From e8da279b6653a02a67563b5a673939fbbb6b3050 Mon Sep 17 00:00:00 2001 From: makspll Date: Thu, 6 Nov 2025 22:23:27 +0000 Subject: [PATCH 01/22] WIP --- Cargo.toml | 65 +-- .../src/function/script_function.rs | 4 +- .../src/reference.rs | 5 +- .../src/schedule.rs | 26 +- .../src/script_component.rs | 2 +- .../bevy_mod_scripting_bindings/src/world.rs | 8 +- crates/bevy_mod_scripting_core/Cargo.toml | 1 + .../bevy_mod_scripting_core/src/commands.rs | 4 +- crates/bevy_mod_scripting_core/src/event.rs | 97 ++-- .../bevy_mod_scripting_core/src/extractors.rs | 428 +++++++++--------- crates/bevy_mod_scripting_core/src/handler.rs | 35 +- crates/bevy_mod_scripting_core/src/lib.rs | 6 +- .../src/pipeline/start.rs | 19 +- .../src/script/context_key.rs | 25 +- .../bevy_mod_scripting_core/src/script/mod.rs | 25 +- .../src/script/script_context.rs | 26 +- .../src/script_system.rs | 115 ++--- crates/bevy_mod_scripting_script/src/lib.rs | 12 - crates/bevy_system_reflection/src/lib.rs | 15 +- .../test_utils/src/test_data.rs | 4 +- 20 files changed, 445 insertions(+), 477 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 9ec235d467..0192599bc4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -140,53 +140,54 @@ lua_language_server_lad_backend = { path = "crates/lad_backends/lua_language_ser # bevy bevy_mod_scripting_core = { path = "crates/bevy_mod_scripting_core", version = "0.16.1" } -bevy = { version = "0.16.0", default-features = false } -bevy_math = { version = "0.16.0", default-features = false, features = ["std"] } -bevy_transform = { version = "0.16.0", default-features = false } -bevy_reflect = { version = "0.16.0", default-features = false } -bevy_ecs = { version = "0.16.0", default-features = false } -bevy_asset = { version = "0.16.0", default-features = false } -bevy_app = { version = "0.16.0", default-features = false } -bevy_log = { version = "0.16.0", default-features = false } -bevy_internal = { version = "0.16.0", default-features = false } -bevy_diagnostic = { version = "0.16.0", default-features = false } -bevy_platform = { version = "0.16.0", default-features = false } -bevy_time = { version = "0.16.0", default-features = false } -bevy_input = { version = "0.16.0", default-features = false } -bevy_a11y = { version = "0.16.0", default-features = false, features = [ +bevy = { version = "0.17", default-features = false } +bevy_math = { version = "0.17", default-features = false, features = ["std"] } +bevy_transform = { version = "0.17", default-features = false } +bevy_reflect = { version = "0.17", default-features = false } +bevy_ecs = { version = "0.17", default-features = false } +bevy_asset = { version = "0.17", default-features = false } +bevy_app = { version = "0.17", default-features = false } +bevy_log = { version = "0.17", default-features = false } +bevy_internal = { version = "0.17", default-features = false } +bevy_diagnostic = { version = "0.17", default-features = false } +bevy_platform = { version = "0.17", default-features = false } +bevy_time = { version = "0.17", default-features = false } +bevy_input = { version = "0.17", default-features = false } +bevy_a11y = { version = "0.17", default-features = false, features = [ "std", "bevy_reflect", ] } -bevy_animation = { version = "0.16.0", default-features = false } -bevy_color = { version = "0.16.0", default-features = false, features = [ +bevy_animation = { version = "0.17", default-features = false } +bevy_color = { version = "0.17", default-features = false, features = [ "std", "bevy_reflect", ] } -bevy_core_pipeline = { version = "0.16.0", default-features = false } -bevy_gizmos = { version = "0.16.0", default-features = false } -bevy_gltf = { version = "0.16.0", default-features = false } -bevy_image = { version = "0.16.0", default-features = false, features = [ +bevy_core_pipeline = { version = "0.17", default-features = false } +bevy_gizmos = { version = "0.17", default-features = false } +bevy_gltf = { version = "0.17", default-features = false } +bevy_image = { version = "0.17", default-features = false, features = [ "bevy_reflect", ] } -bevy_input_focus = { version = "0.16.0", default-features = false, features = [ +bevy_input_focus = { version = "0.17", default-features = false, features = [ "std", "bevy_reflect", ] } -bevy_mesh = { version = "0.16.0", default-features = false } -bevy_pbr = { version = "0.16.0", default-features = false } -bevy_picking = { version = "0.16.0", default-features = false } -bevy_render = { version = "0.16.0", default-features = false } -bevy_scene = { version = "0.16.0", default-features = false } -bevy_sprite = { version = "0.16.0", default-features = false } -bevy_text = { version = "0.16.0", default-features = false } -bevy_window = { version = "0.16.0", default-features = false, features = [ +bevy_mesh = { version = "0.17", default-features = false } +bevy_pbr = { version = "0.17", default-features = false } +bevy_picking = { version = "0.17", default-features = false } +bevy_render = { version = "0.17", default-features = false } +bevy_scene = { version = "0.17", default-features = false } +bevy_sprite = { version = "0.17", default-features = false } +bevy_text = { version = "0.17", default-features = false } +bevy_window = { version = "0.17", default-features = false, features = [ "bevy_reflect", "std", ] } -bevy_winit = { version = "0.16.0", default-features = false } +bevy_winit = { version = "0.17", default-features = false } +bevy_utils = { version = "0.17", default-features = false, features = ["std"] } -glam = { version = "0.29.3", default-features = false } -uuid = { version = "1.11", default-features = false } +glam = { version = "0.30.7", default-features = false } +uuid = { version = "1.13", default-features = false } smol_str = { version = "0.2.0", default-features = false } # other diff --git a/crates/bevy_mod_scripting_bindings/src/function/script_function.rs b/crates/bevy_mod_scripting_bindings/src/function/script_function.rs index e8860ea70c..b578d5c77a 100644 --- a/crates/bevy_mod_scripting_bindings/src/function/script_function.rs +++ b/crates/bevy_mod_scripting_bindings/src/function/script_function.rs @@ -724,7 +724,7 @@ variadics_please::all_tuples!(impl_script_function, 0, 13, T); #[cfg(test)] mod test { use super::*; - use bevy_asset::{AssetId, Handle}; + use bevy_asset::Handle; use bevy_ecs::{prelude::Component, world::World}; use bevy_mod_scripting_script::ScriptAttachment; @@ -734,7 +734,7 @@ mod test { ThreadWorldContainer .set_context(crate::ThreadScriptContext { world, - attachment: ScriptAttachment::StaticScript(Handle::Weak(AssetId::invalid())), + attachment: ScriptAttachment::StaticScript(Handle::default()), }) .unwrap(); f() diff --git a/crates/bevy_mod_scripting_bindings/src/reference.rs b/crates/bevy_mod_scripting_bindings/src/reference.rs index 46693d99e1..9666bfd2fb 100644 --- a/crates/bevy_mod_scripting_bindings/src/reference.rs +++ b/crates/bevy_mod_scripting_bindings/src/reference.rs @@ -17,7 +17,6 @@ use bevy_mod_scripting_display::{ DebugWithTypeInfo, DisplayWithTypeInfo, OrFakeId, PrintReflectAsDebug, WithTypeInfo, }; use bevy_reflect::{Access, OffsetAccess, ReflectRef, TypeRegistry}; -use core::alloc; use std::{ any::{Any, TypeId}, fmt::Debug, @@ -323,8 +322,8 @@ impl ReflectReference { // Safety: The caller guarantees exclusive access to the asset through the WorldGuard, // and we've validated that the type_id matches the ReflectAsset type data. // The UnsafeWorldCell is valid for the lifetime 'w of the WorldGuard. - let asset = unsafe { reflect_asset.get_unchecked_mut(world_cell, handle.clone()) } - .ok_or_else(|| { + let asset = + unsafe { reflect_asset.get_unchecked_mut(world_cell, handle) }.ok_or_else(|| { InteropError::unsupported_operation( Some(self.base.type_id), None, diff --git a/crates/bevy_mod_scripting_bindings/src/schedule.rs b/crates/bevy_mod_scripting_bindings/src/schedule.rs index b4d380616e..dff25ee5ba 100644 --- a/crates/bevy_mod_scripting_bindings/src/schedule.rs +++ b/crates/bevy_mod_scripting_bindings/src/schedule.rs @@ -201,7 +201,7 @@ mod tests { bevy_app::{App, Plugin, Update}, bevy_ecs::{ entity::Entity, - schedule::{NodeId, Schedules}, + schedule::{NodeId, Schedules, SystemKey}, system::IntoSystem, }, std::{cell::OnceCell, rc::Rc}, @@ -236,7 +236,7 @@ mod tests { #[test] fn test_reflect_system_names() { let system = IntoSystem::into_system(test_system_generic::); - let system = ReflectSystem::from_system(&system, NodeId::Set(0)); + let system = ReflectSystem::from_system(&system, SystemKey::default()); assert_eq!(system.identifier(), "test_system_generic"); assert_eq!( @@ -245,7 +245,7 @@ mod tests { ); let system = IntoSystem::into_system(test_system); - let system = ReflectSystem::from_system(&system, NodeId::Set(0)); + let system = ReflectSystem::from_system(&system, SystemKey::default()); assert_eq!(system.identifier(), "test_system"); assert_eq!( @@ -314,16 +314,24 @@ mod tests { let resolve_name = |node_id: NodeId| { let out = { - // try systems - if let Some(system) = graph.get_system_at(node_id) { - system.name().clone().to_string() - } else if let Some(system_set) = graph.get_set_at(node_id) { - format!("{system_set:?}").to_string() + let name = match node_id { + NodeId::System(system_key) => graph + .systems + .get(system_key) + .map(|system| system.system.name().clone().to_string()), + NodeId::Set(system_set_key) => graph + .system_sets + .get(system_set_key) + .map(|set| format!("{set:?}").to_string()), + }; + + if let Some(name) = name { + name } else { // try schedule systems let mut default = format!("{node_id:?}").to_string(); for (system_node, system) in schedule.systems().unwrap() { - if node_id == system_node { + if node_id == NodeId::System(system_node) { default = system.name().clone().to_string(); } } diff --git a/crates/bevy_mod_scripting_bindings/src/script_component.rs b/crates/bevy_mod_scripting_bindings/src/script_component.rs index 4bf333a114..a72ea2df90 100644 --- a/crates/bevy_mod_scripting_bindings/src/script_component.rs +++ b/crates/bevy_mod_scripting_bindings/src/script_component.rs @@ -165,6 +165,6 @@ mod test { .get_info(info.registration.component_id) .unwrap(); - assert_eq!(component.name(), "ScriptTest"); + assert_eq!(component.name(), "ScriptTest".into()); } } diff --git a/crates/bevy_mod_scripting_bindings/src/world.rs b/crates/bevy_mod_scripting_bindings/src/world.rs index 5b98d7eb8d..ac96c7ebf3 100644 --- a/crates/bevy_mod_scripting_bindings/src/world.rs +++ b/crates/bevy_mod_scripting_bindings/src/world.rs @@ -43,6 +43,7 @@ use ::{ PartialReflect, TypeRegistryArc, std_traits::ReflectDefault, }, }; +use bevy_asset::AssetPath; use bevy_ecs::{ component::Mutable, hierarchy::{ChildOf, Children}, @@ -906,7 +907,10 @@ impl WorldAccessGuard<'_> { } /// Loads a script from the given asset path with default settings. - pub fn load_script_asset(&self, asset_path: &str) -> Result, InteropError> { + pub fn load_script_asset<'a>( + &self, + asset_path: impl Into>, + ) -> Result, InteropError> { self.with_resource(|r: &AssetServer| r.load(asset_path)) } @@ -1337,7 +1341,7 @@ impl WorldAccessGuard<'_> { /// Sends AppExit event to the world with success status pub fn exit(&self) -> Result<(), InteropError> { self.with_global_access(|world| { - world.send_event(AppExit::Success); + world.write_message(AppExit::Success); }) } } diff --git a/crates/bevy_mod_scripting_core/Cargo.toml b/crates/bevy_mod_scripting_core/Cargo.toml index 25ed1685d3..f3189f40a7 100644 --- a/crates/bevy_mod_scripting_core/Cargo.toml +++ b/crates/bevy_mod_scripting_core/Cargo.toml @@ -33,6 +33,7 @@ bevy_log = { workspace = true, default-features = false, features = [] } bevy_asset = { workspace = true, default-features = false, features = [] } bevy_diagnostic = { workspace = true, default-features = false, features = [] } bevy_platform = { workspace = true, default-features = false, features = [] } +bevy_utils = { workspace = true } parking_lot = { workspace = true } smallvec = { workspace = true } diff --git a/crates/bevy_mod_scripting_core/src/commands.rs b/crates/bevy_mod_scripting_core/src/commands.rs index 3fd9efa9c3..3fdb3291ae 100644 --- a/crates/bevy_mod_scripting_core/src/commands.rs +++ b/crates/bevy_mod_scripting_core/src/commands.rs @@ -175,14 +175,14 @@ impl DetachScript

{ impl Command for AttachScript

{ fn apply(self, world: &mut World) { - world.send_event(self.0); + world.write_message(self.0); RunProcessingPipelineOnce::

::new(Some(Duration::from_secs(9999))).apply(world) } } impl Command for DetachScript

{ fn apply(self, world: &mut World) { - world.send_event(self.0); + world.write_message(self.0); RunProcessingPipelineOnce::

::new(Some(Duration::from_secs(9999))).apply(world) } } diff --git a/crates/bevy_mod_scripting_core/src/event.rs b/crates/bevy_mod_scripting_core/src/event.rs index 86667e589b..c4c873d240 100644 --- a/crates/bevy_mod_scripting_core/src/event.rs +++ b/crates/bevy_mod_scripting_core/src/event.rs @@ -2,8 +2,8 @@ use std::{marker::PhantomData, sync::Arc}; -use ::{bevy_asset::Handle, bevy_ecs::entity::Entity, bevy_reflect::Reflect}; -use bevy_ecs::event::Event; +use ::{bevy_ecs::entity::Entity, bevy_reflect::Reflect}; +use bevy_ecs::message::Message; use bevy_mod_scripting_asset::Language; use bevy_mod_scripting_bindings::ScriptValue; use bevy_mod_scripting_script::ScriptAttachment; @@ -16,7 +16,7 @@ use crate::{ }; /// An error coming from a script -#[derive(Debug, Event)] +#[derive(Debug, Message)] pub struct ScriptErrorEvent { /// The script that caused the error pub error: ScriptError, @@ -30,18 +30,18 @@ impl ScriptErrorEvent { } /// Emitted when a script is attached. -#[derive(Event, Clone, Debug)] +#[derive(Message, Clone, Debug)] pub struct ScriptAttachedEvent(pub ScriptAttachment); /// Emitted when a script is detached. -#[derive(Event, Clone, Debug)] +#[derive(Message, Clone, Debug)] pub struct ScriptDetachedEvent(pub ScriptAttachment); /// Emitted when a script asset is modified and all its attachments require re-loading -#[derive(Event, Clone, Debug)] +#[derive(Message, Clone, Debug)] pub struct ScriptAssetModifiedEvent(pub ScriptId); -#[derive(Event)] +#[derive(Message)] /// Wrapper around a script event making it available to read by a specific plugin only pub struct ForPlugin(T, PhantomData); @@ -65,8 +65,8 @@ impl Clone for ForPlugin { impl ForPlugin { /// Creates a new wrapper for the specific plugin - pub fn new(event: T) -> Self { - Self(event, Default::default()) + pub fn new(Message: T) -> Self { + Self(Message, Default::default()) } /// Retrieves the inner event @@ -218,7 +218,7 @@ impl Recipients { Recipients::AllScripts => script_context.all_residents().collect(), Recipients::AllContexts => script_context.first_resident_from_each_context().collect(), Recipients::ScriptEntity(script, entity) => { - let attachment = ScriptAttachment::EntityScript(*entity, Handle::Weak(*script)); + let attachment = ScriptAttachment::EntityScript(*entity, script.clone()); script_context .get_context(&attachment) .into_iter() @@ -226,7 +226,7 @@ impl Recipients { .collect() } Recipients::StaticScript(script) => { - let attachment = ScriptAttachment::StaticScript(Handle::Weak(*script)); + let attachment = ScriptAttachment::StaticScript(script.clone()); script_context .get_context(&attachment) .into_iter() @@ -238,7 +238,7 @@ impl Recipients { } /// A callback event meant to trigger a callback in a subset/set of scripts in the world with the given arguments -#[derive(Clone, Event, Debug)] +#[derive(Clone, Message, Debug)] #[non_exhaustive] pub struct ScriptCallbackEvent { /// The label of the callback @@ -290,7 +290,7 @@ impl ScriptCallbackEvent { } /// Event published when a script completes a callback and a response is requested. -#[derive(Clone, Event, Debug)] +#[derive(Clone, Message, Debug)] #[non_exhaustive] pub struct ScriptCallbackResponseEvent { /// the label of the callback @@ -419,11 +419,12 @@ mod test { use ::{ bevy_app::{App, Plugin}, - bevy_asset::{AssetId, AssetIndex, Handle}, + bevy_asset::{AssetId, Handle}, bevy_ecs::entity::Entity, }; use parking_lot::Mutex; use test_utils::make_test_plugin; + use uuid::uuid; use super::FORBIDDEN_KEYWORDS; use crate::{ @@ -476,18 +477,18 @@ mod test { /// make the following arrangement: /// use AssetId's to identify residents /// ContextA: - /// - EntityScriptA (Entity::from_raw(0), AssetId::from_bits(0)) - /// - EntityScriptB (Entity::from_raw(0), AssetId::from_bits(1)) + /// - EntityScriptA (Entity::from_raw(0), 163f1128-62f9-456f-9b76-a326fbe86fa8) + /// - EntityScriptB (Entity::from_raw(0), 263f1128-62f9-456f-9b76-a326fbe86fa8) /// /// ContextB: - /// - EntityScriptC (Entity::from_raw(1), AssetId::from_bits(2)) - /// - EntityScriptD (Entity::from_raw(1), AssetId::from_bits(3)) + /// - EntityScriptC (Entity::from_raw(1), 363f1128-62f9-456f-9b76-a326fbe86fa8) + /// - EntityScriptD (Entity::from_raw(1), 463f1128-62f9-456f-9b76-a326fbe86fa8) /// /// ContextC: - /// - StaticScriptA (AssetId::from_bits(4)) + /// - StaticScriptA (563f1128-62f9-456f-9b76-a326fbe86fa8) /// /// ContextD: - /// - StaticScriptB (AssetId::from_bits(5)) + /// - StaticScriptB (663f1128-62f9-456f-9b76-a326fbe86fa8) fn make_test_contexts() -> ScriptContext { let policy = ContextPolicy::per_entity(); let script_context = ScriptContext::::new(policy); @@ -505,37 +506,55 @@ mod test { invocations: vec![ScriptValue::String("d".to_string().into())], })); - let entity_script_a = Handle::Weak(AssetId::from(AssetIndex::from_bits(0))); - let entity_script_b = Handle::Weak(AssetId::from(AssetIndex::from_bits(1))); - let entity_script_c = Handle::Weak(AssetId::from(AssetIndex::from_bits(2))); - let entity_script_d = Handle::Weak(AssetId::from(AssetIndex::from_bits(3))); + let entity_script_a = Handle::Uuid( + uuid!("163f1128-62f9-456f-9b76-a326fbe86fa8"), + Default::default(), + ); + let entity_script_b = Handle::Uuid( + uuid!("263f1128-62f9-456f-9b76-a326fbe86fa8"), + Default::default(), + ); + let entity_script_c = Handle::Uuid( + uuid!("363f1128-62f9-456f-9b76-a326fbe86fa8"), + Default::default(), + ); + let entity_script_d = Handle::Uuid( + uuid!("463f1128-62f9-456f-9b76-a326fbe86fa8"), + Default::default(), + ); - let static_script_a = Handle::Weak(AssetId::from(AssetIndex::from_bits(4))); - let static_script_b = Handle::Weak(AssetId::from(AssetIndex::from_bits(5))); + let static_script_a = Handle::Uuid( + uuid!("563f1128-62f9-456f-9b76-a326fbe86fa8"), + Default::default(), + ); + let static_script_b = Handle::Uuid( + uuid!("663f1128-62f9-456f-9b76-a326fbe86fa8"), + Default::default(), + ); script_context_guard .insert( - ScriptAttachment::EntityScript(Entity::from_raw(0), entity_script_a), + ScriptAttachment::EntityScript(Entity::from_raw_u32(0).unwrap(), entity_script_a), context_a, ) .unwrap(); script_context_guard .insert_resident(ScriptAttachment::EntityScript( - Entity::from_raw(0), + Entity::from_raw_u32(0).unwrap(), entity_script_b, )) .unwrap(); script_context_guard .insert( - ScriptAttachment::EntityScript(Entity::from_raw(1), entity_script_c), + ScriptAttachment::EntityScript(Entity::from_raw_u32(1).unwrap(), entity_script_c), context_b, ) .unwrap(); script_context_guard .insert_resident(ScriptAttachment::EntityScript( - Entity::from_raw(1), + Entity::from_raw_u32(1).unwrap(), entity_script_d, )) .unwrap(); @@ -629,9 +648,14 @@ mod test { #[test] fn test_script_entity_recipients() { let script_context = make_test_contexts(); - let recipients = - Recipients::ScriptEntity(AssetId::from(AssetIndex::from_bits(0)), Entity::from_raw(0)) - .get_recipients(script_context); + let recipients = Recipients::ScriptEntity( + Handle::Uuid( + uuid!("163f1128-62f9-456f-9b76-a326fbe86fa8"), + Default::default(), + ), + Entity::from_raw_u32(0).unwrap(), + ) + .get_recipients(script_context); assert_eq!(recipients.len(), 1); let id_context_pairs = recipients_to_asset_ids(&recipients); @@ -641,8 +665,11 @@ mod test { #[test] fn test_static_script_recipients() { let script_context = make_test_contexts(); - let recipients = Recipients::StaticScript(AssetId::from(AssetIndex::from_bits(4))) - .get_recipients(script_context); + let recipients = Recipients::StaticScript(Handle::Uuid( + uuid!("563f1128-62f9-456f-9b76-a326fbe86fa8"), + Default::default(), + )) + .get_recipients(script_context); assert_eq!(recipients.len(), 1); let id_context_pairs = recipients_to_asset_ids(&recipients); diff --git a/crates/bevy_mod_scripting_core/src/extractors.rs b/crates/bevy_mod_scripting_core/src/extractors.rs index 4973e199c6..9a5cc6574e 100644 --- a/crates/bevy_mod_scripting_core/src/extractors.rs +++ b/crates/bevy_mod_scripting_core/src/extractors.rs @@ -3,126 +3,134 @@ //! These are designed to be used to pipe inputs into other systems which require them, while handling any configuration erorrs nicely. use bevy_ecs::{ - archetype::Archetype, - component::{ComponentId, Tick}, + component::ComponentId, query::{Access, AccessConflicts}, storage::SparseSetIndex, - system::{SystemMeta, SystemParam, SystemParamValidationError}, - world::{DeferredWorld, World, unsafe_world_cell::UnsafeWorldCell}, }; -use bevy_mod_scripting_bindings::{WorldAccessGuard, WorldGuard, access_map::ReflectAccessId}; +use bevy_mod_scripting_bindings::access_map::ReflectAccessId; use fixedbitset::FixedBitSet; -/// A wrapper around a world which pre-populates access, to safely co-exist with other system params, -/// acts exactly like `&mut World` so this should be your only top-level system param -/// -/// The reason is the guard needs to know the underlying access that -pub struct WithWorldGuard<'w, 's, T: SystemParam> { - world_guard: WorldGuard<'w>, - param: T::Item<'w, 's>, -} - -impl<'w, 's, T: SystemParam> WithWorldGuard<'w, 's, T> { - /// Get the world guard and the inner system param - pub fn get(&self) -> (WorldGuard<'w>, &T::Item<'w, 's>) { - (self.world_guard.clone(), &self.param) - } - - /// Get the world guard and the inner system param mutably - pub fn get_mut(&mut self) -> (WorldGuard<'w>, &mut T::Item<'w, 's>) { - (self.world_guard.clone(), &mut self.param) - } -} - -unsafe impl SystemParam for WithWorldGuard<'_, '_, T> { - type State = (T::State, Vec<(ReflectAccessId, bool)>); - - type Item<'world, 'state> = WithWorldGuard<'world, 'state, T>; - - fn init_state(world: &mut World, system_meta: &mut SystemMeta) -> Self::State { - // verify there are no accesses previously - let other_accessed_components = - system_meta.component_access_set().combined_access().clone(); - - let inner_state = T::init_state(world, system_meta); - - let accessed_components = system_meta.component_access_set().combined_access(); - let access_ids = get_all_access_ids(accessed_components); - let other_access_ids = get_all_access_ids(&other_accessed_components); - - // reason: we can't handle this error nicely, and continuing is a safety issue - #[allow(clippy::panic)] - if !other_access_ids.is_empty() { - panic!( - "WithWorldGuard must be the only top-level system param, cannot run system: `{}`", - system_meta.name() - ); - } - - // Safety: not removing any accesses - unsafe { system_meta.component_access_set_mut().write_all() } - unsafe { system_meta.archetype_component_access_mut().write_all() } - (inner_state, access_ids) - } - - unsafe fn get_param<'world, 'state>( - state: &'state mut Self::State, - system_meta: &SystemMeta, - world: UnsafeWorldCell<'world>, - change_tick: Tick, - ) -> Self::Item<'world, 'state> { - // create a guard which can only access the resources/components specified by the system. - let guard = WorldAccessGuard::new_exclusive(unsafe { world.world_mut() }); - - #[allow( - clippy::panic, - reason = "This API does not allow us to handle this error nicely, and continuing is a safety issue." - )] - for (raid, is_write) in &state.1 { - if *is_write { - if !guard.claim_write_access(*raid) { - panic!( - "System tried to access set of system params which break rust aliasing rules. Aliasing access: {raid:#?}", - ); - } - } else if !guard.claim_read_access(*raid) { - panic!( - "System tried to access set of system params which break rust aliasing rules. Aliasing access: {raid:#?}", - ); - } - } - - WithWorldGuard { - world_guard: guard, - param: unsafe { T::get_param(&mut state.0, system_meta, world, change_tick) }, - } - } - - unsafe fn new_archetype( - state: &mut Self::State, - archetype: &Archetype, - system_meta: &mut SystemMeta, - ) { - unsafe { T::new_archetype(&mut state.0, archetype, system_meta) } - } - - fn apply(state: &mut Self::State, system_meta: &SystemMeta, world: &mut World) { - T::apply(&mut state.0, system_meta, world) - } - - fn queue(state: &mut Self::State, system_meta: &SystemMeta, world: DeferredWorld) { - T::queue(&mut state.0, system_meta, world) - } - - unsafe fn validate_param( - state: &Self::State, - system_meta: &SystemMeta, - world: UnsafeWorldCell, - ) -> Result<(), SystemParamValidationError> { - unsafe { T::validate_param(&state.0, system_meta, world) } - } -} +// /// A wrapper around a world which pre-populates access, to safely co-exist with other system params, +// /// acts exactly like `&mut World` so this should be your only top-level system param +// /// +// /// The reason is the guard needs to know the underlying access that +// pub struct WithWorldGuard<'w, 's, T: SystemParam> { +// world_guard: WorldGuard<'w>, +// param: T::Item<'w, 's>, +// } + +// impl<'w, 's, T: SystemParam> WithWorldGuard<'w, 's, T> { +// /// Get the world guard and the inner system param +// pub fn get(&self) -> (WorldGuard<'w>, &T::Item<'w, 's>) { +// (self.world_guard.clone(), &self.param) +// } + +// /// Get the world guard and the inner system param mutably +// pub fn get_mut(&mut self) -> (WorldGuard<'w>, &mut T::Item<'w, 's>) { +// (self.world_guard.clone(), &mut self.param) +// } +// } + +// unsafe impl SystemParam for WithWorldGuard<'_, '_, T> { +// type State = (T::State, Vec<(ReflectAccessId, bool)>); + +// type Item<'world, 'state> = WithWorldGuard<'world, 'state, T>; + +// fn init_access( +// _state: &Self::State, +// _system_meta: &mut SystemMeta, +// component_access_set: &mut bevy_ecs::query::FilteredAccessSet, +// _world: &mut World, +// ) { +// // verify there are no accesses previously +// // let other_accessed_components = component_access_set.combined_access().clone(); + +// // let accessed_components = component_access_set.combined_access(); +// // let access_ids = get_all_access_ids(accessed_components); +// // let other_access_ids = get_all_access_ids(&other_accessed_components); + +// // reason: we can't handle this error nicely, and continuing is a safety issue +// // #[allow(clippy::panic)] +// // if !other_access_ids.is_empty() { +// // panic!( +// // "WithWorldGuard must be the only top-level system param, cannot run system: `{}`", +// // system_meta.name() +// // ); +// // } + +// // Safety: not removing any accesses +// component_access_set.write_all() +// } + +// fn init_state(world: &mut World) -> Self::State { +// // // verify there are no accesses previously +// // let other_accessed_components = +// // system_meta.component_access_set().combined_access().clone(); + +// // let inner_state = T::init_state(world); + +// // let accessed_components = system_meta.component_access_set().combined_access(); +// // let inner_state = T::init_access(T::init_state(world)); +// // let access_ids = get_all_access_ids(accessed_components); +// // let other_access_ids = get_all_access_ids(&other_accessed_components); + +// (T::init_state(world), vec![]) +// } + +// unsafe fn get_param<'world, 'state>( +// state: &'state mut (T::State, Vec<(ReflectAccessId, bool)>), +// system_meta: &SystemMeta, +// world: UnsafeWorldCell<'world>, +// change_tick: Tick, +// ) -> Self::Item<'world, 'state> { +// if state.1.is_empty() { +// T::init_access() +// } + +// // create a guard which can only access the resources/components specified by the system. +// let guard = WorldAccessGuard::new_exclusive(unsafe { world.world_mut() }); + +// #[allow( +// clippy::panic, +// reason = "This API does not allow us to handle this error nicely, and continuing is a safety issue." +// )] +// for (raid, is_write) in &state.1 { +// if *is_write { +// if !guard.claim_write_access(*raid) { +// panic!( +// "System tried to access set of system params which break rust aliasing rules. Aliasing access: {raid:#?}", +// ); +// } +// } else if !guard.claim_read_access(*raid) { +// panic!( +// "System tried to access set of system params which break rust aliasing rules. Aliasing access: {raid:#?}", +// ); +// } +// } + +// WithWorldGuard { +// world_guard: guard, +// param: unsafe { T::get_param(&mut state.0, system_meta, world, change_tick) }, +// } +// } + +// fn apply(state: &mut Self::State, system_meta: &SystemMeta, world: &mut World) { +// T::apply(&mut state.0, system_meta, world) +// } + +// fn queue(state: &mut Self::State, system_meta: &SystemMeta, world: DeferredWorld) { +// T::queue(&mut state.0, system_meta, world) +// } + +// unsafe fn validate_param( +// state: &mut Self::State, +// system_meta: &SystemMeta, +// world: UnsafeWorldCell, +// ) -> Result<(), SystemParamValidationError> { +// unsafe { T::validate_param(&mut state.0, system_meta, world) } +// } +// } fn individual_conflicts(conflicts: AccessConflicts) -> FixedBitSet { match conflicts { @@ -132,11 +140,11 @@ fn individual_conflicts(conflicts: AccessConflicts) -> FixedBitSet { } } -pub(crate) fn get_all_access_ids(access: &Access) -> Vec<(ReflectAccessId, bool)> { - let mut access_all_read = Access::::default(); +pub(crate) fn get_all_access_ids(access: &Access) -> Vec<(ReflectAccessId, bool)> { + let mut access_all_read = Access::default(); access_all_read.read_all(); - let mut access_all_write = Access::::default(); + let mut access_all_write = Access::default(); access_all_write.write_all(); // read conflicts with each set to figure out the necessary locks @@ -164,96 +172,96 @@ pub(crate) fn get_all_access_ids(access: &Access) -> Vec<(ReflectAc result } -#[cfg(test)] -mod test { - use crate::config::{GetPluginThreadConfig, ScriptingPluginConfiguration}; - use bevy_ecs::resource::Resource; - use bevy_mod_scripting_bindings::ScriptValue; - use test_utils::make_test_plugin; - - use { - bevy_app::{App, Plugin, Update}, - bevy_ecs::{ - component::Component, - entity::Entity, - event::{Event, EventReader}, - system::{Query, ResMut}, - }, - }; - - use super::*; - - make_test_plugin!(crate); - - #[derive(Component)] - struct Comp; - - #[derive(Resource, Default)] - struct Res; - - #[test] - pub fn check_with_world_correctly_locks_resource_and_component() { - let system_fn = |mut guard: WithWorldGuard<(ResMut, Query<&'static Comp>)>| { - let (guard, (_res, _entity)) = guard.get_mut(); - assert_eq!(guard.list_accesses().len(), 2, "Expected 2 accesses"); - assert!( - !guard.claim_read_access( - ReflectAccessId::for_resource::(&guard.as_unsafe_world_cell().unwrap()) - .unwrap() - ) - ); - assert!( - !guard.claim_write_access( - ReflectAccessId::for_resource::(&guard.as_unsafe_world_cell().unwrap()) - .unwrap() - ) - ); - }; - - let mut app = App::new(); - app.add_systems(Update, system_fn); - app.insert_resource(Res); - app.world_mut().spawn(Comp); - - app.cleanup(); - app.finish(); - app.update(); - } - - #[test] - #[should_panic( - expected = "WithWorldGuard must be the only top-level system param, cannot run system" - )] - pub fn check_with_world_panics_when_used_with_resource_top_level() { - let system_fn = |_res: ResMut, mut _guard: WithWorldGuard>| {}; - - let mut app = App::new(); - app.add_systems(Update, system_fn); - app.insert_resource(Res); - app.world_mut().spawn(Comp); - - app.cleanup(); - app.finish(); - app.update(); - } - - #[test] - #[should_panic( - expected = "WithWorldGuard must be the only top-level system param, cannot run system" - )] - pub fn check_with_world_panics_when_used_with_event_reader_top_level() { - #[derive(Event)] - struct TestEvent; - let system_fn = - |_res: EventReader, mut _guard: WithWorldGuard>| {}; - - let mut app = App::new(); - app.add_systems(Update, system_fn); - app.insert_resource(Res); - app.world_mut().spawn(Comp); - - app.cleanup(); - app.finish(); - app.update(); - } -} +// #[cfg(test)] +// mod test { +// use crate::config::{GetPluginThreadConfig, ScriptingPluginConfiguration}; +// use bevy_ecs::resource::Resource; +// use bevy_mod_scripting_bindings::ScriptValue; +// use test_utils::make_test_plugin; + +// use { +// bevy_app::{App, Plugin, Update}, +// bevy_ecs::{ +// component::Component, +// entity::Entity, +// event::{Event, EventReader}, +// system::{Query, ResMut}, +// }, +// }; + +// use super::*; + +// make_test_plugin!(crate); + +// #[derive(Component)] +// struct Comp; + +// #[derive(Resource, Default)] +// struct Res; + +// #[test] +// pub fn check_with_world_correctly_locks_resource_and_component() { +// let system_fn = |mut guard: WithWorldGuard<(ResMut, Query<&'static Comp>)>| { +// let (guard, (_res, _entity)) = guard.get_mut(); +// assert_eq!(guard.list_accesses().len(), 2, "Expected 2 accesses"); +// assert!( +// !guard.claim_read_access( +// ReflectAccessId::for_resource::(&guard.as_unsafe_world_cell().unwrap()) +// .unwrap() +// ) +// ); +// assert!( +// !guard.claim_write_access( +// ReflectAccessId::for_resource::(&guard.as_unsafe_world_cell().unwrap()) +// .unwrap() +// ) +// ); +// }; + +// let mut app = App::new(); +// app.add_systems(Update, system_fn); +// app.insert_resource(Res); +// app.world_mut().spawn(Comp); + +// app.cleanup(); +// app.finish(); +// app.update(); +// } + +// #[test] +// #[should_panic( +// expected = "WithWorldGuard must be the only top-level system param, cannot run system" +// )] +// pub fn check_with_world_panics_when_used_with_resource_top_level() { +// let system_fn = |_res: ResMut, mut _guard: WithWorldGuard>| {}; + +// let mut app = App::new(); +// app.add_systems(Update, system_fn); +// app.insert_resource(Res); +// app.world_mut().spawn(Comp); + +// app.cleanup(); +// app.finish(); +// app.update(); +// } + +// #[test] +// #[should_panic( +// expected = "WithWorldGuard must be the only top-level system param, cannot run system" +// )] +// pub fn check_with_world_panics_when_used_with_event_reader_top_level() { +// #[derive(Event)] +// struct TestEvent; +// let system_fn = +// |_res: EventReader, mut _guard: WithWorldGuard>| {}; + +// let mut app = App::new(); +// app.add_systems(Update, system_fn); +// app.insert_resource(Res); +// app.world_mut().spawn(Comp); + +// app.cleanup(); +// app.finish(); +// app.update(); +// } +// } diff --git a/crates/bevy_mod_scripting_core/src/handler.rs b/crates/bevy_mod_scripting_core/src/handler.rs index 631e3d15b7..67fca54053 100644 --- a/crates/bevy_mod_scripting_core/src/handler.rs +++ b/crates/bevy_mod_scripting_core/src/handler.rs @@ -1,5 +1,8 @@ //! Contains the logic for handling script callback events -use bevy_ecs::world::WorldId; +use bevy_ecs::{ + message::{MessageCursor, Messages}, + world::WorldId, +}; use bevy_mod_scripting_bindings::{ InteropError, ScriptValue, ThreadScriptContext, ThreadWorldContainer, WorldAccessGuard, WorldGuard, @@ -15,13 +18,10 @@ use crate::{ CallbackLabel, IntoCallbackLabel, ScriptCallbackEvent, ScriptCallbackResponseEvent, ScriptErrorEvent, }, - extractors::WithWorldGuard, script::ScriptContext, }; use { bevy_ecs::{ - event::EventCursor, - event::Events, system::{Local, SystemState}, world::{Mut, World}, }, @@ -90,14 +90,14 @@ impl ScriptingHandler

for P { #[allow(deprecated)] pub fn event_handler( world: &mut World, - state: &mut EventHandlerSystemState, + state: &mut SystemState>>, ) { // we wrap the inner event handler, so that we can guarantee that the handler context is released statically { let script_context = world.get_resource_or_init::>().clone(); let script_callbacks = world.get_resource_or_init::>().clone(); - let (event_cursor, mut guard) = state.get_mut(world); - let (guard, _) = guard.get_mut(); + let event_cursor = state.get_mut(world); + let guard = WorldAccessGuard::new_exclusive(world); event_handler_inner::

( L::into_callback_label(), event_cursor, @@ -108,22 +108,17 @@ pub fn event_handler( } } -type EventHandlerSystemState<'w, 's> = SystemState<( - Local<'s, EventCursor>, - WithWorldGuard<'w, 's, ()>, -)>; - #[profiling::function] #[allow(deprecated)] pub(crate) fn event_handler_inner( callback_label: CallbackLabel, - mut event_cursor: Local>, + mut event_cursor: Local>, script_context: ScriptContext

, script_callbacks: ScriptCallbacks

, guard: WorldAccessGuard, ) { let mut errors = Vec::default(); - let events = guard.with_resource(|events: &Events| { + let events = guard.with_resource(|events: &Messages| { event_cursor .read(events) .filter(|e| e.label == callback_label) @@ -195,8 +190,8 @@ fn collect_errors(call_result: Result, errors: &mut Ve /// Sends a callback response event to the world pub fn send_callback_response(world: WorldGuard, response: ScriptCallbackResponseEvent) { - let err = world.with_resource_mut(|mut events: Mut>| { - events.send(response); + let err = world.with_resource_mut(|mut events: Mut>| { + events.write(response); }); if let Err(err) = err { @@ -213,9 +208,9 @@ pub fn send_script_errors<'e>( errors: impl IntoIterator, ) { let iter = errors.into_iter(); - let err = world.with_resource_mut(|mut error_events: Mut>| { + let err = world.with_resource_mut(|mut error_events: Mut>| { for error in iter { - error_events.send(ScriptErrorEvent { + error_events.write(ScriptErrorEvent { error: error.clone(), }); } @@ -232,10 +227,10 @@ pub fn send_script_errors<'e>( /// A system which receives all script errors and logs them to console pub fn script_error_logger( world: &mut World, - mut errors_cursor: Local>, + mut errors_cursor: Local>, ) { let guard = WorldGuard::new_exclusive(world); - let errors = guard.with_resource(|events: &Events| { + let errors = guard.with_resource(|events: &Messages| { errors_cursor .read(events) .map(|e| e.error.clone()) diff --git a/crates/bevy_mod_scripting_core/src/lib.rs b/crates/bevy_mod_scripting_core/src/lib.rs index 6ddd081a7b..06d8fc8a83 100644 --- a/crates/bevy_mod_scripting_core/src/lib.rs +++ b/crates/bevy_mod_scripting_core/src/lib.rs @@ -336,9 +336,9 @@ pub struct BMSScriptingInfrastructurePlugin { impl Plugin for BMSScriptingInfrastructurePlugin { fn build(&self, app: &mut App) { - app.add_event::() - .add_event::() - .add_event::() + app.add_message::() + .add_message::() + .add_message::() .init_resource::() .init_asset::() .init_resource::() diff --git a/crates/bevy_mod_scripting_core/src/pipeline/start.rs b/crates/bevy_mod_scripting_core/src/pipeline/start.rs index f02b15a111..8b8d990c6e 100644 --- a/crates/bevy_mod_scripting_core/src/pipeline/start.rs +++ b/crates/bevy_mod_scripting_core/src/pipeline/start.rs @@ -1,5 +1,6 @@ use super::*; use bevy_asset::AssetEvent; +use bevy_ecs::message::{MessageReader, MessageWriter}; use bevy_log::{debug, trace}; /// A handle to a script asset which can only be made from a strong handle @@ -8,7 +9,7 @@ pub struct StrongScriptHandle(Handle); impl GetScriptHandle for ScriptAssetModifiedEvent { fn get_script_handle(&self) -> Handle { - Handle::Weak(self.0) + self.0.clone() } } @@ -58,8 +59,8 @@ impl StrongScriptHandle { /// Generate [`ScriptAssetModifiedEvent`]'s from asset modification events, filtering to only forward those matching the plugin's language pub fn filter_script_modifications( - mut events: EventReader>, - mut filtered: EventWriter>, + mut events: MessageReader>, + mut filtered: MessageWriter>, assets: Res>, ) { let mut batch = events.read().filter_map(|e| { @@ -81,7 +82,7 @@ pub fn filter_script_modifications( /// Filters incoming [`ScriptAttachedEvent`]'s leaving only those which match the plugin's language pub fn filter_script_attachments( mut events: LoadedWithHandles, - mut filtered: EventWriter>, + mut filtered: MessageWriter>, ) { let mut batch = events.get_loaded().map(|(mut a, b)| { trace!("dispatching script attachment event for: {a:?}"); @@ -96,8 +97,8 @@ pub fn filter_script_attachments( /// Filters incoming [`ScriptDetachedEvent`]'s leaving only those which are currently attached pub fn filter_script_detachments( - mut events: EventReader, - mut filtered: EventWriter>, + mut events: MessageReader, + mut filtered: MessageWriter>, contexts: Res>, ) { let contexts_guard = contexts.read(); @@ -115,7 +116,7 @@ pub fn filter_script_detachments( /// Process [`ScriptAttachedEvent`]'s and generate loading machines with the [`LoadingInitialized`] and [`ReloadingInitialized`] states pub fn process_attachments( - mut events: EventReader>, + mut events: MessageReader>, mut machines: ResMut>, mut assets: ResMut>, contexts: Res>, @@ -157,7 +158,7 @@ pub fn process_attachments( /// Processes [`ScriptAttachedEvent`]'s and initialized unloading state machines with [`UnloadingInitialized`] states pub fn process_detachments( - mut events: EventReader>, + mut events: MessageReader>, mut machines: ResMut>, contexts: Res>, ) { @@ -181,7 +182,7 @@ pub fn process_detachments( /// Processes [`ScriptAssetModifiedEvent`]'s and initializes loading state machines with [`ReloadingInitialized`] states pub fn process_asset_modifications( - mut events: EventReader>, + mut events: MessageReader>, mut machines: ResMut>, mut assets: ResMut>, contexts: Res>, diff --git a/crates/bevy_mod_scripting_core/src/script/context_key.rs b/crates/bevy_mod_scripting_core/src/script/context_key.rs index 640d32abfe..c043ee0961 100644 --- a/crates/bevy_mod_scripting_core/src/script/context_key.rs +++ b/crates/bevy_mod_scripting_core/src/script/context_key.rs @@ -1,7 +1,8 @@ -use std::fmt; +use std::{fmt, marker::PhantomData}; use bevy_ecs::entity::Entity; use bevy_mod_scripting_display::DisplayProxy; +use uuid::Uuid; use super::*; use crate::ScriptAsset; @@ -56,7 +57,7 @@ impl ContextKey { /// Creates an invalid context key, which should never exist. pub const INVALID: Self = Self { entity: Some(Entity::PLACEHOLDER), - script: Some(Handle::Weak(AssetId::invalid())), + script: Some(Handle::Uuid(Uuid::nil(), PhantomData)), }; /// Creates a shared context key, which is used for shared contexts @@ -80,15 +81,15 @@ impl ContextKey { } } - /// If a script handle is present and is strong, convert it to a weak - /// handle. - pub fn into_weak(mut self) -> Self { - if let Some(script) = &self.script - && script.is_strong() - { - self.script = Some(script.clone_weak()); - } + // /// If a script handle is present and is strong, convert it to a weak + // /// handle. + // pub fn into_weak(mut self) -> Self { + // if let Some(script) = &self.script + // && script.is_strong() + // { + // self.script = Some(script.clone()); + // } - self - } + // self + // } } diff --git a/crates/bevy_mod_scripting_core/src/script/mod.rs b/crates/bevy_mod_scripting_core/src/script/mod.rs index 296d4cb175..c7b7e06892 100644 --- a/crates/bevy_mod_scripting_core/src/script/mod.rs +++ b/crates/bevy_mod_scripting_core/src/script/mod.rs @@ -8,17 +8,16 @@ use std::{ use crate::event::{ScriptAttachedEvent, ScriptDetachedEvent}; use ::{ - bevy_asset::{AssetId, Handle}, + bevy_asset::Handle, bevy_ecs::{ - component::HookContext, entity::Entity, prelude::ReflectComponent, resource::Resource, - world::DeferredWorld, + entity::Entity, prelude::ReflectComponent, resource::Resource, world::DeferredWorld, }, bevy_reflect::Reflect, }; mod context_key; mod script_context; -use bevy_ecs::component::Component; +use bevy_ecs::{component::Component, lifecycle::HookContext}; use bevy_log::trace; use bevy_mod_scripting_asset::ScriptAsset; use bevy_mod_scripting_script::ScriptAttachment; @@ -28,7 +27,7 @@ pub use script_context::*; /// A unique identifier for a script, by default corresponds to the path of the asset excluding the asset source. /// /// I.e. an asset with the path `path/to/asset.ext` will have the script id `path/to/asset.ext` -pub type ScriptId = AssetId; +pub type ScriptId = Handle; #[derive(Component, Reflect, Clone, Default, Debug)] #[reflect(Component)] @@ -67,7 +66,7 @@ impl ScriptComponent { pub fn on_remove(mut world: DeferredWorld, context: HookContext) { let context_keys = Self::get_context_keys_present(&world, context.entity); trace!("on remove hook for script components: {context_keys:?}"); - world.send_event_batch(context_keys.into_iter().map(ScriptDetachedEvent)); + world.write_message_batch(context_keys.into_iter().map(ScriptDetachedEvent)); } /// the lifecycle hook called when a script component is added to an entity, emits an appropriate event so we can handle @@ -75,29 +74,27 @@ impl ScriptComponent { pub fn on_add(mut world: DeferredWorld, context: HookContext) { let context_keys = Self::get_context_keys_present(&world, context.entity); trace!("on add hook for script components: {context_keys:?}"); - world.send_event_batch(context_keys.into_iter().map(ScriptAttachedEvent)); + world.write_message_batch(context_keys.into_iter().map(ScriptAttachedEvent)); } } #[cfg(test)] mod tests { - use bevy_ecs::{event::Events, world::World}; + use bevy_ecs::{message::Messages, world::World}; use super::*; #[test] fn test_component_add() { let mut world = World::new(); - world.init_resource::>(); + world.init_resource::>(); // spawn new script component - let entity = world - .spawn(ScriptComponent::new([Handle::Weak(AssetId::invalid())])) - .id(); + let entity = world.spawn(ScriptComponent::new([Handle::default()])).id(); // check that the event was sent - let mut events = world.resource_mut::>(); + let mut events = world.resource_mut::>(); assert_eq!( - ScriptAttachment::EntityScript(entity, Handle::Weak(AssetId::invalid())), + ScriptAttachment::EntityScript(entity, Handle::default()), events.drain().next().unwrap().0 ); } diff --git a/crates/bevy_mod_scripting_core/src/script/script_context.rs b/crates/bevy_mod_scripting_core/src/script/script_context.rs index 952514b0fd..380de1937d 100644 --- a/crates/bevy_mod_scripting_core/src/script/script_context.rs +++ b/crates/bevy_mod_scripting_core/src/script/script_context.rs @@ -303,13 +303,10 @@ impl ScriptContextInner

{ ) -> Result<(), (ScriptAttachment, Arc>)> { match self.policy.select(&context_key) { Some(key) => { - let entry = self - .map - .entry(key.into_weak()) - .or_insert_with(|| ContextEntry { - context: context.clone(), - residents: HashSet::from_iter([context_key.clone()]), - }); + let entry = self.map.entry(key.clone()).or_insert_with(|| ContextEntry { + context: context.clone(), + residents: HashSet::from_iter([context_key.clone()]), + }); entry.context = context; entry.residents.insert(context_key.clone()); @@ -348,7 +345,7 @@ impl ScriptContextInner

{ context, residents: HashSet::from_iter([context_key.clone()]), // context with a residency of one }; - self.map.insert(key.into_weak(), entry); + self.map.insert(key.clone(), entry); Ok(()) } None => Err(context), @@ -466,7 +463,6 @@ impl Default for ScriptContextInner

{ mod tests { use crate::config::{GetPluginThreadConfig, ScriptingPluginConfiguration}; use bevy_app::{App, Plugin}; - use bevy_asset::AssetIndex; use bevy_mod_scripting_bindings::ScriptValue; use test_utils::make_test_plugin; @@ -480,14 +476,10 @@ mod tests { let script_context = ScriptContext::::new(policy.clone()); let mut script_context = script_context.write(); - let context_key = ScriptAttachment::EntityScript( - Entity::from_raw(1), - Handle::Weak(AssetIndex::from_bits(1).into()), - ); - let context_key2 = ScriptAttachment::EntityScript( - Entity::from_raw(2), - Handle::Weak(AssetIndex::from_bits(1).into()), - ); + let context_key = + ScriptAttachment::EntityScript(Entity::from_raw_u32(1u32).unwrap(), Handle::default()); + let context_key2 = + ScriptAttachment::EntityScript(Entity::from_raw_u32(2u32).unwrap(), Handle::default()); assert_eq!(policy.select(&context_key), policy.select(&context_key2)); script_context diff --git a/crates/bevy_mod_scripting_core/src/script_system.rs b/crates/bevy_mod_scripting_core/src/script_system.rs index 1171a03cd9..212802e7b9 100644 --- a/crates/bevy_mod_scripting_core/src/script_system.rs +++ b/crates/bevy_mod_scripting_core/src/script_system.rs @@ -7,10 +7,10 @@ use crate::{ use ::{ bevy_ecs::{ - archetype::{ArchetypeComponentId, ArchetypeGeneration}, + archetype::ArchetypeGeneration, component::{ComponentId, Tick}, entity::Entity, - query::{Access, FilteredAccess, FilteredAccessSet, QueryState}, + query::{FilteredAccess, FilteredAccessSet, QueryState}, reflect::AppTypeRegistry, schedule::SystemSet, system::{System, SystemParamValidationError}, @@ -18,10 +18,9 @@ use ::{ }, bevy_reflect::Reflect, }; -use bevy_app::DynEq; use bevy_ecs::{ schedule::{InternedSystemSet, IntoScheduleConfigs, Schedule, Schedules}, - system::SystemIn, + system::{RunSystemError, SystemIn, SystemStateFlags}, world::DeferredWorld, }; use bevy_log::{debug, error, info, warn_once}; @@ -33,6 +32,7 @@ use bevy_mod_scripting_bindings::{ }; use bevy_mod_scripting_script::ScriptAttachment; use bevy_system_reflection::{ReflectSchedule, ReflectSystem}; +use bevy_utils::prelude::DebugName; use std::{ any::TypeId, borrow::Cow, collections::HashSet, hash::Hash, marker::PhantomData, ops::Deref, }; @@ -62,14 +62,6 @@ impl SystemSet for ScriptSystemSet { fn dyn_clone(&self) -> Box { Box::new(self.clone()) } - - fn as_dyn_eq(&self) -> &dyn DynEq { - self - } - - fn dyn_hash(&self, mut state: &mut dyn ::core::hash::Hasher) { - self.hash(&mut state); - } } #[derive(Clone)] @@ -227,22 +219,8 @@ pub enum ScriptSystemParam { /// A system specified, created, and added by a script pub struct DynamicScriptSystem { - name: Cow<'static, str>, + name: DebugName, exclusive: bool, - /// The set of component accesses for this system. This is used to determine - /// - soundness issues (e.g. multiple [`SystemParam`]s mutably accessing the same component) - /// - ambiguities in the schedule (e.g. two systems that have some sort of conflicting access) - pub(crate) component_access_set: FilteredAccessSet, - /// This [`Access`] is used to determine which systems can run in parallel with each other - /// in the multithreaded executor. - /// - /// We use a [`ArchetypeComponentId`] as it is more precise than just checking [`ComponentId`]: - /// for example if you have one system with `Query<&mut T, With>` and one system with `Query<&mut T, With>` - /// they conflict if you just look at the [`ComponentId`] of `T`; but if there are no archetypes with - /// both `A`, `B` and `T` then in practice there's no risk of conflict. By using [`ArchetypeComponentId`] - /// we can be more precise because we can check if the existing archetypes of the [`World`] - /// cause a conflict - pub(crate) archetype_component_access: Access, pub(crate) last_run: Tick, target_attachment: ScriptAttachment, archetype_generation: ArchetypeGeneration, @@ -269,48 +247,38 @@ impl bevy_ecs::system::IntoSystem<(), (), IsDynamicSc last_run: Default::default(), target_attachment: builder.attachment, state: None, - component_access_set: Default::default(), - archetype_component_access: Default::default(), _marker: Default::default(), } } } -#[profiling::all_functions] +// #[profiling::all_functions] impl System for DynamicScriptSystem

{ type In = (); type Out = (); - fn name(&self) -> std::borrow::Cow<'static, str> { + fn name(&self) -> DebugName { self.name.clone() } - fn component_access(&self) -> &Access { - self.component_access_set.combined_access() - } - - fn archetype_component_access(&self) -> &Access { - &self.archetype_component_access - } - - fn is_send(&self) -> bool { - !self.is_exclusive() - } - - fn is_exclusive(&self) -> bool { - self.exclusive + fn flags(&self) -> SystemStateFlags { + if self.is_exclusive() { + SystemStateFlags::NON_SEND | SystemStateFlags::EXCLUSIVE + } else { + SystemStateFlags::empty() + } } - fn has_deferred(&self) -> bool { - false - } + // fn component_access(&self) -> &Access { + // self.component_access_set.combined_access() + // } unsafe fn run_unsafe( &mut self, _input: SystemIn<'_, Self>, world: UnsafeWorldCell, - ) -> Self::Out { + ) -> Result { let _change_tick = world.increment_change_tick(); #[allow( @@ -411,9 +379,11 @@ impl System for DynamicScriptSystem

{ self.target_attachment ); } + + Ok(()) } - fn initialize(&mut self, world: &mut World) { + fn initialize(&mut self, world: &mut World) -> FilteredAccessSet { // we need to register all the: // - resources, simple just need the component ID's // - queries, more difficult the queries need to be built, and archetype access registered on top of component access @@ -421,6 +391,7 @@ impl System for DynamicScriptSystem

{ // start with resources let mut subset = HashSet::default(); let mut system_params = Vec::with_capacity(self.system_param_descriptors.len()); + let mut component_access_set = FilteredAccessSet::new(); for param in &self.system_param_descriptors { match param { ScriptSystemParamDescriptor::Res(res) => { @@ -433,10 +404,10 @@ impl System for DynamicScriptSystem

{ }; system_params.push(system_param); - let mut access = FilteredAccess::::matches_nothing(); + let mut access = FilteredAccess::matches_nothing(); access.add_resource_write(component_id); - self.component_access_set.add(access); + component_access_set.add(access); let raid = ReflectAccessId::for_component_id(component_id); #[allow( clippy::panic, @@ -456,8 +427,7 @@ impl System for DynamicScriptSystem

{ let query = query.as_query_state::(world); // Safety: we are not removing - self.component_access_set - .add(query.component_access().clone()); + component_access_set.add(query.component_access().clone()); let new_raids = get_all_access_ids(query.component_access().access()) .into_iter() @@ -496,37 +466,13 @@ impl System for DynamicScriptSystem

{ system_params, script_contexts: world.get_resource_or_init::>().clone(), script_callbacks: world.get_resource_or_init::>().clone(), - }) - } - - fn update_archetype_component_access(&mut self, world: UnsafeWorldCell) { - let archetypes = world.archetypes(); - - let old_generation = - std::mem::replace(&mut self.archetype_generation, archetypes.generation()); + }); - if let Some(state) = &mut self.state { - for archetype in &archetypes[old_generation..] { - for param in &mut state.system_params { - if let ScriptSystemParam::EntityQuery { query, .. } = param { - // SAFETY: The assertion above ensures that the param_state was initialized from `world`. - unsafe { - query.new_archetype(archetype, &mut self.archetype_component_access) - }; - } - } - } - } + component_access_set } - fn check_change_tick(&mut self, change_tick: Tick) { - let last_run = &mut self.last_run; - let this_run = change_tick; - - let age = this_run.get().wrapping_sub(last_run.get()); - if age > Tick::MAX.get() { - *last_run = Tick::new(this_run.get().wrapping_sub(Tick::MAX.get())); - } + fn check_change_tick(&mut self, change_tick: bevy_ecs::component::CheckChangeTicks) { + self.last_run.check_tick(change_tick); } fn get_last_run(&self) -> Tick { @@ -558,7 +504,6 @@ impl System for DynamicScriptSystem

{ fn validate_param(&mut self, world: &World) -> Result<(), SystemParamValidationError> { let world_cell = world.as_unsafe_world_cell_readonly(); - self.update_archetype_component_access(world_cell); // SAFETY: // - We have exclusive access to the entire world. // - `update_archetype_component_access` has been called. @@ -666,7 +611,7 @@ impl ManageScriptSystems for WorldGuard<'_> { mod test { use ::{ bevy_app::{App, MainScheduleOrder, Plugin, Update}, - bevy_asset::{AssetId, AssetPlugin, Handle}, + bevy_asset::{AssetPlugin, Handle}, bevy_diagnostic::DiagnosticsPlugin, bevy_ecs::{ entity::Entity, @@ -727,7 +672,7 @@ mod test { // now dynamically add script system via builder, without a matching script let mut builder = ScriptSystemBuilder::new( "test".into(), - ScriptAttachment::StaticScript(Handle::Weak(AssetId::invalid())), + ScriptAttachment::StaticScript(Handle::default()), ); builder.before_system(test_system); diff --git a/crates/bevy_mod_scripting_script/src/lib.rs b/crates/bevy_mod_scripting_script/src/lib.rs index ae84fc343c..285a36603e 100644 --- a/crates/bevy_mod_scripting_script/src/lib.rs +++ b/crates/bevy_mod_scripting_script/src/lib.rs @@ -59,18 +59,6 @@ impl ScriptAttachment { } } - /// Downcasts any script handles into weak handles. - pub fn into_weak(self) -> Self { - match self { - ScriptAttachment::EntityScript(entity, script) => { - ScriptAttachment::EntityScript(entity, script.clone_weak()) - } - ScriptAttachment::StaticScript(script) => { - ScriptAttachment::StaticScript(script.clone_weak()) - } - } - } - /// Returns true if the attachment is a static script. pub fn is_static(&self) -> bool { matches!(self, ScriptAttachment::StaticScript(_)) diff --git a/crates/bevy_system_reflection/src/lib.rs b/crates/bevy_system_reflection/src/lib.rs index 85f897def1..5867a10b52 100644 --- a/crates/bevy_system_reflection/src/lib.rs +++ b/crates/bevy_system_reflection/src/lib.rs @@ -11,6 +11,7 @@ use ::{ bevy_platform::collections::{HashMap, HashSet}, bevy_reflect::Reflect, }; +use bevy_ecs::schedule::SystemKey; use bevy_log::warn; use dot_writer::{Attributes, DotWriter}; @@ -47,12 +48,12 @@ impl ReflectSystem { /// Creates a reflect system from a system specification pub fn from_system( system: &dyn System, - node_id: NodeId, + node_id: SystemKey, ) -> Self { ReflectSystem { - name: system.name().clone(), + name: system.name().into(), type_id: system.type_id(), - node_id: ReflectNodeId(node_id), + node_id: ReflectNodeId(NodeId::System(node_id)), default_system_sets: system.default_system_sets(), } } @@ -257,17 +258,17 @@ pub fn schedule_to_reflect_graph(schedule: &Schedule) -> ReflectSystemGraph { let mut nodes = Vec::new(); let mut covered_nodes = HashSet::new(); - for (node_id, system_set, _) in graph.system_sets() { - covered_nodes.insert(node_id); + for (node_id, system_set, _) in graph.system_sets.iter() { + covered_nodes.insert(NodeId::Set(node_id)); nodes.push(ReflectSystemGraphNode::SystemSet( - ReflectSystemSet::from_set(system_set, node_id), + ReflectSystemSet::from_set(system_set, NodeId::Set(node_id)), )); } // for some reason the graph doesn't contain these if let Ok(systems) = schedule.systems() { for (node_id, system) in systems { - covered_nodes.insert(node_id); + covered_nodes.insert(NodeId::System(node_id)); nodes.push(ReflectSystemGraphNode::System(ReflectSystem::from_system( system.as_ref(), node_id, diff --git a/crates/testing_crates/test_utils/src/test_data.rs b/crates/testing_crates/test_utils/src/test_data.rs index e48e940556..4ea8127b5b 100644 --- a/crates/testing_crates/test_utils/src/test_data.rs +++ b/crates/testing_crates/test_utils/src/test_data.rs @@ -292,7 +292,7 @@ macro_rules! impl_test_component_ids { impl GetTestEntityId for $comp_type { fn test_entity_id() -> Entity { - Entity::from_raw(TEST_ENTITY_ID_START + $comp_id) + Entity::from_raw_u32(TEST_ENTITY_ID_START + $comp_id).unwrap() } } )* @@ -312,7 +312,7 @@ macro_rules! impl_test_component_ids { assert_eq!(registered_id, TEST_COMPONENT_ID_START + $comp_id, "Test setup failed. Did you register components before running setup_world?: {}", stringify!($comp_type)); let entity = world.spawn(<$comp_type>::init()).id(); assert_eq!(entity.index(), TEST_ENTITY_ID_START + $comp_id, "Test setup failed. Did you spawn entities before running setup_world?: {}", stringify!($comp_type)); - assert_eq!(entity.generation(), 1, "Test setup failed. Did you spawn entities before running setup_world?: {}", stringify!($comp_type)); + assert_eq!(entity.generation(), bevy_ecs::entity::EntityGeneration::FIRST, "Test setup failed. Did you spawn entities before running setup_world?: {}", stringify!($comp_type)); )* $( world.insert_resource::<$res_type>(<$res_type>::init()); From 4f74fd48dced2fd9f7f2b3b3126f2f27d36ee7d3 Mon Sep 17 00:00:00 2001 From: makspll Date: Fri, 7 Nov 2025 20:45:17 +0000 Subject: [PATCH 02/22] more conversions --- .../src/pipeline/machines.rs | 19 ++++++------ .../src/pipeline/mod.rs | 30 +++++++++---------- 2 files changed, 25 insertions(+), 24 deletions(-) diff --git a/crates/bevy_mod_scripting_core/src/pipeline/machines.rs b/crates/bevy_mod_scripting_core/src/pipeline/machines.rs index 32dfe922ab..4858d2c369 100644 --- a/crates/bevy_mod_scripting_core/src/pipeline/machines.rs +++ b/crates/bevy_mod_scripting_core/src/pipeline/machines.rs @@ -6,6 +6,7 @@ use std::{ time::{Duration, Instant}, }; +use bevy_ecs::message::{MessageCursor, Messages}; use bevy_log::debug; use bevy_mod_scripting_bindings::InteropError; use bevy_mod_scripting_script::ScriptAttachment; @@ -19,8 +20,8 @@ use super::*; /// Allows re-publishing of the same events too #[derive(SystemParam)] pub struct StateMachine<'w, 's, T: Send + Sync + 'static, P: IntoScriptPluginParams> { - events: ResMut<'w, Events>>, - cursor: Local<'s, EventCursor>>, + events: ResMut<'w, Messages>>, + cursor: Local<'s, MessageCursor>>, } impl<'w, 's, T: Send + Sync + 'static, P: IntoScriptPluginParams> StateMachine<'w, 's, T, P> { @@ -62,7 +63,7 @@ impl<'w, 's, T: Send + Sync + 'static, P: IntoScriptPluginParams> StateMachine<' /// Consumes an iterator of state machines and writes them to the asset pipe pub fn write_batch(&mut self, batch: impl IntoIterator) { self.events - .send_batch(batch.into_iter().map(ForPlugin::new)); + .write_batch(batch.into_iter().map(ForPlugin::new)); } } @@ -165,7 +166,7 @@ impl ActiveMachines

{ // removed } Some(Err(err)) => { - _ = world.send_event(ScriptErrorEvent::new(err)); + _ = world.write_message(ScriptErrorEvent::new(err)); // removed } None => { @@ -244,7 +245,7 @@ impl ScriptMachine

{ if let Err(err) = (on_entered)(machine_state.as_mut(), world, &mut self.context) { - _ = world.send_event(ScriptErrorEvent::new( + _ = world.write_message(ScriptErrorEvent::new( err.with_context(self.context.attachment.to_string()) .with_context(machine_state.state_name()) .with_language(P::LANGUAGE), @@ -523,13 +524,13 @@ impl MachineState

for ContextAssigned

{ let mut contexts_guard = contexts.write(); // drop any strong handles - match contexts_guard.insert(attachment.clone().into_weak(), self.context.clone()) { + match contexts_guard.insert(attachment.clone(), self.context.clone()) { Ok(_) => {} Err(_) => { drop(contexts_guard); - _ = world.send_event(ScriptErrorEvent::new(ScriptError::from(InteropError::str( - "no context policy matched", - )))) + _ = world.write_message(ScriptErrorEvent::new(ScriptError::from( + InteropError::str("no context policy matched"), + ))) } } Box::new(ready(Ok( diff --git a/crates/bevy_mod_scripting_core/src/pipeline/mod.rs b/crates/bevy_mod_scripting_core/src/pipeline/mod.rs index f759e874c8..33ece17db8 100644 --- a/crates/bevy_mod_scripting_core/src/pipeline/mod.rs +++ b/crates/bevy_mod_scripting_core/src/pipeline/mod.rs @@ -5,7 +5,7 @@ use std::{any::Any, collections::VecDeque, marker::PhantomData, sync::Arc, time: use bevy_app::{App, Plugin, PostUpdate}; use bevy_asset::{AssetServer, Assets, Handle, LoadState}; use bevy_ecs::{ - event::{Event, EventCursor, EventReader, EventWriter, Events}, + message::{Message, MessageReader}, resource::Resource, schedule::{IntoScheduleConfigs, Schedule, ScheduleLabel, SystemSet}, system::{Command, Local, Res, ResMut, SystemParam}, @@ -138,8 +138,8 @@ impl std::fmt::Debug for ScriptProcessingSchedule

} impl ScriptLoadingPipeline

{ - fn add_plugin_event(&self, app: &mut App) -> &Self { - app.add_event::().add_event::>(); + fn add_plugin_message(&self, app: &mut App) -> &Self { + app.add_message::().add_message::>(); self } } @@ -156,15 +156,15 @@ pub trait GetScriptHandle { /// is loaded, will also guarantee a strong handle, otherwise the whole thing is skipped. /// /// Think of this as a proxy for "baby'ing" asset handles -pub struct LoadedWithHandles<'w, 's, T: GetScriptHandle + Event + Clone> { +pub struct LoadedWithHandles<'w, 's, T: GetScriptHandle + Message + Clone> { assets: ResMut<'w, Assets>, asset_server: Res<'w, AssetServer>, - fresh_events: EventReader<'w, 's, T>, + fresh_events: MessageReader<'w, 's, T>, loaded_with_handles: Local<'s, VecDeque<(T, StrongScriptHandle)>>, loading: Local<'s, VecDeque>, } -impl LoadedWithHandles<'_, '_, T> { +impl LoadedWithHandles<'_, '_, T> { /// Retrieves all of the events of type `T`, which have finished loading and have a strong handle, /// the rest will be discarded. /// @@ -203,9 +203,9 @@ impl LoadedWithHandles<'_, '_, T> { impl Plugin for ScriptLoadingPipeline

{ fn build(&self, app: &mut App) { - self.add_plugin_event::(app) - .add_plugin_event::(app) - .add_plugin_event::(app); + self.add_plugin_message::(app) + .add_plugin_message::(app) + .add_plugin_message::(app); let mut active_machines = app.world_mut().get_resource_or_init::>(); if self.on_script_loaded_callback { @@ -405,7 +405,7 @@ impl<'w, P: IntoScriptPluginParams> ScriptPipelineState<'w, P> { #[cfg(test)] mod test { - use bevy_asset::{AssetApp, AssetId, AssetPlugin}; + use bevy_asset::{AssetApp, AssetPlugin}; use bevy_ecs::{entity::Entity, system::SystemState, world::FromWorld}; use bevy_mod_scripting_asset::Language; use bevy_mod_scripting_bindings::ScriptValue; @@ -418,7 +418,7 @@ mod test { #[test] fn test_system_params() { let mut app = App::default(); - app.add_event::(); + app.add_message::(); app.add_plugins(AssetPlugin::default()); app.init_asset::(); app.finish(); @@ -441,9 +441,9 @@ mod test { language: Language::Lua, }; let handle = asset_server.add(asset); - let handle_invalid = Handle::Weak(AssetId::invalid()); - world.send_event(ScriptAttachedEvent(ScriptAttachment::StaticScript(handle))); - world.send_event(ScriptAttachedEvent(ScriptAttachment::StaticScript( + let handle_invalid = Handle::default(); + world.write_message(ScriptAttachedEvent(ScriptAttachment::StaticScript(handle))); + world.write_message(ScriptAttachedEvent(ScriptAttachment::StaticScript( handle_invalid, ))); @@ -468,7 +468,7 @@ mod test { #[test] fn test_run_override_is_undid() { let mut app = App::default(); - app.add_event::(); + app.add_message::(); app.add_plugins((AssetPlugin::default(), TestPlugin::default())); app.init_asset::(); From 7224f2f35978d05723565e59dff3cd882a1d196e Mon Sep 17 00:00:00 2001 From: makspll Date: Sat, 8 Nov 2025 11:56:10 +0000 Subject: [PATCH 03/22] change handles to AssetID's where we don't want to keep scripts alive --- crates/bevy_mod_scripting_core/src/event.rs | 9 ++++--- .../src/pipeline/start.rs | 10 +++---- .../src/script/context_key.rs | 27 +++++-------------- .../src/script/script_context.rs | 2 +- .../src/script_system.rs | 3 --- 5 files changed, 18 insertions(+), 33 deletions(-) diff --git a/crates/bevy_mod_scripting_core/src/event.rs b/crates/bevy_mod_scripting_core/src/event.rs index c4c873d240..bcff5235f8 100644 --- a/crates/bevy_mod_scripting_core/src/event.rs +++ b/crates/bevy_mod_scripting_core/src/event.rs @@ -3,8 +3,9 @@ use std::{marker::PhantomData, sync::Arc}; use ::{bevy_ecs::entity::Entity, bevy_reflect::Reflect}; +use bevy_asset::AssetId; use bevy_ecs::message::Message; -use bevy_mod_scripting_asset::Language; +use bevy_mod_scripting_asset::{Language, ScriptAsset}; use bevy_mod_scripting_bindings::ScriptValue; use bevy_mod_scripting_script::ScriptAttachment; use parking_lot::Mutex; @@ -39,7 +40,7 @@ pub struct ScriptDetachedEvent(pub ScriptAttachment); /// Emitted when a script asset is modified and all its attachments require re-loading #[derive(Message, Clone, Debug)] -pub struct ScriptAssetModifiedEvent(pub ScriptId); +pub struct ScriptAssetModifiedEvent(pub AssetId); #[derive(Message)] /// Wrapper around a script event making it available to read by a specific plugin only @@ -65,8 +66,8 @@ impl Clone for ForPlugin { impl ForPlugin { /// Creates a new wrapper for the specific plugin - pub fn new(Message: T) -> Self { - Self(Message, Default::default()) + pub fn new(message: T) -> Self { + Self(message, Default::default()) } /// Retrieves the inner event diff --git a/crates/bevy_mod_scripting_core/src/pipeline/start.rs b/crates/bevy_mod_scripting_core/src/pipeline/start.rs index 8b8d990c6e..78092f2f6f 100644 --- a/crates/bevy_mod_scripting_core/src/pipeline/start.rs +++ b/crates/bevy_mod_scripting_core/src/pipeline/start.rs @@ -7,11 +7,11 @@ use bevy_log::{debug, trace}; #[derive(Clone, Debug)] pub struct StrongScriptHandle(Handle); -impl GetScriptHandle for ScriptAssetModifiedEvent { - fn get_script_handle(&self) -> Handle { - self.0.clone() - } -} +// impl GetScriptHandle for ScriptAssetModifiedEvent { +// fn get_script_handle(&self) -> Handle { +// self.0.clone() +// } +// } impl GetScriptHandle for ScriptAttachedEvent { fn get_script_handle(&self) -> Handle { diff --git a/crates/bevy_mod_scripting_core/src/script/context_key.rs b/crates/bevy_mod_scripting_core/src/script/context_key.rs index c043ee0961..9872c69d8e 100644 --- a/crates/bevy_mod_scripting_core/src/script/context_key.rs +++ b/crates/bevy_mod_scripting_core/src/script/context_key.rs @@ -1,8 +1,7 @@ -use std::{fmt, marker::PhantomData}; +use std::fmt; +use bevy_asset::AssetId; use bevy_ecs::entity::Entity; -use bevy_mod_scripting_display::DisplayProxy; -use uuid::Uuid; use super::*; use crate::ScriptAsset; @@ -12,11 +11,11 @@ impl From for ContextKey { match val { ScriptAttachment::EntityScript(entity, script) => ContextKey { entity: Some(entity), - script: Some(script), + script: Some(script.id()), }, ScriptAttachment::StaticScript(script) => ContextKey { entity: None, - script: Some(script), + script: Some(script.id()), }, } } @@ -31,7 +30,7 @@ pub struct ContextKey { pub entity: Option, /// Script ID if there is one. /// Can be empty if the script is not driven by an asset. - pub script: Option>, + pub script: Option>, } impl fmt::Display for ContextKey { @@ -39,7 +38,7 @@ impl fmt::Display for ContextKey { // write!(f, "context ")?; let mut empty = true; if let Some(script_id) = &self.script { - write!(f, "script {}", script_id.display())?; + write!(f, "script {script_id}")?; empty = false; } if let Some(id) = self.entity { @@ -57,7 +56,7 @@ impl ContextKey { /// Creates an invalid context key, which should never exist. pub const INVALID: Self = Self { entity: Some(Entity::PLACEHOLDER), - script: Some(Handle::Uuid(Uuid::nil(), PhantomData)), + script: Some(AssetId::invalid()), }; /// Creates a shared context key, which is used for shared contexts @@ -80,16 +79,4 @@ impl ContextKey { script: self.script.or(other.script), } } - - // /// If a script handle is present and is strong, convert it to a weak - // /// handle. - // pub fn into_weak(mut self) -> Self { - // if let Some(script) = &self.script - // && script.is_strong() - // { - // self.script = Some(script.clone()); - // } - - // self - // } } diff --git a/crates/bevy_mod_scripting_core/src/script/script_context.rs b/crates/bevy_mod_scripting_core/src/script/script_context.rs index 380de1937d..ee95373f16 100644 --- a/crates/bevy_mod_scripting_core/src/script/script_context.rs +++ b/crates/bevy_mod_scripting_core/src/script/script_context.rs @@ -63,7 +63,7 @@ impl ContextKeySelector for ContextRule { ContextRule::EntityScript => { context_key .entity - .zip(context_key.script.clone()) + .zip(context_key.script) .map(|(entity, script)| ContextKey { entity: Some(entity), script: Some(script), diff --git a/crates/bevy_mod_scripting_core/src/script_system.rs b/crates/bevy_mod_scripting_core/src/script_system.rs index 212802e7b9..f34ef15185 100644 --- a/crates/bevy_mod_scripting_core/src/script_system.rs +++ b/crates/bevy_mod_scripting_core/src/script_system.rs @@ -7,7 +7,6 @@ use crate::{ use ::{ bevy_ecs::{ - archetype::ArchetypeGeneration, component::{ComponentId, Tick}, entity::Entity, query::{FilteredAccess, FilteredAccessSet, QueryState}, @@ -223,7 +222,6 @@ pub struct DynamicScriptSystem { exclusive: bool, pub(crate) last_run: Tick, target_attachment: ScriptAttachment, - archetype_generation: ArchetypeGeneration, system_param_descriptors: Vec, state: Option>, _marker: std::marker::PhantomData P>, @@ -242,7 +240,6 @@ impl bevy_ecs::system::IntoSystem<(), (), IsDynamicSc Self::System { name: builder.name.to_string().into(), exclusive: builder.is_exclusive, - archetype_generation: ArchetypeGeneration::initial(), system_param_descriptors: builder.system_params, last_run: Default::default(), target_attachment: builder.attachment, From 542003f4756b181ff5e4d814a8b5bc10ad380cf0 Mon Sep 17 00:00:00 2001 From: makspll Date: Sat, 8 Nov 2025 14:17:24 +0000 Subject: [PATCH 04/22] bump bevy resolution in codegen --- codegen/Cargo.bootstrap.toml | 2 +- xtask/src/main.rs | 10 ++++++---- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/codegen/Cargo.bootstrap.toml b/codegen/Cargo.bootstrap.toml index 90374660ef..ad18aba78d 100644 --- a/codegen/Cargo.bootstrap.toml +++ b/codegen/Cargo.bootstrap.toml @@ -6,7 +6,7 @@ edition = "2024" [dependencies] bevy_mod_scripting_bindings = { path = "{{BMS_BINDINGS_PATH}}" } -bevy_reflect = { version = "0.16.0", features = [ +bevy_reflect = { version = "0.17", features = [ "smol_str", "glam", "petgraph", diff --git a/xtask/src/main.rs b/xtask/src/main.rs index e598e57bce..c9b7f1af23 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -1216,13 +1216,15 @@ impl Xtasks { )?; let metadata = Self::main_workspace_cargo_metadata()?; + let bevy_version = metadata .packages .iter() - .find(|p| p.name.as_str() == "bevy") - .expect("Could not find bevy package in metadata") - .version - .clone(); + .filter_map(|p| (p.name.as_str() == "bevy").then_some(&p.version)) + .max() + .expect("could not find bevy package in metadata"); + + log::info!("Using bevy version {bevy_version}"); // create directories if they don't already exist std::fs::create_dir_all(&bevy_dir)?; std::fs::create_dir_all(&output_dir)?; From 8d810507c9501665d6b4e82fce35f16d642b0a33 Mon Sep 17 00:00:00 2001 From: makspll Date: Sat, 8 Nov 2025 15:25:57 +0000 Subject: [PATCH 05/22] bump toolchain and fix compilation errors in codegen --- codegen/rust-toolchain.toml | 2 +- codegen/src/lib.rs | 2 +- codegen/src/passes/cache_traits.rs | 4 ++-- codegen/src/passes/find_methods_and_fields.rs | 13 ++++++++----- codegen/src/passes/find_trait_impls.rs | 7 ++----- codegen/src/passes/populate_template_data.rs | 12 ++++++------ 6 files changed, 20 insertions(+), 20 deletions(-) diff --git a/codegen/rust-toolchain.toml b/codegen/rust-toolchain.toml index d03a332d52..4077610134 100644 --- a/codegen/rust-toolchain.toml +++ b/codegen/rust-toolchain.toml @@ -1,3 +1,3 @@ [toolchain] components = ["clippy", "rust-src", "rustc-dev", "llvm-tools"] -channel = "nightly-2025-06-27" +channel = "nightly-2025-11-08" diff --git a/codegen/src/lib.rs b/codegen/src/lib.rs index 32d2e6a058..0368b7633a 100644 --- a/codegen/src/lib.rs +++ b/codegen/src/lib.rs @@ -1,4 +1,4 @@ -#![feature(rustc_private, let_chains)] +#![feature(rustc_private)] #![deny(rustc::internal)] extern crate rustc_ast; diff --git a/codegen/src/passes/cache_traits.rs b/codegen/src/passes/cache_traits.rs index d44f30eadb..b06e6aef72 100644 --- a/codegen/src/passes/cache_traits.rs +++ b/codegen/src/passes/cache_traits.rs @@ -10,7 +10,7 @@ use crate::{ fn dump_traits(tcx: &TyCtxt) -> String { let mut buffer = String::new(); - for t in tcx.all_traits() { + for t in tcx.all_traits_including_private() { buffer.push_str(&tcx.def_path_str(t)); buffer.push_str(", "); } @@ -21,7 +21,7 @@ fn dump_traits(tcx: &TyCtxt) -> String { pub(crate) fn cache_traits(ctxt: &mut BevyCtxt<'_>, _args: &Args) -> bool { let tcx = &ctxt.tcx; - for trait_did in tcx.all_traits() { + for trait_did in tcx.all_traits_including_private() { let def_path_str = tcx.def_path_str(trait_did); if DEF_PATHS_REFLECT.contains(&def_path_str.as_str()) { trace!("found Reflect trait def id: {trait_did:?}"); diff --git a/codegen/src/passes/find_methods_and_fields.rs b/codegen/src/passes/find_methods_and_fields.rs index 7efe4d8427..b277f15b2d 100644 --- a/codegen/src/passes/find_methods_and_fields.rs +++ b/codegen/src/passes/find_methods_and_fields.rs @@ -32,7 +32,7 @@ pub(crate) fn find_methods_and_fields(ctxt: &mut BevyCtxt<'_>, _args: &Args) -> .variants() .iter() .flat_map(|variant| { - if has_reflect_ignore_attr(ctxt.tcx.get_attrs_unchecked(variant.def_id)) { + if has_reflect_ignore_attr(ctxt.tcx.get_all_attrs(variant.def_id)) { // TODO: is this the right approach? do we need to still include those variants? or do we just provide dummies // or can we just skip those ? info!( @@ -159,7 +159,7 @@ pub(crate) fn find_methods_and_fields(ctxt: &mut BevyCtxt<'_>, _args: &Args) -> let trait_did = ctxt .tcx - .impl_trait_ref(*impl_did) + .impl_opt_trait_ref(*impl_did) .map(|tr| tr.skip_binder().def_id); let trait_name = trait_did .map(|td| ctxt.tcx.item_name(td).to_ident_string()) @@ -353,7 +353,8 @@ fn process_fields<'tcx, 'f, I: Iterator>( return (f.did, crate::ReflectionStrategy::Filtered); } - let field_ty = tcx.erase_regions(tcx.type_of(f.did).instantiate_identity()); + let field_ty = + tcx.erase_and_anonymize_regions(tcx.type_of(f.did).instantiate_identity()); if type_is_supported_as_non_proxy_arg(tcx, param_env, cached_traits, field_ty) && type_is_supported_as_non_proxy_return_val( tcx, @@ -367,7 +368,7 @@ fn process_fields<'tcx, 'f, I: Iterator>( && type_is_supported_as_proxy_return_val(tcx, reflect_types, meta_loader, field_ty) { (f.did, crate::ReflectionStrategy::Proxy) - } else if !has_reflect_ignore_attr(tcx.get_attrs_unchecked(f.did)) { + } else if !has_reflect_ignore_attr(tcx.get_all_attrs(f.did)) { (f.did, crate::ReflectionStrategy::Reflection) } else { (f.did, crate::ReflectionStrategy::Filtered) @@ -487,7 +488,9 @@ fn type_is_supported_as_non_proxy_return_val<'tcx>( "Checkign type is supported as non proxy return val: '{ty:?}' with param_env: '{param_env:?}'" ); if let TyKind::Ref(region, _, _) = ty.kind() - && region.get_name().is_none_or(|rn| rn.as_str() != "'static") + && region + .get_name(tcx) + .is_none_or(|rn| rn.as_str() != "'static") { return false; } diff --git a/codegen/src/passes/find_trait_impls.rs b/codegen/src/passes/find_trait_impls.rs index 1d33232bb7..ffaaa80bab 100644 --- a/codegen/src/passes/find_trait_impls.rs +++ b/codegen/src/passes/find_trait_impls.rs @@ -146,10 +146,7 @@ fn impl_matches<'tcx>(infcx: &InferCtxt<'tcx>, ty: Ty<'tcx>, impl_def_id: DefId) let param_env = typing_env.with_post_analysis_normalized(tcx).param_env; let impl_args = infcx.fresh_args_for_item(DUMMY_SP, impl_def_id); - let impl_trait_ref = tcx - .impl_trait_ref(impl_def_id) - .expect("Expected defid to be an impl for a trait") - .instantiate(tcx, impl_args); + let impl_trait_ref = tcx.impl_trait_ref(impl_def_id).instantiate(tcx, impl_args); let impl_trait_ref = ocx.normalize(&ObligationCause::dummy(), param_env, impl_trait_ref); let impl_trait_ref_ty = impl_trait_ref.self_ty(); if ocx @@ -164,7 +161,7 @@ fn impl_matches<'tcx>(infcx: &InferCtxt<'tcx>, ty: Ty<'tcx>, impl_def_id: DefId) Obligation::new(tcx, ObligationCause::dummy(), param_env, predicate) })); - ocx.select_where_possible().is_empty() + ocx.try_evaluate_obligations().is_empty() }; infcx.probe(|_| impl_may_apply(impl_def_id)) diff --git a/codegen/src/passes/populate_template_data.rs b/codegen/src/passes/populate_template_data.rs index a56701c6c7..f47847d2cf 100644 --- a/codegen/src/passes/populate_template_data.rs +++ b/codegen/src/passes/populate_template_data.rs @@ -57,7 +57,7 @@ pub(crate) fn populate_template_data(ctxt: &mut BevyCtxt<'_>, args: &Args) -> bo .variants() .iter() .map(|variant| Variant { - docstrings: docstrings(ctxt.tcx.get_attrs_unchecked(variant.def_id)), + docstrings: docstrings(ctxt.tcx.get_all_attrs(variant.def_id)), name: variant.name.to_ident_string().into(), fields: process_fields(ctxt, variant.fields.iter(), &ty_ctxt), }) @@ -71,7 +71,7 @@ pub(crate) fn populate_template_data(ctxt: &mut BevyCtxt<'_>, args: &Args) -> bo is_enum: variants.len() > 1, variants, is_tuple_struct, - docstrings: docstrings(tcx.get_attrs_unchecked(reflect_ty_did)), + docstrings: docstrings(tcx.get_all_attrs(reflect_ty_did)), impls_clone: trait_impls.contains_key(&clone_diagnostic), impls_debug: trait_impls.contains_key(&debug_diagnostic), impls_display: trait_impls.contains_key(&display_diagnostic), @@ -110,7 +110,7 @@ pub(crate) fn process_fields<'f, I: Iterator>( ) -> Vec { fields .map(|field| Field { - docstrings: docstrings(ctxt.tcx.get_attrs_unchecked(field.did)), + docstrings: docstrings(ctxt.tcx.get_all_attrs(field.did)), ident: field.name.to_ident_string(), ty: ty_to_string(ctxt, ctxt.tcx.type_of(field.did).skip_binder(), false), reflection_strategy: *ty_ctxt @@ -163,9 +163,9 @@ pub(crate) fn process_functions(ctxt: &BevyCtxt, fns: &[FunctionContext]) -> Vec args, output, has_self: fn_ctxt.has_self, - docstrings: docstrings(ctxt.tcx.get_attrs_unchecked(fn_ctxt.def_id)), + docstrings: docstrings(ctxt.tcx.get_all_attrs(fn_ctxt.def_id)), from_trait_path: fn_ctxt.trait_and_impl_did.map(|(_, impl_did)| { - let trait_ref = ctxt.tcx.impl_trait_ref(impl_did).unwrap().skip_binder(); + let trait_ref = ctxt.tcx.impl_trait_ref(impl_did).skip_binder(); trait_ref_to_string(ctxt, trait_ref) }), @@ -239,7 +239,7 @@ fn trait_ref_to_string<'tcx>(ctxt: &BevyCtxt<'tcx>, trait_ref: TraitRef<'tcx>) - // filter out non const | type generics and the compiler generated ones .filter(|(_, arg_def)| match arg_def.kind { GenericParamDefKind::Lifetime => false, - GenericParamDefKind::Const { synthetic, .. } => !synthetic, + GenericParamDefKind::Type { synthetic, .. } => !synthetic, _ => true, }) .map(|(arg, arg_def)| { From 69397027ba2e3c044b86ce2d62d32dc8030312ee Mon Sep 17 00:00:00 2001 From: makspll Date: Sun, 9 Nov 2025 14:33:46 +0000 Subject: [PATCH 06/22] fix recursion issues with crawling paths, embed linker arguments at build time to avoid toolchain issues --- codegen/build.rs | 42 ++++++++++++++++++++++++++++++++++++- codegen/src/driver/mod.rs | 11 +++++----- codegen/src/import_path.rs | 43 +++++++++++++++++++++++++++----------- codegen/src/lib.rs | 3 +++ codegen/src/plugin.rs | 4 ++-- xtask/src/main.rs | 11 ++++++++-- 6 files changed, 91 insertions(+), 23 deletions(-) diff --git a/codegen/build.rs b/codegen/build.rs index b6690b0ffd..cee5f6012f 100644 --- a/codegen/build.rs +++ b/codegen/build.rs @@ -1,8 +1,48 @@ -fn main() { +use std::{ + path::{Path, PathBuf}, + process::Command, +}; + +fn rustc_path(channel: &str) -> PathBuf { + let output = Command::new("rustup") + .args(["which", "--toolchain", channel, "rustc"]) + .output() + .expect("failed to run rustup which"); + + let rustc_path = String::from_utf8(output.stdout).unwrap(); + + PathBuf::from(rustc_path.trim()) +} + +fn target_libdir(rustc: &Path) -> PathBuf { + let output = Command::new(rustc) + .args(["--print", "target-libdir"]) + .output() + .expect("failed to run rustc --print target-libdir"); + + let libdir = String::from_utf8(output.stdout).unwrap(); + + PathBuf::from(libdir.trim()) +} + +pub fn main() { // Use to set RUSTC_CHANNEL so we can compute target dir from rustc_plugin let toolchain_toml = include_str!("rust-toolchain.toml"); let toolchain_table = toolchain_toml.parse::().unwrap(); let toolchain = toolchain_table["toolchain"].as_table().unwrap(); let channel = toolchain["channel"].as_str().unwrap(); println!("cargo:rustc-env=RUSTC_CHANNEL={channel}"); + + // I believe there was some sort of change in cargo, which motivated this change in the original rustc_plugin: + // https://github.com/cognitive-engineering-lab/rustc_plugin/pull/41 + // + // This solves issues with linking to the rustc driver dynamic library, as cargo does not seem to put in the correct LD_LIBRARY_PATH for the driver binary instantiations + // Embedding this in the binary solves the problem + let rustc_path = rustc_path(channel); + let target_libdir = target_libdir(&rustc_path); + + println!( + "cargo::rustc-link-arg=-Wl,-rpath,{}", + target_libdir.display() + ); } diff --git a/codegen/src/driver/mod.rs b/codegen/src/driver/mod.rs index f963ff39e1..3ad259c229 100644 --- a/codegen/src/driver/mod.rs +++ b/codegen/src/driver/mod.rs @@ -19,7 +19,7 @@ pub const CARGO_VERBOSE: &str = "CARGO_VERBOSE"; pub const WORKSPACE_GRAPH_FILE_ENV: &str = "WORKSPACE_GRAPH_FILE"; pub fn fetch_target_directory(metadata: &Metadata) -> Utf8PathBuf { - let plugin_subdir = format!("plugin-{}", env!("RUSTC_CHANNEL")); + let plugin_subdir = format!("plugin-{}", crate::CHANNEL); metadata.target_directory.join(plugin_subdir) } @@ -197,7 +197,7 @@ pub fn driver_main(plugin: T) { // the driver directly without having to pass --sysroot or anything let mut args: Vec = orig_args.clone(); if !have_sys_root_arg { - args.extend(["--sysroot".into(), sys_root]); + args.extend(["--sysroot".into(), sys_root.clone()]); }; // On a given invocation of rustc, we have to decide whether to act as rustc, @@ -215,16 +215,15 @@ pub fn driver_main(plugin: T) { let run_plugin = !normal_rustc && is_target_crate; + // TODO: this is dangerous + // ignore all lints that could break the comp in crates that we don't care about + // args.extend([String::from("--cap-lints"), String::from("warn")]); if run_plugin { - // TODO: this is dangerous - args.extend([String::from("--cap-lints"), String::from("warn")]); log::debug!("Running plugin on crate: {crate_being_built}"); let plugin_args: T::Args = serde_json::from_str(&env::var(PLUGIN_ARGS).unwrap()).unwrap(); plugin.run(args, plugin_args); } else { - // ignore all lints that could break the comp in crates that we don't care about - args.extend([String::from("--cap-lints"), String::from("warn")]); log::debug!( "Running normal Rust. Relevant variables:\ normal_rustc={normal_rustc}, \ diff --git a/codegen/src/import_path.rs b/codegen/src/import_path.rs index 4bae0d0f0a..fc1b8d40b2 100644 --- a/codegen/src/import_path.rs +++ b/codegen/src/import_path.rs @@ -14,6 +14,15 @@ pub(crate) enum ImportPathElement { Item(DefId), } +impl ImportPathElement { + pub fn def_id(&self) -> DefId { + match self { + Self::Rename(did, _) => *did, + Self::Item(did) => *did, + } + } +} + impl std::fmt::Debug for ImportPathElement { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { @@ -55,11 +64,12 @@ impl<'tcx> ImportPathFinder<'tcx> { fn crawl_module(&mut self, did: DefId, frontier: &[ImportPathElement]) { trace!("Crawling module {did:?}"); + // Push current module onto the path frontier let mut new_frontier = frontier.to_vec(); new_frontier.push(ImportPathElement::Item(did)); - // do not allow modification or weird things happen let new_frontier = &new_frontier; + // Get children of the module let children = if did.is_local() { self.tcx.module_children_local(did.expect_local()) } else { @@ -69,15 +79,16 @@ impl<'tcx> ImportPathFinder<'tcx> { for child in children { let rename = child.ident.to_string(); + // Skip private items if we don't include them if !self.include_private_paths && !child.vis.is_public() { trace!("Skipping private child {rename:?}"); continue; } - let did = if let Some(did) = child.res.opt_def_id() { - did - } else { - continue; + // Skip if the child has no DefId + let did = match child.res.opt_def_id() { + Some(did) => did, + None => continue, }; trace!( @@ -87,16 +98,24 @@ impl<'tcx> ImportPathFinder<'tcx> { ); match self.tcx.def_kind(did) { - DefKind::Mod => self.crawl_module(did, new_frontier), - DefKind::Struct | DefKind::Union | DefKind::Enum | DefKind::Trait => { - // save the rename and the def id + DefKind::Mod => { + // Only recurse if this DefId is not already in the current path + if new_frontier.iter().any(|el| el.def_id() == did) { + trace!("Cycle detected for {did:?}, skipping recursion"); + continue; + } + self.crawl_module(did, new_frontier) + } - let mut new_frontier = new_frontier.clone(); - new_frontier.push(ImportPathElement::Rename(did, rename)); + DefKind::Struct | DefKind::Union | DefKind::Enum | DefKind::Trait => { + // Save the rename and the DefId + let mut path_for_item = new_frontier.clone(); + path_for_item.push(ImportPathElement::Rename(did, rename)); - trace!("saving import path for {did:?}: {new_frontier:?}"); - self.cache.entry(did).or_default().push(new_frontier); + trace!("Saving import path for {did:?}: {path_for_item:?}"); + self.cache.entry(did).or_default().push(path_for_item); } + _ => continue, } } diff --git a/codegen/src/lib.rs b/codegen/src/lib.rs index 0368b7633a..0409702e73 100644 --- a/codegen/src/lib.rs +++ b/codegen/src/lib.rs @@ -39,3 +39,6 @@ pub use template::{ Collect, Crate, TEMPLATE_DIR, TemplateKind, configure_tera, extend_context_with_args, }; pub mod driver; + +/// The rustc toolchain this crate was built with and needs to work with +pub const CHANNEL: &str = env!("RUSTC_CHANNEL"); diff --git a/codegen/src/plugin.rs b/codegen/src/plugin.rs index 937c4db23d..bc5c88cfd6 100644 --- a/codegen/src/plugin.rs +++ b/codegen/src/plugin.rs @@ -50,7 +50,7 @@ impl crate::driver::RustcPlugin for BevyAnalyzer { // make cargo chatty as well if args.verbose.get_log_level_int() >= 3 { - cmd.arg("-v"); + cmd.arg("-vv"); } else { cmd.arg("-q"); } @@ -74,7 +74,7 @@ impl crate::driver::RustcPlugin for BevyAnalyzer { .map(|a| a.to_string_lossy()) .collect::>() .join(" "); - log::debug!("Running: \n{all_env} {bin_name} {args}",); + log::debug!("Running cargo build command: \n{all_env} {bin_name} {args}",); } } diff --git a/xtask/src/main.rs b/xtask/src/main.rs index c9b7f1af23..39af27b70b 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -1196,16 +1196,19 @@ impl Xtasks { } let api_gen_dir = Self::codegen_crate_dir(&main_workspace_app_settings)?; + let codegen_toolchain = Self::read_rust_toolchain(&api_gen_dir); let codegen_app_settings = main_workspace_app_settings .clone() .with_workspace_dir(api_gen_dir.clone()); + // .with_toolchain(codegen_toolchain.clone()); // don't think it's needed, the rust toolchain file sorts that out let bevy_repo_app_settings = main_workspace_app_settings .clone() .with_workspace_dir(bevy_dir.clone()) - .with_toolchain(Self::read_rust_toolchain(&api_gen_dir)); + .with_toolchain(codegen_toolchain.clone()); // run cargo install + log::info!("Running bevy_api_gen against toolchain: {codegen_toolchain}"); Self::run_system_command( &codegen_app_settings, "cargo", @@ -2235,9 +2238,13 @@ fn pop_cargo_env() -> Result<()> { let env = std::env::vars().collect::>(); // RUSTUP TOOLCHAIN exclude is a temporary fix, it might make deving the api codegen crate not work let exclude_list = ["CARGO_HOME"]; + let include_list = []; //"LD_LIBRARY_PATH" for (key, value) in env.iter() { - if key.starts_with("CARGO_") && !exclude_list.contains(&(key.as_str())) { + let key_str = &(key.as_str()); + if (include_list.contains(key_str) || key.starts_with("CARGO_")) + && !exclude_list.contains(key_str) + { let new_key = format!("MAIN_{key}"); unsafe { std::env::set_var(new_key, value) }; unsafe { std::env::remove_var(key) }; From aa42f948bd81df726d9f6aab01e06ca1592bbc22 Mon Sep 17 00:00:00 2001 From: makspll Date: Sun, 9 Nov 2025 16:55:13 +0000 Subject: [PATCH 07/22] fix missing external feature activations, and regen code --- .../crates/crate_feature_graph/src/feature.rs | 6 +- .../crates/crate_feature_graph/src/graph.rs | 47 +- codegen/src/passes/write_meta.rs | 5 +- .../bevy_a11y_bms_bindings/Cargo.toml | 24 +- .../bevy_a11y_bms_bindings/src/lib.rs | 34 +- .../bevy_animation_bms_bindings/Cargo.toml | 42 +- .../bevy_animation_bms_bindings/src/lib.rs | 140 +- .../bevy_asset_bms_bindings/Cargo.toml | 71 +- .../bevy_asset_bms_bindings/src/lib.rs | 141 + .../bevy_camera_bms_bindings/Cargo.toml | 47 + .../bevy_camera_bms_bindings/README.md | 4 + .../bevy_camera_bms_bindings/src/lib.rs | 2209 +++++ .../bevy_color_bms_bindings/Cargo.toml | 23 +- .../bevy_color_bms_bindings/src/lib.rs | 2 +- .../Cargo.toml | 51 +- .../src/lib.rs | 981 +-- .../bindings/bevy_ecs_bms_bindings/Cargo.toml | 62 +- .../bindings/bevy_ecs_bms_bindings/src/lib.rs | 578 +- .../bevy_gizmos_bms_bindings/Cargo.toml | 52 +- .../bevy_gltf_bms_bindings/Cargo.toml | 51 +- .../bevy_gltf_bms_bindings/src/lib.rs | 30 + .../bevy_image_bms_bindings/Cargo.toml | 48 +- .../bevy_image_bms_bindings/src/lib.rs | 38 + .../bevy_input_bms_bindings/Cargo.toml | 49 +- .../bevy_input_bms_bindings/src/lib.rs | 368 +- .../bevy_input_focus_bms_bindings/Cargo.toml | 51 +- .../bevy_light_bms_bindings/Cargo.toml | 47 + .../bevy_light_bms_bindings/README.md | 4 + .../bevy_light_bms_bindings/src/lib.rs | 862 ++ .../bevy_math_bms_bindings/Cargo.toml | 38 +- .../bevy_math_bms_bindings/src/lib.rs | 470 +- .../bevy_mesh_bms_bindings/Cargo.toml | 31 +- .../bevy_mesh_bms_bindings/src/lib.rs | 723 +- .../bindings/bevy_pbr_bms_bindings/Cargo.toml | 52 +- .../bindings/bevy_pbr_bms_bindings/src/lib.rs | 938 +- .../bevy_picking_bms_bindings/Cargo.toml | 34 +- .../bevy_picking_bms_bindings/src/lib.rs | 1966 +++-- .../bevy_post_process_bms_bindings/Cargo.toml | 59 + .../bevy_post_process_bms_bindings/README.md | 4 + .../bevy_post_process_bms_bindings/src/lib.rs | 363 + .../bevy_reflect_bms_bindings/Cargo.toml | 44 +- .../bevy_reflect_bms_bindings/src/lib.rs | 7550 ++++++++++++++--- .../bevy_render_bms_bindings/Cargo.toml | 91 +- .../bevy_render_bms_bindings/src/lib.rs | 2311 +---- .../bevy_scene_bms_bindings/Cargo.toml | 36 +- .../bevy_sprite_bms_bindings/Cargo.toml | 44 +- .../bevy_sprite_bms_bindings/src/lib.rs | 444 +- .../Cargo.toml | 65 + .../bevy_sprite_render_bms_bindings/README.md | 4 + .../src/lib.rs | 527 ++ .../bevy_text_bms_bindings/Cargo.toml | 40 +- .../bevy_text_bms_bindings/src/lib.rs | 360 +- .../bevy_time_bms_bindings/Cargo.toml | 25 +- .../bevy_time_bms_bindings/src/lib.rs | 51 +- .../bevy_transform_bms_bindings/Cargo.toml | 53 +- .../bevy_transform_bms_bindings/src/lib.rs | 72 +- .../bindings/bevy_ui_bms_bindings/Cargo.toml | 63 + .../bindings/bevy_ui_bms_bindings/README.md | 4 + .../bindings/bevy_ui_bms_bindings/src/lib.rs | 6263 ++++++++++++++ .../bevy_ui_render_bms_bindings/Cargo.toml | 63 + .../bevy_ui_render_bms_bindings/README.md | 4 + .../bevy_ui_render_bms_bindings/src/lib.rs | 153 + 62 files changed, 21215 insertions(+), 7797 deletions(-) create mode 100644 crates/bindings/bevy_camera_bms_bindings/Cargo.toml create mode 100644 crates/bindings/bevy_camera_bms_bindings/README.md create mode 100644 crates/bindings/bevy_camera_bms_bindings/src/lib.rs create mode 100644 crates/bindings/bevy_light_bms_bindings/Cargo.toml create mode 100644 crates/bindings/bevy_light_bms_bindings/README.md create mode 100644 crates/bindings/bevy_light_bms_bindings/src/lib.rs create mode 100644 crates/bindings/bevy_post_process_bms_bindings/Cargo.toml create mode 100644 crates/bindings/bevy_post_process_bms_bindings/README.md create mode 100644 crates/bindings/bevy_post_process_bms_bindings/src/lib.rs create mode 100644 crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml create mode 100644 crates/bindings/bevy_sprite_render_bms_bindings/README.md create mode 100644 crates/bindings/bevy_sprite_render_bms_bindings/src/lib.rs create mode 100644 crates/bindings/bevy_ui_bms_bindings/Cargo.toml create mode 100644 crates/bindings/bevy_ui_bms_bindings/README.md create mode 100644 crates/bindings/bevy_ui_bms_bindings/src/lib.rs create mode 100644 crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml create mode 100644 crates/bindings/bevy_ui_render_bms_bindings/README.md create mode 100644 crates/bindings/bevy_ui_render_bms_bindings/src/lib.rs diff --git a/codegen/crates/crate_feature_graph/src/feature.rs b/codegen/crates/crate_feature_graph/src/feature.rs index 0f34a8b550..96fa7752ac 100644 --- a/codegen/crates/crate_feature_graph/src/feature.rs +++ b/codegen/crates/crate_feature_graph/src/feature.rs @@ -49,6 +49,10 @@ impl FeatureName { pub fn new(name: impl Into>) -> Self { Self(name.into()) } + + pub fn is_special_default_enabling_feature(&self) -> bool { + self.0.contains("enable_default_for") + } } impl Display for FeatureName { @@ -228,7 +232,7 @@ pub struct Crate { pub version: Version, pub in_workspace: Option, pub active_features: Option>, - pub active_dependency_features: Option>>, + pub active_dependency_features: Option>>, pub is_enabled: Option, } diff --git a/codegen/crates/crate_feature_graph/src/graph.rs b/codegen/crates/crate_feature_graph/src/graph.rs index af18cadcc2..9ce700e175 100644 --- a/codegen/crates/crate_feature_graph/src/graph.rs +++ b/codegen/crates/crate_feature_graph/src/graph.rs @@ -331,7 +331,11 @@ impl WorkspaceGraph { .map(|(k, v)| { ( k.to_string(), - v.iter().map(|f| f.to_string()).collect::>(), + v.iter() + .map(|(f, enabled_by_shared)| { + (f.to_string(), enabled_by_shared) + }) + .collect::>(), ) }) .collect() @@ -345,7 +349,20 @@ impl WorkspaceGraph { active_features.join("\\n"), active_dependencies .iter() - .map(|(k, v)| format!("{}: [{}]", k, v.join(", "))) + .map(|(k, v)| format!( + "{}: [{}]", + k, + v.iter() + .map(|(f, enabled_by_shared)| format!( + "{}{}", + f, + enabled_by_shared + .then_some(String::from(" (*shared)")) + .unwrap_or_default() + )) + .collect::>() + .join(", ") + )) .collect::>() .join("\\n") ); @@ -555,7 +572,7 @@ impl WorkspaceGraph { } // then compute the active dependency features for each crate - let mut active_dependency_features = HashMap::<_, Vec<_>>::new(); + let mut active_dependency_features = HashMap::<_, Vec<(_, _)>>::new(); for krate in self .workspace .all_crates() @@ -585,12 +602,34 @@ impl WorkspaceGraph { active_dependency_features .entry((krate.name.clone(), dependency.name.clone())) .or_default() - .push(feature.clone()); + .push((feature.clone(), false)); + } + } + } + // now go through the active features for this crate, and add remaining features enabled by cargo through other crates + if let Some(entry) = active_dependency_features + .get_mut(&(krate.name.clone(), dependency.name.clone())) + { + // find features on these active deps, that must now be enabled, we show that on the graph with a note + for feat in self + .workspace + .find_crate_opt(&dependency.name) + .iter() + .flat_map(|d| d.active_features.iter()) + .flatten() + .filter(|f| !f.is_special_default_enabling_feature()) + { + // meh + let val = (feat.clone(), true); + let false_val = (feat.clone(), false); + if !entry.contains(&val) && !entry.contains(&false_val) { + entry.push(val); } } } } } + // finally remove all enable_default_for_ features not to pollute the output // and insert the previously computed active dependency features for krate in self.workspace.all_crates_mut() { diff --git a/codegen/src/passes/write_meta.rs b/codegen/src/passes/write_meta.rs index 1d478f2964..9f027b507c 100644 --- a/codegen/src/passes/write_meta.rs +++ b/codegen/src/passes/write_meta.rs @@ -51,7 +51,10 @@ pub(crate) fn write_meta(ctxt: &mut BevyCtxt<'_>, _args: &Args) -> bool { k.to_string(), Dependency { version: d.version.to_string(), - features: features.iter().map(|f| f.to_string()).collect(), + features: features + .iter() + .map(|(feat_name, _)| feat_name.to_string()) + .collect(), }, ), None => todo!(), diff --git a/crates/bindings/bevy_a11y_bms_bindings/Cargo.toml b/crates/bindings/bevy_a11y_bms_bindings/Cargo.toml index b910600307..3fbc89a7cf 100644 --- a/crates/bindings/bevy_a11y_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_a11y_bms_bindings/Cargo.toml @@ -17,25 +17,15 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_a11y = { version = "0.16.1", features = [ - "std", - "bevy_reflect", -], default-features = true } +bevy_a11y = { version = "0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_app = { version = "^0.16.1", features = [ - "std", - "bevy_reflect", -], default-features = false } +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "reflect_auto_register", "error_panic_hook"], default-features = true} -bevy_derive = { version = "^0.16.1", features = [], default-features = true } +bevy_derive = { version = "^0.17.2", features = [], default-features = true} + +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "multi_threaded", "reflect_auto_register", "backtrace", "serialize"], default-features = true} + +bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_ecs = { version = "^0.16.1", features = [ - "std", - "bevy_reflect", - "async_executor", -], default-features = false } -bevy_reflect = { version = "^0.16.1", features = [ - "std", -], default-features = false } diff --git a/crates/bindings/bevy_a11y_bms_bindings/src/lib.rs b/crates/bindings/bevy_a11y_bms_bindings/src/lib.rs index 0bd6d37980..f041856a82 100644 --- a/crates/bindings/bevy_a11y_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_a11y_bms_bindings/src/lib.rs @@ -47,7 +47,7 @@ pub(crate) fn register_accessibility_requested_functions(world: &mut World) { }; output }, - " Returns `true` if an access technology is active and accessibility tree\n updates should be sent.", + " Checks if any assistive technology has requested accessibility\n information.\n If so, this method returns `true`, indicating that accessibility tree\n updates should be sent.", &["_self"], ) .register_documented( @@ -65,7 +65,7 @@ pub(crate) fn register_accessibility_requested_functions(world: &mut World) { }; output }, - " Sets whether accessibility updates were requested by an access technology.", + " Sets the app's preference for sending accessibility updates.\n If the `value` argument is `true`, this method requests that the app,\n including both Bevy and third-party interfaces, provides updates to\n accessibility information.\n Setting with `false` requests that the entire app stops providing these\n updates.", &["_self", "value"], ); let registry = world.get_resource_or_init::(); @@ -109,7 +109,7 @@ pub(crate) fn register_manage_accessibility_updates_functions(world: &mut World) }; output }, - " Returns `true` if the ECS should update the accessibility tree.", + " Returns `true` if Bevy's ECS should update the accessibility tree.", &["_self"], ) .register_documented( @@ -124,7 +124,7 @@ pub(crate) fn register_manage_accessibility_updates_functions(world: &mut World) }; output }, - " Sets whether the ECS should update the accessibility tree.", + " Sets whether Bevy's ECS should update the accessibility tree.", &["_self", "value"], ); let registry = world.get_resource_or_init::(); @@ -135,16 +135,16 @@ pub(crate) fn register_manage_accessibility_updates_functions(world: &mut World) bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_accessibility_system_functions(world: &mut World) { +pub(crate) fn register_accessibility_systems_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_a11y::AccessibilitySystem, + ::bevy_a11y::AccessibilitySystems, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_a11y::AccessibilitySystem>| { + |_self: Ref<::bevy_a11y::AccessibilitySystems>| { let output: () = { { - let output: () = <::bevy_a11y::AccessibilitySystem as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_a11y::AccessibilitySystems as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -158,10 +158,10 @@ pub(crate) fn register_accessibility_system_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_a11y::AccessibilitySystem>| { - let output: Val<::bevy_a11y::AccessibilitySystem> = { + |_self: Ref<::bevy_a11y::AccessibilitySystems>| { + let output: Val<::bevy_a11y::AccessibilitySystems> = { { - let output: Val<::bevy_a11y::AccessibilitySystem> = <::bevy_a11y::AccessibilitySystem as ::core::clone::Clone>::clone( + let output: Val<::bevy_a11y::AccessibilitySystems> = <::bevy_a11y::AccessibilitySystems as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -176,13 +176,13 @@ pub(crate) fn register_accessibility_system_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_a11y::AccessibilitySystem>, - other: Ref<::bevy_a11y::AccessibilitySystem>| + _self: Ref<::bevy_a11y::AccessibilitySystems>, + other: Ref<::bevy_a11y::AccessibilitySystems>| { let output: bool = { { - let output: bool = <::bevy_a11y::AccessibilitySystem as ::core::cmp::PartialEq< - ::bevy_a11y::AccessibilitySystem, + let output: bool = <::bevy_a11y::AccessibilitySystems as ::core::cmp::PartialEq< + ::bevy_a11y::AccessibilitySystems, >>::eq(&_self, &other) .into(); output @@ -197,7 +197,7 @@ pub(crate) fn register_accessibility_system_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_a11y::AccessibilitySystem, + ::bevy_a11y::AccessibilitySystems, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -206,6 +206,6 @@ impl Plugin for BevyA11YScriptingPlugin { let mut world = app.world_mut(); register_accessibility_requested_functions(&mut world); register_manage_accessibility_updates_functions(&mut world); - register_accessibility_system_functions(&mut world); + register_accessibility_systems_functions(&mut world); } } diff --git a/crates/bindings/bevy_animation_bms_bindings/Cargo.toml b/crates/bindings/bevy_animation_bms_bindings/Cargo.toml index 819ad9423d..0ed8acccf8 100644 --- a/crates/bindings/bevy_animation_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_animation_bms_bindings/Cargo.toml @@ -17,47 +17,45 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_animation = { version = "0.16.1", features = [], default-features = true } +bevy_animation = { version = "0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.16.1", features = [], default-features = true } +bevy_animation_macros = { version = "^0.17.2", features = [], default-features = true} -bevy_asset = { version = "^0.16.1", features = [], default-features = true } +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} -bevy_color = { version = "^0.16.2", features = [], default-features = true } +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} -bevy_derive = { version = "^0.16.1", features = [], default-features = true } +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} -bevy_ecs = { version = "^0.16.1", features = [], default-features = true } +bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_log = { version = "^0.16.1", features = [], default-features = true } +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_math = { version = "^0.16.1", features = [], default-features = true } +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} -bevy_mesh = { version = "^0.16.1", features = [], default-features = true } +bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.16.1", features = [], default-features = true } +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_render = { version = "^0.16.1", features = [], default-features = true } +bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_time = { version = "^0.16.1", features = [], default-features = true } +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_transform = { version = "^0.16.1", features = [], default-features = true } +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} -bevy_utils = { version = "^0.16.1", features = [], default-features = true } +blake3 = { version = "^1.0", features = [], default-features = true} -blake3 = { version = "^1.0", features = [], default-features = true } +either = { version = "^1.13", features = [], default-features = true} -either = { version = "^1.13", features = [], default-features = true } +petgraph = { version = "^0.8", features = [], default-features = true} -petgraph = { version = "^0.7", features = [], default-features = true } +ron = { version = "^0.10", features = [], default-features = true} -ron = { version = "^0.8", features = [], default-features = true } +serde = { version = "^1", features = [], default-features = true} -serde = { version = "^1", features = [], default-features = true } +thread_local = { version = "^1", features = [], default-features = true} -smallvec = { version = "^1", features = [], default-features = true } +uuid = { version = "^1.13.1", features = [], default-features = true} -thread_local = { version = "^1", features = [], default-features = true } -uuid = { version = "^1.13.1", features = [], default-features = true } diff --git a/crates/bindings/bevy_animation_bms_bindings/src/lib.rs b/crates/bindings/bevy_animation_bms_bindings/src/lib.rs index 3e09ae2549..34a8730c8f 100644 --- a/crates/bindings/bevy_animation_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_animation_bms_bindings/src/lib.rs @@ -334,75 +334,6 @@ pub(crate) fn register_animation_graph_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_animation_transitions_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_animation::transition::AnimationTransitions, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_animation::transition::AnimationTransitions>| { - let output: Val<::bevy_animation::transition::AnimationTransitions> = { - { - let output: Val< - ::bevy_animation::transition::AnimationTransitions, - > = <::bevy_animation::transition::AnimationTransitions as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone_from", - | - mut _self: Mut<::bevy_animation::transition::AnimationTransitions>, - source: Ref<::bevy_animation::transition::AnimationTransitions>| - { - let output: () = { - { - let output: () = <::bevy_animation::transition::AnimationTransitions as ::std::clone::Clone>::clone_from( - &mut _self, - &source, - ) - .into(); - output - } - }; - output - }, - "", - &["_self", "source"], - ) - .register_documented( - "new", - || { - let output: Val<::bevy_animation::transition::AnimationTransitions> = { - { - let output: Val< - ::bevy_animation::transition::AnimationTransitions, - > = ::bevy_animation::transition::AnimationTransitions::new() - .into(); - output - } - }; - output - }, - " Creates a new [`AnimationTransitions`] component, ready to be added to\n an entity with an [`AnimationPlayer`].", - &[], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_animation::transition::AnimationTransitions, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} pub(crate) fn register_animation_target_id_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_animation::AnimationTargetId, @@ -880,6 +811,75 @@ pub(crate) fn register_threaded_animation_graph_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } +pub(crate) fn register_animation_transitions_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_animation::transition::AnimationTransitions, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_animation::transition::AnimationTransitions>| { + let output: Val<::bevy_animation::transition::AnimationTransitions> = { + { + let output: Val< + ::bevy_animation::transition::AnimationTransitions, + > = <::bevy_animation::transition::AnimationTransitions as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone_from", + | + mut _self: Mut<::bevy_animation::transition::AnimationTransitions>, + source: Ref<::bevy_animation::transition::AnimationTransitions>| + { + let output: () = { + { + let output: () = <::bevy_animation::transition::AnimationTransitions as ::std::clone::Clone>::clone_from( + &mut _self, + &source, + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "source"], + ) + .register_documented( + "new", + || { + let output: Val<::bevy_animation::transition::AnimationTransitions> = { + { + let output: Val< + ::bevy_animation::transition::AnimationTransitions, + > = ::bevy_animation::transition::AnimationTransitions::new() + .into(); + output + } + }; + output + }, + " Creates a new [`AnimationTransitions`] component, ready to be added to\n an entity with an [`AnimationPlayer`].", + &[], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_animation::transition::AnimationTransitions, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} pub(crate) fn register_animation_transition_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_animation::transition::AnimationTransition, @@ -920,7 +920,6 @@ impl Plugin for BevyAnimationScriptingPlugin { register_animation_clip_functions(&mut world); register_animation_player_functions(&mut world); register_animation_graph_functions(&mut world); - register_animation_transitions_functions(&mut world); register_animation_target_id_functions(&mut world); register_animation_target_functions(&mut world); register_repeat_animation_functions(&mut world); @@ -929,6 +928,7 @@ impl Plugin for BevyAnimationScriptingPlugin { register_cubic_rotation_curve_functions(&mut world); register_animation_graph_node_functions(&mut world); register_threaded_animation_graph_functions(&mut world); + register_animation_transitions_functions(&mut world); register_animation_transition_functions(&mut world); } } diff --git a/crates/bindings/bevy_asset_bms_bindings/Cargo.toml b/crates/bindings/bevy_asset_bms_bindings/Cargo.toml index 8fdf2a62d6..bfd7abf50d 100644 --- a/crates/bindings/bevy_asset_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_asset_bms_bindings/Cargo.toml @@ -12,77 +12,24 @@ keywords.workspace = true categories.workspace = true [dependencies] - - +bevy_ecs = { workspace = true, features = ["std", "bevy_reflect"] } +bevy_app = { workspace = true, features = ["std"] } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_asset = { version = "0.16.1", features = [ - "notify-debouncer-full", - "watch", - "file_watcher", - "multi_threaded", -], default-features = true } - - -async-broadcast = { version = "^0.7.2", features = [], default-features = true } - -async-fs = { version = "^2.0", features = [], default-features = true } - -async-lock = { version = "^3.0", features = [], default-features = true } - -atomicow = { version = "^1.0", features = [], default-features = true } - -bevy_app = { version = "^0.16.1", features = [], default-features = true } - -bevy_asset_macros = { version = "^0.16.1", features = [ -], default-features = true } - -bevy_ecs = { version = "^0.16.1", features = [], default-features = true } - -bevy_reflect = { version = "^0.16.1", features = [], default-features = true } - -bevy_tasks = { version = "^0.16.1", features = [ - "multi_threaded", - "multi_threaded", -], default-features = false } - -bevy_utils = { version = "^0.16.1", features = [], default-features = true } - -bevy_window = { version = "^0.16.1", features = [], default-features = true } - -bitflags = { version = "^2.3", features = [], default-features = true } - -blake3 = { version = "^1.5", features = [], default-features = true } - -crossbeam-channel = { version = "^0.5", features = [], default-features = true } - -disqualified = { version = "^1.0", features = [], default-features = true } - -either = { version = "^1.13", features = [], default-features = true } - -futures-io = { version = "^0.3", features = [], default-features = true } - -futures-lite = { version = "^2.0.1", features = [], default-features = true } - -js-sys = { version = "^0.3", features = [], default-features = true } +bevy_asset = { version = "0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} -notify-debouncer-full = { version = "^0.5.0", features = [ -], default-features = true } -parking_lot = { version = "^0.12", features = [], default-features = true } +bevy_asset_macros = { version = "^0.17.2", features = [], default-features = true} -ron = { version = "^0.8", features = [], default-features = true } +bevy_tasks = { version = "^0.17.2", features = ["multi_threaded", "async_executor", "futures-lite"], default-features = true} -serde = { version = "^1", features = [], default-features = true } +js-sys = { version = "^0.3", features = [], default-features = true} -stackfuture = { version = "^0.3", features = [], default-features = true } +wasm-bindgen = { version = "^0.2", features = [], default-features = true} -uuid = { version = "^1.13.1", features = [], default-features = true } +wasm-bindgen-futures = { version = "^0.4", features = [], default-features = true} -wasm-bindgen = { version = "^0.2", features = [], default-features = true } +web-sys = { version = "^0.3", features = [], default-features = true} -wasm-bindgen-futures = { version = "^0.4", features = [ -], default-features = true } -web-sys = { version = "^0.3", features = [], default-features = true } diff --git a/crates/bindings/bevy_asset_bms_bindings/src/lib.rs b/crates/bindings/bevy_asset_bms_bindings/src/lib.rs index a7223709a3..a99e6d8e20 100644 --- a/crates/bindings/bevy_asset_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_asset_bms_bindings/src/lib.rs @@ -12,6 +12,145 @@ use bevy_mod_scripting_bindings::{ }; use bevy_mod_scripting_derive::script_bindings; pub struct BevyAssetScriptingPlugin; +pub(crate) fn register_untyped_handle_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_asset::prelude::UntypedHandle, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_asset::prelude::UntypedHandle>| { + let output: Val<::bevy_asset::prelude::UntypedHandle> = { + { + let output: Val<::bevy_asset::prelude::UntypedHandle> = + <::bevy_asset::prelude::UntypedHandle as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_asset::prelude::UntypedHandle>, + other: Ref<::bevy_asset::prelude::UntypedHandle>| { + let output: bool = { + { + let output: bool = + <::bevy_asset::prelude::UntypedHandle as ::core::cmp::PartialEq< + ::bevy_asset::prelude::UntypedHandle, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "id", + |_self: Ref<::bevy_asset::prelude::UntypedHandle>| { + let output: Val<::bevy_asset::UntypedAssetId> = { + { + let output: Val<::bevy_asset::UntypedAssetId> = + ::bevy_asset::prelude::UntypedHandle::id(&_self).into(); + output + } + }; + output + }, + " Returns the [`UntypedAssetId`] for the referenced asset.", + &["_self"], + ) + .register_documented( + "type_id", + |_self: Ref<::bevy_asset::prelude::UntypedHandle>| { + let output: Val<::core::any::TypeId> = { + { + let output: Val<::core::any::TypeId> = + ::bevy_asset::prelude::UntypedHandle::type_id(&_self).into(); + output + } + }; + output + }, + " Returns the [`TypeId`] of the referenced [`Asset`].", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_asset::prelude::UntypedHandle, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_untyped_asset_id_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_asset::UntypedAssetId, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_asset::UntypedAssetId>| { + let output: Val<::bevy_asset::UntypedAssetId> = { + { + let output: Val<::bevy_asset::UntypedAssetId> = + <::bevy_asset::UntypedAssetId as ::core::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_asset::UntypedAssetId>, other: Ref<::bevy_asset::UntypedAssetId>| { + let output: bool = { + { + let output: bool = <::bevy_asset::UntypedAssetId as ::core::cmp::PartialEq< + ::bevy_asset::UntypedAssetId, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "type_id", + |_self: Ref<::bevy_asset::UntypedAssetId>| { + let output: Val<::core::any::TypeId> = { + { + let output: Val<::core::any::TypeId> = + ::bevy_asset::UntypedAssetId::type_id(&_self).into(); + output + } + }; + output + }, + " Returns the stored [`TypeId`] of the referenced [`Asset`].", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_asset::UntypedAssetId, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} pub(crate) fn register_asset_index_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_asset::AssetIndex, @@ -540,6 +679,8 @@ pub(crate) fn register_render_asset_usages_functions(world: &mut World) { impl Plugin for BevyAssetScriptingPlugin { fn build(&self, app: &mut App) { let mut world = app.world_mut(); + register_untyped_handle_functions(&mut world); + register_untyped_asset_id_functions(&mut world); register_asset_index_functions(&mut world); register_render_asset_usages_functions(&mut world); } diff --git a/crates/bindings/bevy_camera_bms_bindings/Cargo.toml b/crates/bindings/bevy_camera_bms_bindings/Cargo.toml new file mode 100644 index 0000000000..02a6a2dbe6 --- /dev/null +++ b/crates/bindings/bevy_camera_bms_bindings/Cargo.toml @@ -0,0 +1,47 @@ +[package] +name = "bevy_camera_bms_bindings" +description = "Automatically generated bindings for bevy_camera crate" +readme = "README.md" +version.workspace = true +edition.workspace = true +authors.workspace = true +license.workspace = true +homepage.workspace = true +repository.workspace = true +keywords.workspace = true +categories.workspace = true + +[dependencies] + + +bevy_mod_scripting_core = { workspace = true } +bevy_mod_scripting_bindings = { workspace = true } +bevy_mod_scripting_derive = { workspace = true } +bevy_camera = { version = "0.17.2", features = [], default-features = true} + + +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} + +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} + +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} + +bevy_derive = { version = "^0.17.2", features = [], default-features = true} + +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} + +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} + +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} + +bevy_mesh = { version = "^0.17.2", features = [], default-features = true} + +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} + +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} + +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} + +bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} + + diff --git a/crates/bindings/bevy_camera_bms_bindings/README.md b/crates/bindings/bevy_camera_bms_bindings/README.md new file mode 100644 index 0000000000..d7b64de5d0 --- /dev/null +++ b/crates/bindings/bevy_camera_bms_bindings/README.md @@ -0,0 +1,4 @@ +# bevy_camera bindings +This crate is part of the [bevy_mod_scripting](http://github.com/makspll/bevy_mod_scripting) project. + +The code inside is fully generated via a custom rustc plugin. \ No newline at end of file diff --git a/crates/bindings/bevy_camera_bms_bindings/src/lib.rs b/crates/bindings/bevy_camera_bms_bindings/src/lib.rs new file mode 100644 index 0000000000..d8b01861c7 --- /dev/null +++ b/crates/bindings/bevy_camera_bms_bindings/src/lib.rs @@ -0,0 +1,2209 @@ +#![allow(clippy::all)] +#![allow(unused, deprecated, dead_code)] + +use bevy_app::{App, Plugin}; +use bevy_ecs::prelude::*; +use bevy_mod_scripting_bindings::{ + ReflectReference, + function::{ + from::{Mut, Ref, Val}, + namespace::NamespaceBuilder, + }, +}; +use bevy_mod_scripting_derive::script_bindings; +pub struct BevyCameraScriptingPlugin; +pub(crate) fn register_clear_color_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::prelude::ClearColor, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::prelude::ClearColor>| { + let output: Val<::bevy_camera::prelude::ClearColor> = { + { + let output: Val<::bevy_camera::prelude::ClearColor> = + <::bevy_camera::prelude::ClearColor as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::prelude::ClearColor, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_inherited_visibility_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::visibility::InheritedVisibility, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_camera::visibility::InheritedVisibility>| { + let output: () = { + { + let output: () = <::bevy_camera::visibility::InheritedVisibility as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::visibility::InheritedVisibility>| { + let output: Val<::bevy_camera::visibility::InheritedVisibility> = { + { + let output: Val< + ::bevy_camera::visibility::InheritedVisibility, + > = <::bevy_camera::visibility::InheritedVisibility as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_camera::visibility::InheritedVisibility>, + other: Ref<::bevy_camera::visibility::InheritedVisibility>| + { + let output: bool = { + { + let output: bool = <::bevy_camera::visibility::InheritedVisibility as ::std::cmp::PartialEq< + ::bevy_camera::visibility::InheritedVisibility, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "get", + |_self: Val<::bevy_camera::visibility::InheritedVisibility>| { + let output: bool = { + { + let output: bool = ::bevy_camera::visibility::InheritedVisibility::get( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns `true` if the entity is visible in the hierarchy.\n Otherwise, returns `false`.", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::visibility::InheritedVisibility, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_view_visibility_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::visibility::ViewVisibility, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_camera::visibility::ViewVisibility>| { + let output: () = { + { + let output: () = <::bevy_camera::visibility::ViewVisibility as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::visibility::ViewVisibility>| { + let output: Val<::bevy_camera::visibility::ViewVisibility> = { + { + let output: Val<::bevy_camera::visibility::ViewVisibility> = <::bevy_camera::visibility::ViewVisibility as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_camera::visibility::ViewVisibility>, + other: Ref<::bevy_camera::visibility::ViewVisibility>| + { + let output: bool = { + { + let output: bool = <::bevy_camera::visibility::ViewVisibility as ::std::cmp::PartialEq< + ::bevy_camera::visibility::ViewVisibility, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "get", + |_self: Val<::bevy_camera::visibility::ViewVisibility>| { + let output: bool = { + { + let output: bool = ::bevy_camera::visibility::ViewVisibility::get( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns `true` if the entity is visible in any view.\n Otherwise, returns `false`.", + &["_self"], + ) + .register_documented( + "set", + |mut _self: Mut<::bevy_camera::visibility::ViewVisibility>| { + let output: () = { + { + let output: () = ::bevy_camera::visibility::ViewVisibility::set( + &mut _self, + ) + .into(); + output + } + }; + output + }, + " Sets the visibility to `true`. This should not be considered reversible for a given frame,\n as this component tracks whether or not the entity visible in _any_ view.\n This will be automatically reset to `false` every frame in [`VisibilityPropagate`] and then set\n to the proper value in [`CheckVisibility`].\n You should only manually set this if you are defining a custom visibility system,\n in which case the system should be placed in the [`CheckVisibility`] set.\n For normal user-defined entity visibility, see [`Visibility`].\n [`VisibilityPropagate`]: VisibilitySystems::VisibilityPropagate\n [`CheckVisibility`]: VisibilitySystems::CheckVisibility", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::visibility::ViewVisibility, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_visibility_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::visibility::Visibility, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_camera::visibility::Visibility>| { + let output: () = { + { + let output: () = <::bevy_camera::visibility::Visibility as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::visibility::Visibility>| { + let output: Val<::bevy_camera::visibility::Visibility> = { + { + let output: Val<::bevy_camera::visibility::Visibility> = <::bevy_camera::visibility::Visibility as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_camera::visibility::Visibility>, + other: Ref<::bevy_camera::visibility::Visibility>| + { + let output: bool = { + { + let output: bool = <::bevy_camera::visibility::Visibility as ::std::cmp::PartialEq< + ::bevy_camera::visibility::Visibility, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "toggle_inherited_hidden", + |mut _self: Mut<::bevy_camera::visibility::Visibility>| { + let output: () = { + { + let output: () = ::bevy_camera::visibility::Visibility::toggle_inherited_hidden( + &mut _self, + ) + .into(); + output + } + }; + output + }, + " Toggles between `Visibility::Inherited` and `Visibility::Hidden`.\n If the value is `Visibility::Visible`, it remains unaffected.", + &["_self"], + ) + .register_documented( + "toggle_inherited_visible", + |mut _self: Mut<::bevy_camera::visibility::Visibility>| { + let output: () = { + { + let output: () = ::bevy_camera::visibility::Visibility::toggle_inherited_visible( + &mut _self, + ) + .into(); + output + } + }; + output + }, + " Toggles between `Visibility::Inherited` and `Visibility::Visible`.\n If the value is `Visibility::Hidden`, it remains unaffected.", + &["_self"], + ) + .register_documented( + "toggle_visible_hidden", + |mut _self: Mut<::bevy_camera::visibility::Visibility>| { + let output: () = { + { + let output: () = ::bevy_camera::visibility::Visibility::toggle_visible_hidden( + &mut _self, + ) + .into(); + output + } + }; + output + }, + " Toggles between `Visibility::Visible` and `Visibility::Hidden`.\n If the value is `Visibility::Inherited`, it remains unaffected.", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::visibility::Visibility, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_camera_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::prelude::Camera, + >::new(world) + .register_documented( + "clip_from_view", + |_self: Ref<::bevy_camera::prelude::Camera>| { + let output: Val<::bevy_math::Mat4> = { + { + let output: Val<::bevy_math::Mat4> = ::bevy_camera::prelude::Camera::clip_from_view( + &_self, + ) + .into(); + output + } + }; + output + }, + " The projection matrix computed using this camera's [`Projection`](super::projection::Projection).", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::prelude::Camera>| { + let output: Val<::bevy_camera::prelude::Camera> = { + { + let output: Val<::bevy_camera::prelude::Camera> = <::bevy_camera::prelude::Camera as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "depth_ndc_to_view_z", + |_self: Ref<::bevy_camera::prelude::Camera>, ndc_depth: f32| { + let output: f32 = { + { + let output: f32 = ::bevy_camera::prelude::Camera::depth_ndc_to_view_z( + &_self, + ndc_depth, + ) + .into(); + output + } + }; + output + }, + " Converts the depth in Normalized Device Coordinates\n to linear view z for perspective projections.\n Note: Depth values in front of the camera will be negative as -z is forward", + &["_self", "ndc_depth"], + ) + .register_documented( + "depth_ndc_to_view_z_2d", + |_self: Ref<::bevy_camera::prelude::Camera>, ndc_depth: f32| { + let output: f32 = { + { + let output: f32 = ::bevy_camera::prelude::Camera::depth_ndc_to_view_z_2d( + &_self, + ndc_depth, + ) + .into(); + output + } + }; + output + }, + " Converts the depth in Normalized Device Coordinates\n to linear view z for orthographic projections.\n Note: Depth values in front of the camera will be negative as -z is forward", + &["_self", "ndc_depth"], + ) + .register_documented( + "target_scaling_factor", + |_self: Ref<::bevy_camera::prelude::Camera>| { + let output: ::std::option::Option = { + { + let output: ::std::option::Option = ::bevy_camera::prelude::Camera::target_scaling_factor( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::prelude::Camera, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_camera_2_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::prelude::Camera2d, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::prelude::Camera2d>| { + let output: Val<::bevy_camera::prelude::Camera2d> = { + { + let output: Val<::bevy_camera::prelude::Camera2d> = + <::bevy_camera::prelude::Camera2d as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::prelude::Camera2d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_camera_3_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::prelude::Camera3d, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::prelude::Camera3d>| { + let output: Val<::bevy_camera::prelude::Camera3d> = { + { + let output: Val<::bevy_camera::prelude::Camera3d> = + <::bevy_camera::prelude::Camera3d as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::prelude::Camera3d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_clear_color_config_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::prelude::ClearColorConfig, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::prelude::ClearColorConfig>| { + let output: Val<::bevy_camera::prelude::ClearColorConfig> = { + { + let output: Val<::bevy_camera::prelude::ClearColorConfig> = + <::bevy_camera::prelude::ClearColorConfig as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::prelude::ClearColorConfig, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_orthographic_projection_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::prelude::OrthographicProjection, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::prelude::OrthographicProjection>| { + let output: Val<::bevy_camera::prelude::OrthographicProjection> = { + { + let output: Val< + ::bevy_camera::prelude::OrthographicProjection, + > = <::bevy_camera::prelude::OrthographicProjection as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "default_2d", + || { + let output: Val<::bevy_camera::prelude::OrthographicProjection> = { + { + let output: Val< + ::bevy_camera::prelude::OrthographicProjection, + > = ::bevy_camera::prelude::OrthographicProjection::default_2d() + .into(); + output + } + }; + output + }, + " Returns the default orthographic projection for a 2D context.\n The near plane is set to a negative value so that the camera can still\n render the scene when using positive z coordinates to order foreground elements.", + &[], + ) + .register_documented( + "default_3d", + || { + let output: Val<::bevy_camera::prelude::OrthographicProjection> = { + { + let output: Val< + ::bevy_camera::prelude::OrthographicProjection, + > = ::bevy_camera::prelude::OrthographicProjection::default_3d() + .into(); + output + } + }; + output + }, + " Returns the default orthographic projection for a 3D context.\n The near plane is set to 0.0 so that the camera doesn't render\n objects that are behind it.", + &[], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::prelude::OrthographicProjection, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_perspective_projection_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::prelude::PerspectiveProjection, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::prelude::PerspectiveProjection>| { + let output: Val<::bevy_camera::prelude::PerspectiveProjection> = { + { + let output: Val<::bevy_camera::prelude::PerspectiveProjection> = <::bevy_camera::prelude::PerspectiveProjection as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::prelude::PerspectiveProjection, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_projection_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::prelude::Projection, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::prelude::Projection>| { + let output: Val<::bevy_camera::prelude::Projection> = { + { + let output: Val<::bevy_camera::prelude::Projection> = <::bevy_camera::prelude::Projection as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "is_perspective", + |_self: Ref<::bevy_camera::prelude::Projection>| { + let output: bool = { + { + let output: bool = ::bevy_camera::prelude::Projection::is_perspective( + &_self, + ) + .into(); + output + } + }; + output + }, + " Check if the projection is perspective.\n For [`CustomProjection`], this checks if the projection matrix's w-axis's w is 0.0.", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::prelude::Projection, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_frustum_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::primitives::Frustum, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::primitives::Frustum>| { + let output: Val<::bevy_camera::primitives::Frustum> = { + { + let output: Val<::bevy_camera::primitives::Frustum> = <::bevy_camera::primitives::Frustum as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "contains_aabb", + | + _self: Ref<::bevy_camera::primitives::Frustum>, + aabb: Ref<::bevy_camera::primitives::Aabb>, + world_from_local: Ref<::bevy_math::Affine3A>| + { + let output: bool = { + { + let output: bool = ::bevy_camera::primitives::Frustum::contains_aabb( + &_self, + &aabb, + &world_from_local, + ) + .into(); + output + } + }; + output + }, + " Check if the frustum contains the Axis-Aligned Bounding Box (AABB).\n Referenced from: [Frustum Culling](https://learnopengl.com/Guest-Articles/2021/Scene/Frustum-Culling)", + &["_self", "aabb", "world_from_local"], + ) + .register_documented( + "from_clip_from_world", + |clip_from_world: Ref<::bevy_math::Mat4>| { + let output: Val<::bevy_camera::primitives::Frustum> = { + { + let output: Val<::bevy_camera::primitives::Frustum> = ::bevy_camera::primitives::Frustum::from_clip_from_world( + &clip_from_world, + ) + .into(); + output + } + }; + output + }, + " Returns a frustum derived from `clip_from_world`.", + &["clip_from_world"], + ) + .register_documented( + "from_clip_from_world_custom_far", + | + clip_from_world: Ref<::bevy_math::Mat4>, + view_translation: Ref<::bevy_math::Vec3>, + view_backward: Ref<::bevy_math::Vec3>, + far: f32| + { + let output: Val<::bevy_camera::primitives::Frustum> = { + { + let output: Val<::bevy_camera::primitives::Frustum> = ::bevy_camera::primitives::Frustum::from_clip_from_world_custom_far( + &clip_from_world, + &view_translation, + &view_backward, + far, + ) + .into(); + output + } + }; + output + }, + " Returns a frustum derived from `clip_from_world`,\n but with a custom far plane.", + &["clip_from_world", "view_translation", "view_backward", "far"], + ) + .register_documented( + "intersects_obb", + | + _self: Ref<::bevy_camera::primitives::Frustum>, + aabb: Ref<::bevy_camera::primitives::Aabb>, + world_from_local: Ref<::bevy_math::Affine3A>, + intersect_near: bool, + intersect_far: bool| + { + let output: bool = { + { + let output: bool = ::bevy_camera::primitives::Frustum::intersects_obb( + &_self, + &aabb, + &world_from_local, + intersect_near, + intersect_far, + ) + .into(); + output + } + }; + output + }, + " Checks if an Oriented Bounding Box (obb) intersects the frustum.", + &["_self", "aabb", "world_from_local", "intersect_near", "intersect_far"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::primitives::Frustum, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_visible_entities_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::visibility::VisibleEntities, + >::new(world) + .register_documented( + "clear", + |mut _self: Mut<::bevy_camera::visibility::VisibleEntities>, + type_id: Val<::std::any::TypeId>| { + let output: () = { + { + let output: () = ::bevy_camera::visibility::VisibleEntities::clear( + &mut _self, + type_id.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "type_id"], + ) + .register_documented( + "clear_all", + |mut _self: Mut<::bevy_camera::visibility::VisibleEntities>| { + let output: () = { + { + let output: () = + ::bevy_camera::visibility::VisibleEntities::clear_all(&mut _self).into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::visibility::VisibleEntities>| { + let output: Val<::bevy_camera::visibility::VisibleEntities> = { + { + let output: Val<::bevy_camera::visibility::VisibleEntities> = + <::bevy_camera::visibility::VisibleEntities as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "is_empty", + |_self: Ref<::bevy_camera::visibility::VisibleEntities>, + type_id: Val<::std::any::TypeId>| { + let output: bool = { + { + let output: bool = ::bevy_camera::visibility::VisibleEntities::is_empty( + &_self, + type_id.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "type_id"], + ) + .register_documented( + "len", + |_self: Ref<::bevy_camera::visibility::VisibleEntities>, + type_id: Val<::std::any::TypeId>| { + let output: usize = { + { + let output: usize = ::bevy_camera::visibility::VisibleEntities::len( + &_self, + type_id.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "type_id"], + ) + .register_documented( + "push", + |mut _self: Mut<::bevy_camera::visibility::VisibleEntities>, + entity: Val<::bevy_ecs::entity::Entity>, + type_id: Val<::std::any::TypeId>| { + let output: () = { + { + let output: () = ::bevy_camera::visibility::VisibleEntities::push( + &mut _self, + entity.into_inner(), + type_id.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "entity", "type_id"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::visibility::VisibleEntities, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_viewport_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::Viewport, + >::new(world) + .register_documented( + "clamp_to_size", + |mut _self: Mut<::bevy_camera::Viewport>, size: Val<::bevy_math::UVec2>| { + let output: () = { + { + let output: () = ::bevy_camera::Viewport::clamp_to_size( + &mut _self, + size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Cut the viewport rectangle so that it lies inside a rectangle of the\n given size.\n If either of the viewport's position coordinates lies outside the given\n dimensions, it will be moved just inside first. If either of the given\n dimensions is zero, the position and size of the viewport rectangle will\n both be set to zero in that dimension.", + &["_self", "size"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::Viewport>| { + let output: Val<::bevy_camera::Viewport> = { + { + let output: Val<::bevy_camera::Viewport> = <::bevy_camera::Viewport as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::Viewport, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_main_pass_resolution_override_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::MainPassResolutionOverride, + >::new(world); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::MainPassResolutionOverride, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_sub_camera_view_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::SubCameraView, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::SubCameraView>| { + let output: Val<::bevy_camera::SubCameraView> = { + { + let output: Val<::bevy_camera::SubCameraView> = + <::bevy_camera::SubCameraView as ::std::clone::Clone>::clone(&_self).into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_camera::SubCameraView>, other: Ref<::bevy_camera::SubCameraView>| { + let output: bool = { + { + let output: bool = <::bevy_camera::SubCameraView as ::std::cmp::PartialEq< + ::bevy_camera::SubCameraView, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::SubCameraView, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_exposure_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::Exposure, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::Exposure>| { + let output: Val<::bevy_camera::Exposure> = { + { + let output: Val<::bevy_camera::Exposure> = <::bevy_camera::Exposure as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "exposure", + |_self: Ref<::bevy_camera::Exposure>| { + let output: f32 = { + { + let output: f32 = ::bevy_camera::Exposure::exposure(&_self) + .into(); + output + } + }; + output + }, + " Converts EV100 values to exposure values.\n ", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::Exposure, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_camera_main_texture_usages_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::CameraMainTextureUsages, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::CameraMainTextureUsages>| { + let output: Val<::bevy_camera::CameraMainTextureUsages> = { + { + let output: Val<::bevy_camera::CameraMainTextureUsages> = + <::bevy_camera::CameraMainTextureUsages as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::CameraMainTextureUsages, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_render_target_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::RenderTarget, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::RenderTarget>| { + let output: Val<::bevy_camera::RenderTarget> = { + { + let output: Val<::bevy_camera::RenderTarget> = <::bevy_camera::RenderTarget as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::RenderTarget, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_image_render_target_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::ImageRenderTarget, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_camera::ImageRenderTarget>| { + let output: () = { + { + let output: () = <::bevy_camera::ImageRenderTarget as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::ImageRenderTarget>| { + let output: Val<::bevy_camera::ImageRenderTarget> = { + { + let output: Val<::bevy_camera::ImageRenderTarget> = <::bevy_camera::ImageRenderTarget as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_camera::ImageRenderTarget>, + other: Ref<::bevy_camera::ImageRenderTarget>| + { + let output: bool = { + { + let output: bool = <::bevy_camera::ImageRenderTarget as ::std::cmp::PartialEq< + ::bevy_camera::ImageRenderTarget, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::ImageRenderTarget, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_manual_texture_view_handle_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::ManualTextureViewHandle, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_camera::ManualTextureViewHandle>| { + let output: () = { + { + let output: () = <::bevy_camera::ManualTextureViewHandle as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::ManualTextureViewHandle>| { + let output: Val<::bevy_camera::ManualTextureViewHandle> = { + { + let output: Val<::bevy_camera::ManualTextureViewHandle> = <::bevy_camera::ManualTextureViewHandle as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_camera::ManualTextureViewHandle>, + other: Ref<::bevy_camera::ManualTextureViewHandle>| + { + let output: bool = { + { + let output: bool = <::bevy_camera::ManualTextureViewHandle as ::std::cmp::PartialEq< + ::bevy_camera::ManualTextureViewHandle, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::ManualTextureViewHandle, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_normalized_render_target_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::NormalizedRenderTarget, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_camera::NormalizedRenderTarget>| { + let output: () = { + { + let output: () = <::bevy_camera::NormalizedRenderTarget as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::NormalizedRenderTarget>| { + let output: Val<::bevy_camera::NormalizedRenderTarget> = { + { + let output: Val<::bevy_camera::NormalizedRenderTarget> = <::bevy_camera::NormalizedRenderTarget as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_camera::NormalizedRenderTarget>, + other: Ref<::bevy_camera::NormalizedRenderTarget>| + { + let output: bool = { + { + let output: bool = <::bevy_camera::NormalizedRenderTarget as ::std::cmp::PartialEq< + ::bevy_camera::NormalizedRenderTarget, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::NormalizedRenderTarget, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_camera_3_d_depth_load_op_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::Camera3dDepthLoadOp, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::Camera3dDepthLoadOp>| { + let output: Val<::bevy_camera::Camera3dDepthLoadOp> = { + { + let output: Val<::bevy_camera::Camera3dDepthLoadOp> = + <::bevy_camera::Camera3dDepthLoadOp as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::Camera3dDepthLoadOp, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_camera_3_d_depth_texture_usage_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::Camera3dDepthTextureUsage, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::Camera3dDepthTextureUsage>| { + let output: Val<::bevy_camera::Camera3dDepthTextureUsage> = { + { + let output: Val<::bevy_camera::Camera3dDepthTextureUsage> = + <::bevy_camera::Camera3dDepthTextureUsage as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::Camera3dDepthTextureUsage, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_screen_space_transmission_quality_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::ScreenSpaceTransmissionQuality, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::ScreenSpaceTransmissionQuality>| { + let output: Val<::bevy_camera::ScreenSpaceTransmissionQuality> = { + { + let output: Val<::bevy_camera::ScreenSpaceTransmissionQuality> = <::bevy_camera::ScreenSpaceTransmissionQuality as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_camera::ScreenSpaceTransmissionQuality>, + other: Ref<::bevy_camera::ScreenSpaceTransmissionQuality>| + { + let output: bool = { + { + let output: bool = <::bevy_camera::ScreenSpaceTransmissionQuality as ::std::cmp::PartialEq< + ::bevy_camera::ScreenSpaceTransmissionQuality, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::ScreenSpaceTransmissionQuality, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_aabb_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::primitives::Aabb, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::primitives::Aabb>| { + let output: Val<::bevy_camera::primitives::Aabb> = { + { + let output: Val<::bevy_camera::primitives::Aabb> = + <::bevy_camera::primitives::Aabb as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_camera::primitives::Aabb>, + other: Ref<::bevy_camera::primitives::Aabb>| { + let output: bool = { + { + let output: bool = <::bevy_camera::primitives::Aabb as ::std::cmp::PartialEq< + ::bevy_camera::primitives::Aabb, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "from_min_max", + |minimum: Val<::bevy_math::Vec3>, maximum: Val<::bevy_math::Vec3>| { + let output: Val<::bevy_camera::primitives::Aabb> = { + { + let output: Val<::bevy_camera::primitives::Aabb> = + ::bevy_camera::primitives::Aabb::from_min_max( + minimum.into_inner(), + maximum.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["minimum", "maximum"], + ) + .register_documented( + "max", + |_self: Ref<::bevy_camera::primitives::Aabb>| { + let output: Val<::bevy_math::Vec3A> = { + { + let output: Val<::bevy_math::Vec3A> = + ::bevy_camera::primitives::Aabb::max(&_self).into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "min", + |_self: Ref<::bevy_camera::primitives::Aabb>| { + let output: Val<::bevy_math::Vec3A> = { + { + let output: Val<::bevy_math::Vec3A> = + ::bevy_camera::primitives::Aabb::min(&_self).into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "relative_radius", + |_self: Ref<::bevy_camera::primitives::Aabb>, + p_normal: Ref<::bevy_math::Vec3A>, + world_from_local: Ref<::bevy_math::Mat3A>| { + let output: f32 = { + { + let output: f32 = ::bevy_camera::primitives::Aabb::relative_radius( + &_self, + &p_normal, + &world_from_local, + ) + .into(); + output + } + }; + output + }, + " Calculate the relative radius of the AABB with respect to a plane", + &["_self", "p_normal", "world_from_local"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::primitives::Aabb, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_cubemap_frusta_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::primitives::CubemapFrusta, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::primitives::CubemapFrusta>| { + let output: Val<::bevy_camera::primitives::CubemapFrusta> = { + { + let output: Val<::bevy_camera::primitives::CubemapFrusta> = + <::bevy_camera::primitives::CubemapFrusta as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::primitives::CubemapFrusta, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_cubemap_layout_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::primitives::CubemapLayout, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::primitives::CubemapLayout>| { + let output: Val<::bevy_camera::primitives::CubemapLayout> = { + { + let output: Val<::bevy_camera::primitives::CubemapLayout> = + <::bevy_camera::primitives::CubemapLayout as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::primitives::CubemapLayout, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_cascades_frusta_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::primitives::CascadesFrusta, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::primitives::CascadesFrusta>| { + let output: Val<::bevy_camera::primitives::CascadesFrusta> = { + { + let output: Val<::bevy_camera::primitives::CascadesFrusta> = + <::bevy_camera::primitives::CascadesFrusta as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::primitives::CascadesFrusta, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_custom_projection_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::CustomProjection, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::CustomProjection>| { + let output: Val<::bevy_camera::CustomProjection> = { + { + let output: Val<::bevy_camera::CustomProjection> = + <::bevy_camera::CustomProjection as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::CustomProjection, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_scaling_mode_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::ScalingMode, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::ScalingMode>| { + let output: Val<::bevy_camera::ScalingMode> = { + { + let output: Val<::bevy_camera::ScalingMode> = <::bevy_camera::ScalingMode as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::ScalingMode, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_visibility_class_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::visibility::VisibilityClass, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::visibility::VisibilityClass>| { + let output: Val<::bevy_camera::visibility::VisibilityClass> = { + { + let output: Val<::bevy_camera::visibility::VisibilityClass> = + <::bevy_camera::visibility::VisibilityClass as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::visibility::VisibilityClass, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_no_frustum_culling_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::visibility::NoFrustumCulling, + >::new(world); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::visibility::NoFrustumCulling, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_visible_mesh_entities_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::visibility::VisibleMeshEntities, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::visibility::VisibleMeshEntities>| { + let output: Val<::bevy_camera::visibility::VisibleMeshEntities> = { + { + let output: Val< + ::bevy_camera::visibility::VisibleMeshEntities, + > = <::bevy_camera::visibility::VisibleMeshEntities as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::visibility::VisibleMeshEntities, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_cubemap_visible_entities_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::visibility::CubemapVisibleEntities, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::visibility::CubemapVisibleEntities>| { + let output: Val<::bevy_camera::visibility::CubemapVisibleEntities> = { + { + let output: Val< + ::bevy_camera::visibility::CubemapVisibleEntities, + > = <::bevy_camera::visibility::CubemapVisibleEntities as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::visibility::CubemapVisibleEntities, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_cascades_visible_entities_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::visibility::CascadesVisibleEntities, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::visibility::CascadesVisibleEntities>| { + let output: Val<::bevy_camera::visibility::CascadesVisibleEntities> = { + { + let output: Val< + ::bevy_camera::visibility::CascadesVisibleEntities, + > = <::bevy_camera::visibility::CascadesVisibleEntities as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::visibility::CascadesVisibleEntities, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_render_layers_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::visibility::RenderLayers, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_camera::visibility::RenderLayers>| { + let output: () = { + { + let output: () = <::bevy_camera::visibility::RenderLayers as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::visibility::RenderLayers>| { + let output: Val<::bevy_camera::visibility::RenderLayers> = { + { + let output: Val<::bevy_camera::visibility::RenderLayers> = <::bevy_camera::visibility::RenderLayers as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_camera::visibility::RenderLayers>, + other: Ref<::bevy_camera::visibility::RenderLayers>| + { + let output: bool = { + { + let output: bool = <::bevy_camera::visibility::RenderLayers as ::std::cmp::PartialEq< + ::bevy_camera::visibility::RenderLayers, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "intersection", + | + _self: Ref<::bevy_camera::visibility::RenderLayers>, + other: Ref<::bevy_camera::visibility::RenderLayers>| + { + let output: Val<::bevy_camera::visibility::RenderLayers> = { + { + let output: Val<::bevy_camera::visibility::RenderLayers> = ::bevy_camera::visibility::RenderLayers::intersection( + &_self, + &other, + ) + .into(); + output + } + }; + output + }, + " Returns the set of [layers](Layer) shared by two instances of [`RenderLayers`].\n This corresponds to the `self & other` operation.", + &["_self", "other"], + ) + .register_documented( + "intersects", + | + _self: Ref<::bevy_camera::visibility::RenderLayers>, + other: Ref<::bevy_camera::visibility::RenderLayers>| + { + let output: bool = { + { + let output: bool = ::bevy_camera::visibility::RenderLayers::intersects( + &_self, + &other, + ) + .into(); + output + } + }; + output + }, + " Determine if a `RenderLayers` intersects another.\n `RenderLayers`s intersect if they share any common layers.\n A `RenderLayers` with no layers will not match any other\n `RenderLayers`, even another with no layers.", + &["_self", "other"], + ) + .register_documented( + "layer", + |n: usize| { + let output: Val<::bevy_camera::visibility::RenderLayers> = { + { + let output: Val<::bevy_camera::visibility::RenderLayers> = ::bevy_camera::visibility::RenderLayers::layer( + n, + ) + .into(); + output + } + }; + output + }, + " Create a new `RenderLayers` belonging to the given layer.\n This `const` constructor is limited to `size_of::()` layers.\n If you need to support an arbitrary number of layers, use [`with`](RenderLayers::with)\n or [`from_layers`](RenderLayers::from_layers).", + &["n"], + ) + .register_documented( + "none", + || { + let output: Val<::bevy_camera::visibility::RenderLayers> = { + { + let output: Val<::bevy_camera::visibility::RenderLayers> = ::bevy_camera::visibility::RenderLayers::none() + .into(); + output + } + }; + output + }, + " Create a new `RenderLayers` that belongs to no layers.\n This is distinct from [`RenderLayers::default`], which belongs to the first layer.", + &[], + ) + .register_documented( + "symmetric_difference", + | + _self: Ref<::bevy_camera::visibility::RenderLayers>, + other: Ref<::bevy_camera::visibility::RenderLayers>| + { + let output: Val<::bevy_camera::visibility::RenderLayers> = { + { + let output: Val<::bevy_camera::visibility::RenderLayers> = ::bevy_camera::visibility::RenderLayers::symmetric_difference( + &_self, + &other, + ) + .into(); + output + } + }; + output + }, + " Returns all [layers](Layer) included in exactly one of the instances of [`RenderLayers`].\n This corresponds to the \"exclusive or\" (XOR) operation: `self ^ other`.", + &["_self", "other"], + ) + .register_documented( + "union", + | + _self: Ref<::bevy_camera::visibility::RenderLayers>, + other: Ref<::bevy_camera::visibility::RenderLayers>| + { + let output: Val<::bevy_camera::visibility::RenderLayers> = { + { + let output: Val<::bevy_camera::visibility::RenderLayers> = ::bevy_camera::visibility::RenderLayers::union( + &_self, + &other, + ) + .into(); + output + } + }; + output + }, + " Returns all [layers](Layer) included in either instance of [`RenderLayers`].\n This corresponds to the `self | other` operation.", + &["_self", "other"], + ) + .register_documented( + "with", + |_self: Val<::bevy_camera::visibility::RenderLayers>, layer: usize| { + let output: Val<::bevy_camera::visibility::RenderLayers> = { + { + let output: Val<::bevy_camera::visibility::RenderLayers> = ::bevy_camera::visibility::RenderLayers::with( + _self.into_inner(), + layer, + ) + .into(); + output + } + }; + output + }, + " Add the given layer.\n This may be called multiple times to allow an entity to belong\n to multiple rendering layers.", + &["_self", "layer"], + ) + .register_documented( + "without", + |_self: Val<::bevy_camera::visibility::RenderLayers>, layer: usize| { + let output: Val<::bevy_camera::visibility::RenderLayers> = { + { + let output: Val<::bevy_camera::visibility::RenderLayers> = ::bevy_camera::visibility::RenderLayers::without( + _self.into_inner(), + layer, + ) + .into(); + output + } + }; + output + }, + " Removes the given rendering layer.", + &["_self", "layer"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::visibility::RenderLayers, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_visibility_range_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_camera::visibility::VisibilityRange, + >::new(world) + .register_documented( + "abrupt", + |start: f32, end: f32| { + let output: Val<::bevy_camera::visibility::VisibilityRange> = { + { + let output: Val<::bevy_camera::visibility::VisibilityRange> = ::bevy_camera::visibility::VisibilityRange::abrupt( + start, + end, + ) + .into(); + output + } + }; + output + }, + " Creates a new *abrupt* visibility range, with no crossfade.\n There will be no crossfade; the object will immediately vanish if the\n camera is closer than `start` units or farther than `end` units from the\n model.\n The `start` value must be less than or equal to the `end` value.", + &["start", "end"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::visibility::VisibilityRange>| { + let output: Val<::bevy_camera::visibility::VisibilityRange> = { + { + let output: Val<::bevy_camera::visibility::VisibilityRange> = <::bevy_camera::visibility::VisibilityRange as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_camera::visibility::VisibilityRange>, + other: Ref<::bevy_camera::visibility::VisibilityRange>| + { + let output: bool = { + { + let output: bool = <::bevy_camera::visibility::VisibilityRange as ::std::cmp::PartialEq< + ::bevy_camera::visibility::VisibilityRange, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "is_abrupt", + |_self: Ref<::bevy_camera::visibility::VisibilityRange>| { + let output: bool = { + { + let output: bool = ::bevy_camera::visibility::VisibilityRange::is_abrupt( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns true if both the start and end transitions for this range are\n abrupt: that is, there is no crossfading.", + &["_self"], + ) + .register_documented( + "is_culled", + | + _self: Ref<::bevy_camera::visibility::VisibilityRange>, + camera_distance: f32| + { + let output: bool = { + { + let output: bool = ::bevy_camera::visibility::VisibilityRange::is_culled( + &_self, + camera_distance, + ) + .into(); + output + } + }; + output + }, + " Returns true if the object is completely invisible, given a camera\n `camera_distance` units away.\n This is equivalent to `!VisibilityRange::is_visible_at_all()`.", + &["_self", "camera_distance"], + ) + .register_documented( + "is_visible_at_all", + | + _self: Ref<::bevy_camera::visibility::VisibilityRange>, + camera_distance: f32| + { + let output: bool = { + { + let output: bool = ::bevy_camera::visibility::VisibilityRange::is_visible_at_all( + &_self, + camera_distance, + ) + .into(); + output + } + }; + output + }, + " Returns true if the object will be visible at all, given a camera\n `camera_distance` units away.\n Any amount of visibility, even with the heaviest dithering applied, is\n considered visible according to this check.", + &["_self", "camera_distance"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_camera::visibility::VisibilityRange, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +impl Plugin for BevyCameraScriptingPlugin { + fn build(&self, app: &mut App) { + let mut world = app.world_mut(); + register_clear_color_functions(&mut world); + register_inherited_visibility_functions(&mut world); + register_view_visibility_functions(&mut world); + register_visibility_functions(&mut world); + register_camera_functions(&mut world); + register_camera_2_d_functions(&mut world); + register_camera_3_d_functions(&mut world); + register_clear_color_config_functions(&mut world); + register_orthographic_projection_functions(&mut world); + register_perspective_projection_functions(&mut world); + register_projection_functions(&mut world); + register_frustum_functions(&mut world); + register_visible_entities_functions(&mut world); + register_viewport_functions(&mut world); + register_main_pass_resolution_override_functions(&mut world); + register_sub_camera_view_functions(&mut world); + register_exposure_functions(&mut world); + register_camera_main_texture_usages_functions(&mut world); + register_render_target_functions(&mut world); + register_image_render_target_functions(&mut world); + register_manual_texture_view_handle_functions(&mut world); + register_normalized_render_target_functions(&mut world); + register_camera_3_d_depth_load_op_functions(&mut world); + register_camera_3_d_depth_texture_usage_functions(&mut world); + register_screen_space_transmission_quality_functions(&mut world); + register_aabb_functions(&mut world); + register_cubemap_frusta_functions(&mut world); + register_cubemap_layout_functions(&mut world); + register_cascades_frusta_functions(&mut world); + register_custom_projection_functions(&mut world); + register_scaling_mode_functions(&mut world); + register_visibility_class_functions(&mut world); + register_no_frustum_culling_functions(&mut world); + register_visible_mesh_entities_functions(&mut world); + register_cubemap_visible_entities_functions(&mut world); + register_cascades_visible_entities_functions(&mut world); + register_render_layers_functions(&mut world); + register_visibility_range_functions(&mut world); + } +} diff --git a/crates/bindings/bevy_color_bms_bindings/Cargo.toml b/crates/bindings/bevy_color_bms_bindings/Cargo.toml index e7cd226302..27c1e36e3b 100644 --- a/crates/bindings/bevy_color_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_color_bms_bindings/Cargo.toml @@ -17,24 +17,15 @@ bevy_app = { workspace = true, features = ["std"] } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_color = { version = "0.16.2", features = [ - "std", - "bevy_reflect", - "encase", - "alloc", - "wgpu-types", -], default-features = true } +bevy_color = { version = "0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} -bevy_math = { version = "^0.16.1", features = [ - "std", - "alloc", -], default-features = false } +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} -bevy_reflect = { version = "^0.16.1", features = [ - "std", -], default-features = false } +bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} + +bytemuck = { version = "^1", features = [], default-features = true} + +wgpu-types = { version = "^26", features = ["std"], default-features = false} -bytemuck = { version = "^1", features = [], default-features = true } -wgpu-types = { version = "^24", features = ["std"], default-features = false } diff --git a/crates/bindings/bevy_color_bms_bindings/src/lib.rs b/crates/bindings/bevy_color_bms_bindings/src/lib.rs index 76859d9761..b6cc20cc82 100644 --- a/crates/bindings/bevy_color_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_color_bms_bindings/src/lib.rs @@ -2131,7 +2131,7 @@ pub(crate) fn register_oklcha_functions(world: &mut World) { }; output }, - " Construct a new [`Oklcha`] color from (l, c, h) components, with the default alpha (1.0).\n # Arguments\n * `lightness` - Lightness channel. [0.0, 1.0]\n * `chroma` - Chroma channel. [0.0, 1.0]\n * `hue` - Hue channel. [0.0, 360.0]\n * `alpha` - Alpha channel. [0.0, 1.0]", + " Construct a new [`Oklcha`] color from (l, c, h) components, with the default alpha (1.0).\n # Arguments\n * `lightness` - Lightness channel. [0.0, 1.0]\n * `chroma` - Chroma channel. [0.0, 1.0]\n * `hue` - Hue channel. [0.0, 360.0]", &["lightness", "chroma", "hue"], ) .register_documented( diff --git a/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml b/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml index 649b3d3833..eaded9f4c7 100644 --- a/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml @@ -17,56 +17,41 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_core_pipeline = { version = "0.16.1", features = [ - "smaa_luts", - "tonemapping_luts", - "webgl", -], default-features = true } +bevy_core_pipeline = { version = "0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} -bevy_app = { version = "^0.16.1", features = [], default-features = true } +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} -bevy_asset = { version = "^0.16.1", features = [], default-features = true } +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} -bevy_color = { version = "^0.16.2", features = [], default-features = true } +bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_derive = { version = "^0.16.1", features = [], default-features = true } +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} -bevy_diagnostic = { version = "^0.16.1", features = [ -], default-features = true } +bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.16.1", features = [], default-features = true } +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_image = { version = "^0.16.1", features = [ - "ktx2", - "zstd", - "ktx2", - "zstd", -], default-features = false } +bevy_image = { version = "^0.17.2", features = ["ktx2", "zstd", "hdr", "png", "zstd_rust", "bevy_reflect"], default-features = true} -bevy_math = { version = "^0.16.1", features = [], default-features = true } +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} -bevy_reflect = { version = "^0.16.1", features = [], default-features = true } +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_render = { version = "^0.16.1", features = [ - "ktx2", - "ktx2", -], default-features = false } +bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} -bevy_transform = { version = "^0.16.1", features = [], default-features = true } +bevy_shader = { version = "^0.17.2", features = [], default-features = true} -bevy_utils = { version = "^0.16.1", features = [], default-features = true } +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_window = { version = "^0.16.1", features = [], default-features = true } +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} -bitflags = { version = "^2.3", features = [], default-features = true } +bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} -bytemuck = { version = "^1", features = [], default-features = true } +bitflags = { version = "^2.3", features = [], default-features = true} -nonmax = { version = "^0.5", features = [], default-features = true } +nonmax = { version = "^0.5", features = [], default-features = true} -radsort = { version = "^0.1", features = [], default-features = true } +radsort = { version = "^0.1", features = [], default-features = true} -serde = { version = "^1", features = [], default-features = true } -smallvec = { version = "^1", features = [], default-features = true } diff --git a/crates/bindings/bevy_core_pipeline_bms_bindings/src/lib.rs b/crates/bindings/bevy_core_pipeline_bms_bindings/src/lib.rs index 97e750849e..7e0b870b04 100644 --- a/crates/bindings/bevy_core_pipeline_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_core_pipeline_bms_bindings/src/lib.rs @@ -39,649 +39,16 @@ pub(crate) fn register_skybox_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_camera_2_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::core_2d::Camera2d, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_core_pipeline::core_2d::Camera2d>| { - let output: Val<::bevy_core_pipeline::core_2d::Camera2d> = { - { - let output: Val<::bevy_core_pipeline::core_2d::Camera2d> = - <::bevy_core_pipeline::core_2d::Camera2d as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_core_pipeline::core_2d::Camera2d, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_camera_3_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::core_3d::Camera3d, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_core_pipeline::core_3d::Camera3d>| { - let output: Val<::bevy_core_pipeline::core_3d::Camera3d> = { - { - let output: Val<::bevy_core_pipeline::core_3d::Camera3d> = - <::bevy_core_pipeline::core_3d::Camera3d as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_core_pipeline::core_3d::Camera3d, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_deferred_prepass_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::prepass::DeferredPrepass, - >::new(world); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_core_pipeline::prepass::DeferredPrepass, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_depth_prepass_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::prepass::DepthPrepass, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_core_pipeline::prepass::DepthPrepass>| { - let output: Val<::bevy_core_pipeline::prepass::DepthPrepass> = { - { - let output: Val<::bevy_core_pipeline::prepass::DepthPrepass> = <::bevy_core_pipeline::prepass::DepthPrepass as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_core_pipeline::prepass::DepthPrepass, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_motion_vector_prepass_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::prepass::MotionVectorPrepass, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_core_pipeline::prepass::MotionVectorPrepass>| { - let output: Val<::bevy_core_pipeline::prepass::MotionVectorPrepass> = { - { - let output: Val< - ::bevy_core_pipeline::prepass::MotionVectorPrepass, - > = <::bevy_core_pipeline::prepass::MotionVectorPrepass as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_core_pipeline::prepass::MotionVectorPrepass, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_normal_prepass_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::prepass::NormalPrepass, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_core_pipeline::prepass::NormalPrepass>| { - let output: Val<::bevy_core_pipeline::prepass::NormalPrepass> = { - { - let output: Val<::bevy_core_pipeline::prepass::NormalPrepass> = <::bevy_core_pipeline::prepass::NormalPrepass as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_core_pipeline::prepass::NormalPrepass, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_auto_exposure_compensation_curve_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::auto_exposure::AutoExposureCompensationCurve, - >::new(world) - .register_documented( - "clone", - | - _self: Ref< - ::bevy_core_pipeline::auto_exposure::AutoExposureCompensationCurve, - >| - { - let output: Val< - ::bevy_core_pipeline::auto_exposure::AutoExposureCompensationCurve, - > = { - { - let output: Val< - ::bevy_core_pipeline::auto_exposure::AutoExposureCompensationCurve, - > = <::bevy_core_pipeline::auto_exposure::AutoExposureCompensationCurve as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_core_pipeline::auto_exposure::AutoExposureCompensationCurve, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_auto_exposure_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::auto_exposure::AutoExposure, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_core_pipeline::auto_exposure::AutoExposure>| { - let output: Val<::bevy_core_pipeline::auto_exposure::AutoExposure> = { - { - let output: Val< - ::bevy_core_pipeline::auto_exposure::AutoExposure, - > = <::bevy_core_pipeline::auto_exposure::AutoExposure as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_core_pipeline::auto_exposure::AutoExposure, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_tonemapping_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::tonemapping::Tonemapping, - >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_core_pipeline::tonemapping::Tonemapping>| { - let output: () = { - { - let output: () = <::bevy_core_pipeline::tonemapping::Tonemapping as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_core_pipeline::tonemapping::Tonemapping>| { - let output: Val<::bevy_core_pipeline::tonemapping::Tonemapping> = { - { - let output: Val< - ::bevy_core_pipeline::tonemapping::Tonemapping, - > = <::bevy_core_pipeline::tonemapping::Tonemapping as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_core_pipeline::tonemapping::Tonemapping>, - other: Ref<::bevy_core_pipeline::tonemapping::Tonemapping>| - { - let output: bool = { - { - let output: bool = <::bevy_core_pipeline::tonemapping::Tonemapping as ::std::cmp::PartialEq< - ::bevy_core_pipeline::tonemapping::Tonemapping, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "is_enabled", - |_self: Ref<::bevy_core_pipeline::tonemapping::Tonemapping>| { - let output: bool = { - { - let output: bool = ::bevy_core_pipeline::tonemapping::Tonemapping::is_enabled( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_core_pipeline::tonemapping::Tonemapping, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_bloom_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::bloom::Bloom, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_core_pipeline::bloom::Bloom>| { - let output: Val<::bevy_core_pipeline::bloom::Bloom> = { - { - let output: Val<::bevy_core_pipeline::bloom::Bloom> = - <::bevy_core_pipeline::bloom::Bloom as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_core_pipeline::bloom::Bloom, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_bloom_composite_mode_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::bloom::BloomCompositeMode, - >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_core_pipeline::bloom::BloomCompositeMode>| { - let output: () = { - { - let output: () = <::bevy_core_pipeline::bloom::BloomCompositeMode as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_core_pipeline::bloom::BloomCompositeMode>| { - let output: Val<::bevy_core_pipeline::bloom::BloomCompositeMode> = { - { - let output: Val< - ::bevy_core_pipeline::bloom::BloomCompositeMode, - > = <::bevy_core_pipeline::bloom::BloomCompositeMode as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_core_pipeline::bloom::BloomCompositeMode>, - other: Ref<::bevy_core_pipeline::bloom::BloomCompositeMode>| - { - let output: bool = { - { - let output: bool = <::bevy_core_pipeline::bloom::BloomCompositeMode as ::std::cmp::PartialEq< - ::bevy_core_pipeline::bloom::BloomCompositeMode, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_core_pipeline::bloom::BloomCompositeMode, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_bloom_prefilter_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::bloom::BloomPrefilter, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_core_pipeline::bloom::BloomPrefilter>| { - let output: Val<::bevy_core_pipeline::bloom::BloomPrefilter> = { - { - let output: Val<::bevy_core_pipeline::bloom::BloomPrefilter> = <::bevy_core_pipeline::bloom::BloomPrefilter as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_core_pipeline::bloom::BloomPrefilter, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_contrast_adaptive_sharpening_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::contrast_adaptive_sharpening::ContrastAdaptiveSharpening, - >::new(world) - .register_documented( - "clone", - | - _self: Ref< - ::bevy_core_pipeline::contrast_adaptive_sharpening::ContrastAdaptiveSharpening, - >| - { - let output: Val< - ::bevy_core_pipeline::contrast_adaptive_sharpening::ContrastAdaptiveSharpening, - > = { - { - let output: Val< - ::bevy_core_pipeline::contrast_adaptive_sharpening::ContrastAdaptiveSharpening, - > = <::bevy_core_pipeline::contrast_adaptive_sharpening::ContrastAdaptiveSharpening as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_core_pipeline::contrast_adaptive_sharpening::ContrastAdaptiveSharpening, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_denoise_cas_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::contrast_adaptive_sharpening::DenoiseCas, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_core_pipeline::contrast_adaptive_sharpening::DenoiseCas>| { - let output: Val< - ::bevy_core_pipeline::contrast_adaptive_sharpening::DenoiseCas, - > = { - { - let output: Val< - ::bevy_core_pipeline::contrast_adaptive_sharpening::DenoiseCas, - > = <::bevy_core_pipeline::contrast_adaptive_sharpening::DenoiseCas as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_core_pipeline::contrast_adaptive_sharpening::DenoiseCas, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_fxaa_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::fxaa::Fxaa, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_core_pipeline::fxaa::Fxaa>| { - let output: Val<::bevy_core_pipeline::fxaa::Fxaa> = { - { - let output: Val<::bevy_core_pipeline::fxaa::Fxaa> = - <::bevy_core_pipeline::fxaa::Fxaa as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_core_pipeline::fxaa::Fxaa, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_smaa_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::smaa::Smaa, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_core_pipeline::smaa::Smaa>| { - let output: Val<::bevy_core_pipeline::smaa::Smaa> = { - { - let output: Val<::bevy_core_pipeline::smaa::Smaa> = - <::bevy_core_pipeline::smaa::Smaa as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_core_pipeline::smaa::Smaa, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_deband_dither_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::tonemapping::DebandDither, - >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_core_pipeline::tonemapping::DebandDither>| { - let output: () = { - { - let output: () = <::bevy_core_pipeline::tonemapping::DebandDither as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_core_pipeline::tonemapping::DebandDither>| { - let output: Val<::bevy_core_pipeline::tonemapping::DebandDither> = { - { - let output: Val< - ::bevy_core_pipeline::tonemapping::DebandDither, - > = <::bevy_core_pipeline::tonemapping::DebandDither as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_core_pipeline::tonemapping::DebandDither>, - other: Ref<::bevy_core_pipeline::tonemapping::DebandDither>| - { - let output: bool = { - { - let output: bool = <::bevy_core_pipeline::tonemapping::DebandDither as ::std::cmp::PartialEq< - ::bevy_core_pipeline::tonemapping::DebandDither, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_core_pipeline::tonemapping::DebandDither, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_motion_blur_functions(world: &mut World) { +pub(crate) fn register_tonemapping_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::motion_blur::MotionBlur, + ::bevy_core_pipeline::tonemapping::Tonemapping, >::new(world) .register_documented( - "clone", - |_self: Ref<::bevy_core_pipeline::motion_blur::MotionBlur>| { - let output: Val<::bevy_core_pipeline::motion_blur::MotionBlur> = { + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_core_pipeline::tonemapping::Tonemapping>| { + let output: () = { { - let output: Val<::bevy_core_pipeline::motion_blur::MotionBlur> = <::bevy_core_pipeline::motion_blur::MotionBlur as ::std::clone::Clone>::clone( + let output: () = <::bevy_core_pipeline::tonemapping::Tonemapping as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -692,59 +59,15 @@ pub(crate) fn register_motion_blur_functions(world: &mut World) { }, "", &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_core_pipeline::motion_blur::MotionBlur, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_depth_of_field_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::dof::DepthOfField, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_core_pipeline::dof::DepthOfField>| { - let output: Val<::bevy_core_pipeline::dof::DepthOfField> = { - { - let output: Val<::bevy_core_pipeline::dof::DepthOfField> = - <::bevy_core_pipeline::dof::DepthOfField as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_core_pipeline::dof::DepthOfField, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_screen_space_transmission_quality_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::core_3d::ScreenSpaceTransmissionQuality, - >::new(world) + ) .register_documented( "clone", - |_self: Ref<::bevy_core_pipeline::core_3d::ScreenSpaceTransmissionQuality>| { - let output: Val< - ::bevy_core_pipeline::core_3d::ScreenSpaceTransmissionQuality, - > = { + |_self: Ref<::bevy_core_pipeline::tonemapping::Tonemapping>| { + let output: Val<::bevy_core_pipeline::tonemapping::Tonemapping> = { { let output: Val< - ::bevy_core_pipeline::core_3d::ScreenSpaceTransmissionQuality, - > = <::bevy_core_pipeline::core_3d::ScreenSpaceTransmissionQuality as ::std::clone::Clone>::clone( + ::bevy_core_pipeline::tonemapping::Tonemapping, + > = <::bevy_core_pipeline::tonemapping::Tonemapping as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -759,17 +82,13 @@ pub(crate) fn register_screen_space_transmission_quality_functions(world: &mut W .register_documented( "eq", | - _self: Ref< - ::bevy_core_pipeline::core_3d::ScreenSpaceTransmissionQuality, - >, - other: Ref< - ::bevy_core_pipeline::core_3d::ScreenSpaceTransmissionQuality, - >| + _self: Ref<::bevy_core_pipeline::tonemapping::Tonemapping>, + other: Ref<::bevy_core_pipeline::tonemapping::Tonemapping>| { let output: bool = { { - let output: bool = <::bevy_core_pipeline::core_3d::ScreenSpaceTransmissionQuality as ::std::cmp::PartialEq< - ::bevy_core_pipeline::core_3d::ScreenSpaceTransmissionQuality, + let output: bool = <::bevy_core_pipeline::tonemapping::Tonemapping as ::std::cmp::PartialEq< + ::bevy_core_pipeline::tonemapping::Tonemapping, >>::eq(&_self, &other) .into(); output @@ -779,27 +98,13 @@ pub(crate) fn register_screen_space_transmission_quality_functions(world: &mut W }, "", &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_core_pipeline::core_3d::ScreenSpaceTransmissionQuality, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_camera_3_d_depth_load_op_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::core_3d::Camera3dDepthLoadOp, - >::new(world) + ) .register_documented( - "clone", - |_self: Ref<::bevy_core_pipeline::core_3d::Camera3dDepthLoadOp>| { - let output: Val<::bevy_core_pipeline::core_3d::Camera3dDepthLoadOp> = { + "is_enabled", + |_self: Ref<::bevy_core_pipeline::tonemapping::Tonemapping>| { + let output: bool = { { - let output: Val< - ::bevy_core_pipeline::core_3d::Camera3dDepthLoadOp, - > = <::bevy_core_pipeline::core_3d::Camera3dDepthLoadOp as ::std::clone::Clone>::clone( + let output: bool = ::bevy_core_pipeline::tonemapping::Tonemapping::is_enabled( &_self, ) .into(); @@ -815,24 +120,20 @@ pub(crate) fn register_camera_3_d_depth_load_op_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_core_pipeline::core_3d::Camera3dDepthLoadOp, + ::bevy_core_pipeline::tonemapping::Tonemapping, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_camera_3_d_depth_texture_usage_functions(world: &mut World) { +pub(crate) fn register_deband_dither_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::core_3d::Camera3dDepthTextureUsage, + ::bevy_core_pipeline::tonemapping::DebandDither, >::new(world) .register_documented( - "clone", - |_self: Ref<::bevy_core_pipeline::core_3d::Camera3dDepthTextureUsage>| { - let output: Val< - ::bevy_core_pipeline::core_3d::Camera3dDepthTextureUsage, - > = { + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_core_pipeline::tonemapping::DebandDither>| { + let output: () = { { - let output: Val< - ::bevy_core_pipeline::core_3d::Camera3dDepthTextureUsage, - > = <::bevy_core_pipeline::core_3d::Camera3dDepthTextureUsage as ::std::clone::Clone>::clone( + let output: () = <::bevy_core_pipeline::tonemapping::DebandDither as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -843,25 +144,15 @@ pub(crate) fn register_camera_3_d_depth_texture_usage_functions(world: &mut Worl }, "", &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_core_pipeline::core_3d::Camera3dDepthTextureUsage, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_depth_of_field_mode_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::dof::DepthOfFieldMode, - >::new(world) + ) .register_documented( "clone", - |_self: Ref<::bevy_core_pipeline::dof::DepthOfFieldMode>| { - let output: Val<::bevy_core_pipeline::dof::DepthOfFieldMode> = { + |_self: Ref<::bevy_core_pipeline::tonemapping::DebandDither>| { + let output: Val<::bevy_core_pipeline::tonemapping::DebandDither> = { { - let output: Val<::bevy_core_pipeline::dof::DepthOfFieldMode> = <::bevy_core_pipeline::dof::DepthOfFieldMode as ::std::clone::Clone>::clone( + let output: Val< + ::bevy_core_pipeline::tonemapping::DebandDither, + > = <::bevy_core_pipeline::tonemapping::DebandDither as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -876,13 +167,13 @@ pub(crate) fn register_depth_of_field_mode_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_core_pipeline::dof::DepthOfFieldMode>, - other: Ref<::bevy_core_pipeline::dof::DepthOfFieldMode>| + _self: Ref<::bevy_core_pipeline::tonemapping::DebandDither>, + other: Ref<::bevy_core_pipeline::tonemapping::DebandDither>| { let output: bool = { { - let output: bool = <::bevy_core_pipeline::dof::DepthOfFieldMode as ::std::cmp::PartialEq< - ::bevy_core_pipeline::dof::DepthOfFieldMode, + let output: bool = <::bevy_core_pipeline::tonemapping::DebandDither as ::std::cmp::PartialEq< + ::bevy_core_pipeline::tonemapping::DebandDither, >>::eq(&_self, &other) .into(); output @@ -897,70 +188,32 @@ pub(crate) fn register_depth_of_field_mode_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_core_pipeline::dof::DepthOfFieldMode, + ::bevy_core_pipeline::tonemapping::DebandDither, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_temporal_anti_aliasing_functions(world: &mut World) { +pub(crate) fn register_deferred_prepass_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::experimental::taa::TemporalAntiAliasing, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_core_pipeline::experimental::taa::TemporalAntiAliasing>| { - let output: Val< - ::bevy_core_pipeline::experimental::taa::TemporalAntiAliasing, - > = { - { - let output: Val< - ::bevy_core_pipeline::experimental::taa::TemporalAntiAliasing, - > = <::bevy_core_pipeline::experimental::taa::TemporalAntiAliasing as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + ::bevy_core_pipeline::prepass::DeferredPrepass, + >::new(world); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_core_pipeline::experimental::taa::TemporalAntiAliasing, + ::bevy_core_pipeline::prepass::DeferredPrepass, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_sensitivity_functions(world: &mut World) { +pub(crate) fn register_depth_prepass_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::fxaa::Sensitivity, + ::bevy_core_pipeline::prepass::DepthPrepass, >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_core_pipeline::fxaa::Sensitivity>| { - let output: () = { - { - let output: () = <::bevy_core_pipeline::fxaa::Sensitivity as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) .register_documented( "clone", - |_self: Ref<::bevy_core_pipeline::fxaa::Sensitivity>| { - let output: Val<::bevy_core_pipeline::fxaa::Sensitivity> = { + |_self: Ref<::bevy_core_pipeline::prepass::DepthPrepass>| { + let output: Val<::bevy_core_pipeline::prepass::DepthPrepass> = { { - let output: Val<::bevy_core_pipeline::fxaa::Sensitivity> = <::bevy_core_pipeline::fxaa::Sensitivity as ::std::clone::Clone>::clone( + let output: Val<::bevy_core_pipeline::prepass::DepthPrepass> = <::bevy_core_pipeline::prepass::DepthPrepass as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -971,53 +224,27 @@ pub(crate) fn register_sensitivity_functions(world: &mut World) { }, "", &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_core_pipeline::fxaa::Sensitivity>, - other: Ref<::bevy_core_pipeline::fxaa::Sensitivity>| - { - let output: bool = { - { - let output: bool = <::bevy_core_pipeline::fxaa::Sensitivity as ::std::cmp::PartialEq< - ::bevy_core_pipeline::fxaa::Sensitivity, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_core_pipeline::fxaa::Sensitivity, + ::bevy_core_pipeline::prepass::DepthPrepass, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_order_independent_transparency_settings_functions(world: &mut World) { +pub(crate) fn register_motion_vector_prepass_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::oit::OrderIndependentTransparencySettings, + ::bevy_core_pipeline::prepass::MotionVectorPrepass, >::new(world) .register_documented( "clone", - | - _self: Ref< - ::bevy_core_pipeline::oit::OrderIndependentTransparencySettings, - >| - { - let output: Val< - ::bevy_core_pipeline::oit::OrderIndependentTransparencySettings, - > = { + |_self: Ref<::bevy_core_pipeline::prepass::MotionVectorPrepass>| { + let output: Val<::bevy_core_pipeline::prepass::MotionVectorPrepass> = { { let output: Val< - ::bevy_core_pipeline::oit::OrderIndependentTransparencySettings, - > = <::bevy_core_pipeline::oit::OrderIndependentTransparencySettings as ::std::clone::Clone>::clone( + ::bevy_core_pipeline::prepass::MotionVectorPrepass, + > = <::bevy_core_pipeline::prepass::MotionVectorPrepass as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1033,24 +260,20 @@ pub(crate) fn register_order_independent_transparency_settings_functions(world: let mut registry = registry.write(); registry .register_type_data::< - ::bevy_core_pipeline::oit::OrderIndependentTransparencySettings, + ::bevy_core_pipeline::prepass::MotionVectorPrepass, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_chromatic_aberration_functions(world: &mut World) { +pub(crate) fn register_normal_prepass_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::post_process::ChromaticAberration, + ::bevy_core_pipeline::prepass::NormalPrepass, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_core_pipeline::post_process::ChromaticAberration>| { - let output: Val< - ::bevy_core_pipeline::post_process::ChromaticAberration, - > = { + |_self: Ref<::bevy_core_pipeline::prepass::NormalPrepass>| { + let output: Val<::bevy_core_pipeline::prepass::NormalPrepass> = { { - let output: Val< - ::bevy_core_pipeline::post_process::ChromaticAberration, - > = <::bevy_core_pipeline::post_process::ChromaticAberration as ::std::clone::Clone>::clone( + let output: Val<::bevy_core_pipeline::prepass::NormalPrepass> = <::bevy_core_pipeline::prepass::NormalPrepass as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1066,37 +289,28 @@ pub(crate) fn register_chromatic_aberration_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_core_pipeline::post_process::ChromaticAberration, + ::bevy_core_pipeline::prepass::NormalPrepass, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_smaa_preset_functions(world: &mut World) { +pub(crate) fn register_order_independent_transparency_settings_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_core_pipeline::smaa::SmaaPreset, + ::bevy_core_pipeline::oit::OrderIndependentTransparencySettings, >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_core_pipeline::smaa::SmaaPreset>| { - let output: () = { - { - let output: () = <::bevy_core_pipeline::smaa::SmaaPreset as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) .register_documented( "clone", - |_self: Ref<::bevy_core_pipeline::smaa::SmaaPreset>| { - let output: Val<::bevy_core_pipeline::smaa::SmaaPreset> = { + | + _self: Ref< + ::bevy_core_pipeline::oit::OrderIndependentTransparencySettings, + >| + { + let output: Val< + ::bevy_core_pipeline::oit::OrderIndependentTransparencySettings, + > = { { - let output: Val<::bevy_core_pipeline::smaa::SmaaPreset> = <::bevy_core_pipeline::smaa::SmaaPreset as ::std::clone::Clone>::clone( + let output: Val< + ::bevy_core_pipeline::oit::OrderIndependentTransparencySettings, + > = <::bevy_core_pipeline::oit::OrderIndependentTransparencySettings as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1107,32 +321,12 @@ pub(crate) fn register_smaa_preset_functions(world: &mut World) { }, "", &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_core_pipeline::smaa::SmaaPreset>, - other: Ref<::bevy_core_pipeline::smaa::SmaaPreset>| - { - let output: bool = { - { - let output: bool = <::bevy_core_pipeline::smaa::SmaaPreset as ::std::cmp::PartialEq< - ::bevy_core_pipeline::smaa::SmaaPreset, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_core_pipeline::smaa::SmaaPreset, + ::bevy_core_pipeline::oit::OrderIndependentTransparencySettings, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -1140,33 +334,12 @@ impl Plugin for BevyCorePipelineScriptingPlugin { fn build(&self, app: &mut App) { let mut world = app.world_mut(); register_skybox_functions(&mut world); - register_camera_2_d_functions(&mut world); - register_camera_3_d_functions(&mut world); + register_tonemapping_functions(&mut world); + register_deband_dither_functions(&mut world); register_deferred_prepass_functions(&mut world); register_depth_prepass_functions(&mut world); register_motion_vector_prepass_functions(&mut world); register_normal_prepass_functions(&mut world); - register_auto_exposure_compensation_curve_functions(&mut world); - register_auto_exposure_functions(&mut world); - register_tonemapping_functions(&mut world); - register_bloom_functions(&mut world); - register_bloom_composite_mode_functions(&mut world); - register_bloom_prefilter_functions(&mut world); - register_contrast_adaptive_sharpening_functions(&mut world); - register_denoise_cas_functions(&mut world); - register_fxaa_functions(&mut world); - register_smaa_functions(&mut world); - register_deband_dither_functions(&mut world); - register_motion_blur_functions(&mut world); - register_depth_of_field_functions(&mut world); - register_screen_space_transmission_quality_functions(&mut world); - register_camera_3_d_depth_load_op_functions(&mut world); - register_camera_3_d_depth_texture_usage_functions(&mut world); - register_depth_of_field_mode_functions(&mut world); - register_temporal_anti_aliasing_functions(&mut world); - register_sensitivity_functions(&mut world); register_order_independent_transparency_settings_functions(&mut world); - register_chromatic_aberration_functions(&mut world); - register_smaa_preset_functions(&mut world); } } diff --git a/crates/bindings/bevy_ecs_bms_bindings/Cargo.toml b/crates/bindings/bevy_ecs_bms_bindings/Cargo.toml index 046212fc25..caaf910f49 100644 --- a/crates/bindings/bevy_ecs_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_ecs_bms_bindings/Cargo.toml @@ -17,67 +17,37 @@ bevy_app = { workspace = true, features = ["std"] } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_ecs = { version = "0.16.1", features = [ - "std", - "bevy_reflect", - "async_executor", - "backtrace", - "multi_threaded", - "serialize", -], default-features = true } +bevy_ecs = { version = "0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -arrayvec = { version = "^0.7.4", features = ["std"], default-features = false } +arrayvec = { version = "^0.7.4", features = ["std"], default-features = false} -bevy_ecs_macros = { version = "^0.16.1", features = [ -], default-features = true } +bevy_ecs_macros = { version = "^0.17.2", features = [], default-features = true} -bevy_platform = { version = "^0.16.1", features = [ - "std", - "serialize", -], default-features = false } +bevy_platform = { version = "^0.17.2", features = ["std", "serialize", "alloc"], default-features = true} -bevy_ptr = { version = "^0.16.1", features = [], default-features = true } +bevy_ptr = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.16.1", features = [ - "std", -], default-features = false } +bevy_reflect = { version = "^0.17.2", features = ["std", "auto_register", "glam", "uuid", "smol_str", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_tasks = { version = "^0.16.1", features = [ - "std", - "async_executor", - "multi_threaded", -], default-features = false } +bevy_tasks = { version = "^0.17.2", features = ["async_executor", "multi_threaded", "futures-lite"], default-features = true} -bevy_utils = { version = "^0.16.1", features = [ - "std", - "serde", -], default-features = false } +bevy_utils = { version = "^0.17.2", features = ["parallel", "std", "debug"], default-features = true} -bitflags = { version = "^2.3", features = ["std"], default-features = false } +bitflags = { version = "^2.3", features = ["std"], default-features = false} -bumpalo = { version = "^3", features = [], default-features = true } +bumpalo = { version = "^3", features = [], default-features = true} -concurrent-queue = { version = "^2.5.0", features = [ - "std", - "std", -], default-features = false } +concurrent-queue = { version = "^2.5.0", features = ["std", "std"], default-features = false} -disqualified = { version = "^1.0", features = [ - "alloc", -], default-features = false } +fixedbitset = { version = "^0.5", features = ["std"], default-features = false} -fixedbitset = { version = "^0.5", features = ["std"], default-features = false } +indexmap = { version = "^2.5.0", features = ["std", "serde"], default-features = false} -indexmap = { version = "^2.5.0", features = [ - "std", - "serde", -], default-features = false } +log = { version = "^0.4", features = ["std"], default-features = false} -log = { version = "^0.4", features = ["std"], default-features = false } +nonmax = { version = "^0.5", features = ["std"], default-features = false} -nonmax = { version = "^0.5", features = ["std"], default-features = false } +serde = { version = "^1", features = ["std"], default-features = false} -serde = { version = "^1", features = ["std"], default-features = false } -smallvec = { version = "^1", features = [], default-features = true } diff --git a/crates/bindings/bevy_ecs_bms_bindings/src/lib.rs b/crates/bindings/bevy_ecs_bms_bindings/src/lib.rs index bd0502c5b5..631ec06ac8 100644 --- a/crates/bindings/bevy_ecs_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_ecs_bms_bindings/src/lib.rs @@ -71,12 +71,12 @@ pub(crate) fn register_entity_functions(world: &mut World) { &["bits"], ) .register_documented( - "from_raw", - |index: u32| { + "from_row", + |row: Val<::bevy_ecs::entity::EntityRow>| { let output: Val<::bevy_ecs::entity::Entity> = { { - let output: Val<::bevy_ecs::entity::Entity> = ::bevy_ecs::entity::Entity::from_raw( - index, + let output: Val<::bevy_ecs::entity::Entity> = ::bevy_ecs::entity::Entity::from_row( + row.into_inner(), ) .into(); output @@ -84,15 +84,36 @@ pub(crate) fn register_entity_functions(world: &mut World) { }; output }, - " Creates a new entity ID with the specified `index` and a generation of 1.\n # Note\n Spawning a specific `entity` value is __rarely the right choice__. Most apps should favor\n [`Commands::spawn`](crate::system::Commands::spawn). This method should generally\n only be used for sharing entities across apps, and only when they have a scheme\n worked out to share an index space (which doesn't happen by default).\n In general, one should not try to synchronize the ECS by attempting to ensure that\n `Entity` lines up between instances, but instead insert a secondary identifier as\n a component.", - &["index"], + " Creates a new entity ID with the specified `row` and a generation of 1.\n # Note\n Spawning a specific `entity` value is __rarely the right choice__. Most apps should favor\n [`Commands::spawn`](crate::system::Commands::spawn). This method should generally\n only be used for sharing entities across apps, and only when they have a scheme\n worked out to share an index space (which doesn't happen by default).\n In general, one should not try to synchronize the ECS by attempting to ensure that\n `Entity` lines up between instances, but instead insert a secondary identifier as\n a component.", + &["row"], + ) + .register_documented( + "from_row_and_generation", + | + row: Val<::bevy_ecs::entity::EntityRow>, + generation: Val<::bevy_ecs::entity::EntityGeneration>| + { + let output: Val<::bevy_ecs::entity::Entity> = { + { + let output: Val<::bevy_ecs::entity::Entity> = ::bevy_ecs::entity::Entity::from_row_and_generation( + row.into_inner(), + generation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a new instance with the given index and generation.", + &["row", "generation"], ) .register_documented( "generation", |_self: Val<::bevy_ecs::entity::Entity>| { - let output: u32 = { + let output: Val<::bevy_ecs::entity::EntityGeneration> = { { - let output: u32 = ::bevy_ecs::entity::Entity::generation( + let output: Val<::bevy_ecs::entity::EntityGeneration> = ::bevy_ecs::entity::Entity::generation( _self.into_inner(), ) .into(); @@ -101,7 +122,7 @@ pub(crate) fn register_entity_functions(world: &mut World) { }; output }, - " Returns the generation of this Entity's index. The generation is incremented each time an\n entity with a given index is despawned. This serves as a \"count\" of the number of times a\n given index has been reused (index, generation) pairs uniquely identify a given Entity.", + " Returns the generation of this Entity's row. The generation is incremented each time an\n entity with a given row is despawned. This serves as a \"count\" of the number of times a\n given row has been reused (row, generation) pairs uniquely identify a given Entity.", &["_self"], ) .register_documented( @@ -118,7 +139,24 @@ pub(crate) fn register_entity_functions(world: &mut World) { }; output }, - " Return a transiently unique identifier.\n No two simultaneously-live entities share the same index, but dead entities' indices may collide\n with both live and dead entities. Useful for compactly representing entities within a\n specific snapshot of the world, such as when serializing.", + " Equivalent to `self.row().index()`. See [`Self::row`] for details.", + &["_self"], + ) + .register_documented( + "row", + |_self: Val<::bevy_ecs::entity::Entity>| { + let output: Val<::bevy_ecs::entity::EntityRow> = { + { + let output: Val<::bevy_ecs::entity::EntityRow> = ::bevy_ecs::entity::Entity::row( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Return a transiently unique identifier.\n See also [`EntityRow`].\n No two simultaneously-live entities share the same row, but dead entities' indices may collide\n with both live and dead entities. Useful for compactly representing entities within a\n specific snapshot of the world, such as when serializing.", &["_self"], ) .register_documented( @@ -204,23 +242,6 @@ pub(crate) fn register_child_of_functions(world: &mut World) { "", &["_self", "other"], ) - .register_documented( - "get", - |_self: Ref<::bevy_ecs::hierarchy::ChildOf>| { - let output: Val<::bevy_ecs::entity::Entity> = { - { - let output: Val<::bevy_ecs::entity::Entity> = ::bevy_ecs::hierarchy::ChildOf::get( - &_self, - ) - .into(); - output - } - }; - output - }, - " The parent entity of this child entity.", - &["_self"], - ) .register_documented( "parent", |_self: Ref<::bevy_ecs::hierarchy::ChildOf>| { @@ -318,16 +339,16 @@ pub(crate) fn register_children_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_name_functions(world: &mut World) { +pub(crate) fn register_add_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ecs::name::Name, + ::bevy_ecs::lifecycle::Add, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_ecs::name::Name>| { - let output: Val<::bevy_ecs::name::Name> = { + |_self: Ref<::bevy_ecs::lifecycle::Add>| { + let output: Val<::bevy_ecs::lifecycle::Add> = { { - let output: Val<::bevy_ecs::name::Name> = <::bevy_ecs::name::Name as ::core::clone::Clone>::clone( + let output: Val<::bevy_ecs::lifecycle::Add> = <::bevy_ecs::lifecycle::Add as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -338,75 +359,218 @@ pub(crate) fn register_name_functions(world: &mut World) { }, "", &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ecs::name::Name>, other: Ref<::bevy_ecs::name::Name>| { - let output: bool = { - { - let output: bool = <::bevy_ecs::name::Name as ::core::cmp::PartialEq< - ::bevy_ecs::name::Name, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::bevy_ecs::name::Name, bevy_mod_scripting_bindings::MarkAsGenerated>( - ); + .register_type_data::< + ::bevy_ecs::lifecycle::Add, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } -pub(crate) fn register_on_add_functions(world: &mut World) { +pub(crate) fn register_despawn_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ecs::world::OnAdd, - >::new(world); + ::bevy_ecs::lifecycle::Despawn, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ecs::lifecycle::Despawn>| { + let output: Val<::bevy_ecs::lifecycle::Despawn> = { + { + let output: Val<::bevy_ecs::lifecycle::Despawn> = + <::bevy_ecs::lifecycle::Despawn as ::core::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ecs::world::OnAdd, + ::bevy_ecs::lifecycle::Despawn, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_on_insert_functions(world: &mut World) { +pub(crate) fn register_insert_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ecs::world::OnInsert, - >::new(world); + ::bevy_ecs::lifecycle::Insert, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ecs::lifecycle::Insert>| { + let output: Val<::bevy_ecs::lifecycle::Insert> = { + { + let output: Val<::bevy_ecs::lifecycle::Insert> = + <::bevy_ecs::lifecycle::Insert as ::core::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ecs::world::OnInsert, + ::bevy_ecs::lifecycle::Insert, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_on_remove_functions(world: &mut World) { +pub(crate) fn register_remove_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ecs::world::OnRemove, - >::new(world); + ::bevy_ecs::lifecycle::Remove, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ecs::lifecycle::Remove>| { + let output: Val<::bevy_ecs::lifecycle::Remove> = { + { + let output: Val<::bevy_ecs::lifecycle::Remove> = + <::bevy_ecs::lifecycle::Remove as ::core::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ecs::world::OnRemove, + ::bevy_ecs::lifecycle::Remove, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_on_replace_functions(world: &mut World) { +pub(crate) fn register_replace_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ecs::world::OnReplace, - >::new(world); + ::bevy_ecs::lifecycle::Replace, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ecs::lifecycle::Replace>| { + let output: Val<::bevy_ecs::lifecycle::Replace> = { + { + let output: Val<::bevy_ecs::lifecycle::Replace> = + <::bevy_ecs::lifecycle::Replace as ::core::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ecs::world::OnReplace, + ::bevy_ecs::lifecycle::Replace, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_name_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ecs::name::Name, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ecs::name::Name>| { + let output: Val<::bevy_ecs::name::Name> = { + { + let output: Val<::bevy_ecs::name::Name> = <::bevy_ecs::name::Name as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ecs::name::Name>, other: Ref<::bevy_ecs::name::Name>| { + let output: bool = { + { + let output: bool = <::bevy_ecs::name::Name as ::core::cmp::PartialEq< + ::bevy_ecs::name::Name, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::<::bevy_ecs::name::Name, bevy_mod_scripting_bindings::MarkAsGenerated>( + ); +} +pub(crate) fn register_default_query_filters_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ecs::entity_disabling::DefaultQueryFilters, + >::new(world) + .register_documented( + "empty", + || { + let output: Val<::bevy_ecs::entity_disabling::DefaultQueryFilters> = { + { + let output: Val< + ::bevy_ecs::entity_disabling::DefaultQueryFilters, + > = ::bevy_ecs::entity_disabling::DefaultQueryFilters::empty() + .into(); + output + } + }; + output + }, + " Creates a new, completely empty [`DefaultQueryFilters`].\n This is provided as an escape hatch; in most cases you should initialize this using [`FromWorld`],\n which is automatically called when creating a new [`World`].", + &[], + ) + .register_documented( + "register_disabling_component", + | + mut _self: Mut<::bevy_ecs::entity_disabling::DefaultQueryFilters>, + component_id: Val<::bevy_ecs::component::ComponentId>| + { + let output: () = { + { + let output: () = ::bevy_ecs::entity_disabling::DefaultQueryFilters::register_disabling_component( + &mut _self, + component_id.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Adds this [`ComponentId`] to the set of [`DefaultQueryFilters`],\n causing entities with this component to be excluded from queries.\n This method is idempotent, and will not add the same component multiple times.\n # Warning\n This method should only be called before the app starts, as it will not affect queries\n initialized before it is called.\n As discussed in the [module docs](crate::entity_disabling), this can have performance implications,\n as well as create interoperability issues, and should be used with caution.", + &["_self", "component_id"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ecs::entity_disabling::DefaultQueryFilters, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -510,56 +674,6 @@ pub(crate) fn register_component_id_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_default_query_filters_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ecs::entity_disabling::DefaultQueryFilters, - >::new(world) - .register_documented( - "empty", - || { - let output: Val<::bevy_ecs::entity_disabling::DefaultQueryFilters> = { - { - let output: Val< - ::bevy_ecs::entity_disabling::DefaultQueryFilters, - > = ::bevy_ecs::entity_disabling::DefaultQueryFilters::empty() - .into(); - output - } - }; - output - }, - " Creates a new, completely empty [`DefaultQueryFilters`].\n This is provided as an escape hatch; in most cases you should initialize this using [`FromWorld`],\n which is automatically called when creating a new [`World`].", - &[], - ) - .register_documented( - "register_disabling_component", - | - mut _self: Mut<::bevy_ecs::entity_disabling::DefaultQueryFilters>, - component_id: Val<::bevy_ecs::component::ComponentId>| - { - let output: () = { - { - let output: () = ::bevy_ecs::entity_disabling::DefaultQueryFilters::register_disabling_component( - &mut _self, - component_id.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Adds this [`ComponentId`] to the set of [`DefaultQueryFilters`],\n causing entities with this component to be excluded from queries.\n This method is idempotent, and will not add the same component multiple times.\n # Warning\n This method should only be called before the app starts, as it will not affect queries\n initialized before it is called.\n As discussed in the [module docs](crate::entity_disabling), this can have performance implications,\n as well as create interoperability issues, and should be used with caution.", - &["_self", "component_id"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_ecs::entity_disabling::DefaultQueryFilters, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} pub(crate) fn register_tick_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_ecs::component::Tick, @@ -803,7 +917,7 @@ pub(crate) fn register_component_ticks_functions(world: &mut World) { }; output }, - " Manually sets the change tick.\n This is normally done automatically via the [`DerefMut`] implementation\n on [`Mut`](crate::change_detection::Mut), [`ResMut`](crate::change_detection::ResMut), etc.\n However, components and resources that make use of interior mutability might require manual updates.\n # Example\n ```no_run\n # use bevy_ecs::{world::World, component::ComponentTicks};\n let world: World = unimplemented!();\n let component_ticks: ComponentTicks = unimplemented!();\n component_ticks.set_changed(world.read_change_tick());\n ```", + " Manually sets the change tick.\n This is normally done automatically via the [`DerefMut`](core::ops::DerefMut) implementation\n on [`Mut`](crate::change_detection::Mut), [`ResMut`](crate::change_detection::ResMut), etc.\n However, components and resources that make use of interior mutability might require manual updates.\n # Example\n ```no_run\n # use bevy_ecs::{world::World, component::ComponentTicks};\n let world: World = unimplemented!();\n let component_ticks: ComponentTicks = unimplemented!();\n component_ticks.set_changed(world.read_change_tick());\n ```", &["_self", "change_tick"], ); let registry = world.get_resource_or_init::(); @@ -946,16 +1060,33 @@ pub(crate) fn register_entity_hash_set_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_identifier_functions(world: &mut World) { +pub(crate) fn register_entity_row_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ecs::identifier::Identifier, + ::bevy_ecs::entity::EntityRow, >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ecs::entity::EntityRow>| { + let output: () = { + { + let output: () = <::bevy_ecs::entity::EntityRow as ::core::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) .register_documented( "clone", - |_self: Ref<::bevy_ecs::identifier::Identifier>| { - let output: Val<::bevy_ecs::identifier::Identifier> = { + |_self: Ref<::bevy_ecs::entity::EntityRow>| { + let output: Val<::bevy_ecs::entity::EntityRow> = { { - let output: Val<::bevy_ecs::identifier::Identifier> = <::bevy_ecs::identifier::Identifier as ::core::clone::Clone>::clone( + let output: Val<::bevy_ecs::entity::EntityRow> = <::bevy_ecs::entity::EntityRow as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -970,13 +1101,13 @@ pub(crate) fn register_identifier_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_ecs::identifier::Identifier>, - other: Ref<::bevy_ecs::identifier::Identifier>| + _self: Ref<::bevy_ecs::entity::EntityRow>, + other: Ref<::bevy_ecs::entity::EntityRow>| { let output: bool = { { - let output: bool = <::bevy_ecs::identifier::Identifier as ::core::cmp::PartialEq< - ::bevy_ecs::identifier::Identifier, + let output: bool = <::bevy_ecs::entity::EntityRow as ::core::cmp::PartialEq< + ::bevy_ecs::entity::EntityRow, >>::eq(&_self, &other) .into(); output @@ -988,12 +1119,12 @@ pub(crate) fn register_identifier_functions(world: &mut World) { &["_self", "other"], ) .register_documented( - "from_bits", - |value: u64| { - let output: Val<::bevy_ecs::identifier::Identifier> = { + "index", + |_self: Val<::bevy_ecs::entity::EntityRow>| { + let output: u32 = { { - let output: Val<::bevy_ecs::identifier::Identifier> = ::bevy_ecs::identifier::Identifier::from_bits( - value, + let output: u32 = ::bevy_ecs::entity::EntityRow::index( + _self.into_inner(), ) .into(); output @@ -1001,16 +1132,46 @@ pub(crate) fn register_identifier_functions(world: &mut World) { }; output }, - " Convert a `u64` into an [`Identifier`].\n # Panics\n This method will likely panic if given `u64` values that did not come from [`Identifier::to_bits`].", - &["value"], - ) + " Gets the index of the entity.", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ecs::entity::EntityRow, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_entity_generation_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ecs::entity::EntityGeneration, + >::new(world) .register_documented( - "low", - |_self: Val<::bevy_ecs::identifier::Identifier>| { - let output: u32 = { + "after_versions", + |_self: Val<::bevy_ecs::entity::EntityGeneration>, versions: u32| { + let output: Val<::bevy_ecs::entity::EntityGeneration> = { { - let output: u32 = ::bevy_ecs::identifier::Identifier::low( + let output: Val<::bevy_ecs::entity::EntityGeneration> = ::bevy_ecs::entity::EntityGeneration::after_versions( _self.into_inner(), + versions, + ) + .into(); + output + } + }; + output + }, + " Returns the [`EntityGeneration`] that would result from this many more `versions` of the corresponding [`EntityRow`] from passing.", + &["_self", "versions"], + ) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ecs::entity::EntityGeneration>| { + let output: () = { + { + let output: () = <::bevy_ecs::entity::EntityGeneration as ::core::cmp::Eq>::assert_receiver_is_total_eq( + &_self, ) .into(); output @@ -1018,16 +1179,16 @@ pub(crate) fn register_identifier_functions(world: &mut World) { }; output }, - " Returns the value of the low segment of the [`Identifier`].", + "", &["_self"], ) .register_documented( - "masked_high", - |_self: Val<::bevy_ecs::identifier::Identifier>| { - let output: u32 = { + "clone", + |_self: Ref<::bevy_ecs::entity::EntityGeneration>| { + let output: Val<::bevy_ecs::entity::EntityGeneration> = { { - let output: u32 = ::bevy_ecs::identifier::Identifier::masked_high( - _self.into_inner(), + let output: Val<::bevy_ecs::entity::EntityGeneration> = <::bevy_ecs::entity::EntityGeneration as ::core::clone::Clone>::clone( + &_self, ) .into(); output @@ -1035,15 +1196,52 @@ pub(crate) fn register_identifier_functions(world: &mut World) { }; output }, - " Returns the masked value of the high segment of the [`Identifier`].\n Does not include the flag bits.", + "", &["_self"], ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ecs::entity::EntityGeneration>, + other: Ref<::bevy_ecs::entity::EntityGeneration>| + { + let output: bool = { + { + let output: bool = <::bevy_ecs::entity::EntityGeneration as ::core::cmp::PartialEq< + ::bevy_ecs::entity::EntityGeneration, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "from_bits", + |bits: u32| { + let output: Val<::bevy_ecs::entity::EntityGeneration> = { + { + let output: Val<::bevy_ecs::entity::EntityGeneration> = ::bevy_ecs::entity::EntityGeneration::from_bits( + bits, + ) + .into(); + output + } + }; + output + }, + " Reconstruct an [`EntityGeneration`] previously destructured with [`EntityGeneration::to_bits`].\n Only useful when applied to results from `to_bits` in the same instance of an application.", + &["bits"], + ) .register_documented( "to_bits", - |_self: Val<::bevy_ecs::identifier::Identifier>| { - let output: u64 = { + |_self: Val<::bevy_ecs::entity::EntityGeneration>| { + let output: u32 = { { - let output: u64 = ::bevy_ecs::identifier::Identifier::to_bits( + let output: u32 = ::bevy_ecs::entity::EntityGeneration::to_bits( _self.into_inner(), ) .into(); @@ -1052,14 +1250,14 @@ pub(crate) fn register_identifier_functions(world: &mut World) { }; output }, - " Convert the [`Identifier`] into a `u64`.", + " Gets some bits that represent this value.\n The bits are opaque and should not be regarded as meaningful.", &["_self"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ecs::identifier::Identifier, + ::bevy_ecs::entity::EntityGeneration, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -1121,18 +1319,46 @@ pub(crate) fn register_disabled_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } +pub(crate) fn register_internal_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ecs::entity_disabling::Internal, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ecs::entity_disabling::Internal>| { + let output: Val<::bevy_ecs::entity_disabling::Internal> = { + { + let output: Val<::bevy_ecs::entity_disabling::Internal> = + <::bevy_ecs::entity_disabling::Internal as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ecs::entity_disabling::Internal, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} pub(crate) fn register_removed_component_entity_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ecs::removal_detection::RemovedComponentEntity, + ::bevy_ecs::lifecycle::RemovedComponentEntity, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_ecs::removal_detection::RemovedComponentEntity>| { - let output: Val<::bevy_ecs::removal_detection::RemovedComponentEntity> = { + |_self: Ref<::bevy_ecs::lifecycle::RemovedComponentEntity>| { + let output: Val<::bevy_ecs::lifecycle::RemovedComponentEntity> = { { - let output: Val< - ::bevy_ecs::removal_detection::RemovedComponentEntity, - > = <::bevy_ecs::removal_detection::RemovedComponentEntity as ::core::clone::Clone>::clone( + let output: Val<::bevy_ecs::lifecycle::RemovedComponentEntity> = <::bevy_ecs::lifecycle::RemovedComponentEntity as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -1148,31 +1374,19 @@ pub(crate) fn register_removed_component_entity_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ecs::removal_detection::RemovedComponentEntity, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_system_id_marker_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ecs::system::SystemIdMarker, - >::new(world); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_ecs::system::SystemIdMarker, + ::bevy_ecs::lifecycle::RemovedComponentEntity, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_on_despawn_functions(world: &mut World) { +pub(crate) fn register_observed_by_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ecs::world::OnDespawn, + ::bevy_ecs::observer::ObservedBy, >::new(world); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ecs::world::OnDespawn, + ::bevy_ecs::observer::ObservedBy, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -1182,21 +1396,23 @@ impl Plugin for BevyEcsScriptingPlugin { register_entity_functions(&mut world); register_child_of_functions(&mut world); register_children_functions(&mut world); + register_add_functions(&mut world); + register_despawn_functions(&mut world); + register_insert_functions(&mut world); + register_remove_functions(&mut world); + register_replace_functions(&mut world); register_name_functions(&mut world); - register_on_add_functions(&mut world); - register_on_insert_functions(&mut world); - register_on_remove_functions(&mut world); - register_on_replace_functions(&mut world); - register_component_id_functions(&mut world); register_default_query_filters_functions(&mut world); + register_component_id_functions(&mut world); register_tick_functions(&mut world); register_component_ticks_functions(&mut world); register_entity_hash_set_functions(&mut world); - register_identifier_functions(&mut world); + register_entity_row_functions(&mut world); + register_entity_generation_functions(&mut world); register_entity_hash_functions(&mut world); register_disabled_functions(&mut world); + register_internal_functions(&mut world); register_removed_component_entity_functions(&mut world); - register_system_id_marker_functions(&mut world); - register_on_despawn_functions(&mut world); + register_observed_by_functions(&mut world); } } diff --git a/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml b/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml index 32821e8dcd..f357a033e7 100644 --- a/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml @@ -17,45 +17,47 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_gizmos = { version = "0.16.1", features = [ - "bevy_pbr", - "bevy_core_pipeline", - "bevy_render", - "bevy_sprite", - "webgl", -], default-features = false } +bevy_gizmos = { version = "0.17.2", features = ["bevy_pbr", "bevy_core_pipeline", "bevy_render", "bevy_sprite_render", "webgl"], default-features = false} -bevy_app = { version = "^0.16.1", features = [], default-features = true } +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} -bevy_asset = { version = "^0.16.1", features = [], default-features = true } +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} -bevy_color = { version = "^0.16.2", features = [], default-features = true } +bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_core_pipeline = { version = "^0.16.1", features = [ -], default-features = true } +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} -bevy_ecs = { version = "^0.16.1", features = [], default-features = true } +bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} -bevy_gizmos_macros = { version = "^0.16.1", features = [ -], default-features = true } +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_image = { version = "^0.16.1", features = [], default-features = true } +bevy_gizmos_macros = { version = "^0.17.2", features = [], default-features = true} -bevy_math = { version = "^0.16.1", features = [], default-features = true } +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} -bevy_pbr = { version = "^0.16.1", features = [], default-features = true } +bevy_light = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_reflect = { version = "^0.16.1", features = [], default-features = true } +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} -bevy_render = { version = "^0.16.1", features = [], default-features = true } +bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_sprite = { version = "^0.16.1", features = [], default-features = true } +bevy_pbr = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_time = { version = "^0.16.1", features = [], default-features = true } +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_transform = { version = "^0.16.1", features = [], default-features = true } +bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} + +bevy_shader = { version = "^0.17.2", features = [], default-features = true} + +bevy_sprite_render = { version = "^0.17.2", features = ["bevy_text", "webgl"], default-features = true} + +bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} + +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} + +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} + +bytemuck = { version = "^1.0", features = [], default-features = true} -bevy_utils = { version = "^0.16.1", features = [], default-features = true } -bytemuck = { version = "^1.0", features = [], default-features = true } diff --git a/crates/bindings/bevy_gltf_bms_bindings/Cargo.toml b/crates/bindings/bevy_gltf_bms_bindings/Cargo.toml index b9a5767d11..465a5e174d 100644 --- a/crates/bindings/bevy_gltf_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_gltf_bms_bindings/Cargo.toml @@ -17,54 +17,51 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_gltf = { version = "0.16.1", features = [ - "bevy_animation", -], default-features = true } +bevy_gltf = { version = "0.17.2", features = ["bevy_animation"], default-features = true} -base64 = { version = "^0.22.0", features = [], default-features = true } +base64 = { version = "^0.22.0", features = [], default-features = true} -bevy_animation = { version = "^0.16.1", features = [], default-features = true } +bevy_animation = { version = "^0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.16.1", features = [], default-features = true } +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} -bevy_asset = { version = "^0.16.1", features = [], default-features = true } +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} -bevy_color = { version = "^0.16.2", features = [], default-features = true } +bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_core_pipeline = { version = "^0.16.1", features = [ -], default-features = true } +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} -bevy_ecs = { version = "^0.16.1", features = [], default-features = true } +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_image = { version = "^0.16.1", features = [], default-features = true } +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} -bevy_math = { version = "^0.16.1", features = [], default-features = true } +bevy_light = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_mesh = { version = "^0.16.1", features = [], default-features = true } +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} -bevy_pbr = { version = "^0.16.1", features = [], default-features = true } +bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.16.1", features = [], default-features = true } +bevy_pbr = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_render = { version = "^0.16.1", features = [], default-features = true } +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_scene = { version = "^0.16.1", features = [], default-features = true } +bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} -bevy_tasks = { version = "^0.16.1", features = [], default-features = true } +bevy_scene = { version = "^0.17.2", features = ["serialize"], default-features = true} -bevy_transform = { version = "^0.16.1", features = [], default-features = true } +bevy_tasks = { version = "^0.17.2", features = ["async_executor", "futures-lite", "multi_threaded"], default-features = true} -bevy_utils = { version = "^0.16.1", features = [], default-features = true } +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -fixedbitset = { version = "^0.5", features = [], default-features = true } +fixedbitset = { version = "^0.5", features = [], default-features = true} -itertools = { version = "^0.14", features = [], default-features = true } +itertools = { version = "^0.14", features = [], default-features = true} -percent-encoding = { version = "^2.1", features = [], default-features = true } +percent-encoding = { version = "^2.1", features = [], default-features = true} -serde = { version = "^1.0", features = [], default-features = true } +serde = { version = "^1.0", features = [], default-features = true} + +serde_json = { version = "^1.0.140", features = [], default-features = true} -serde_json = { version = "^1.0.140", features = [], default-features = true } -smallvec = { version = "^1.11", features = [], default-features = true } diff --git a/crates/bindings/bevy_gltf_bms_bindings/src/lib.rs b/crates/bindings/bevy_gltf_bms_bindings/src/lib.rs index 3c4d746c5b..84d859283b 100644 --- a/crates/bindings/bevy_gltf_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_gltf_bms_bindings/src/lib.rs @@ -96,6 +96,35 @@ pub(crate) fn register_gltf_mesh_extras_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } +pub(crate) fn register_gltf_mesh_name_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_gltf::GltfMeshName, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_gltf::GltfMeshName>| { + let output: Val<::bevy_gltf::GltfMeshName> = { + { + let output: Val<::bevy_gltf::GltfMeshName> = <::bevy_gltf::GltfMeshName as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_gltf::GltfMeshName, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} pub(crate) fn register_gltf_material_extras_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_gltf::GltfMaterialExtras, @@ -158,6 +187,7 @@ impl Plugin for BevyGltfScriptingPlugin { register_gltf_extras_functions(&mut world); register_gltf_scene_extras_functions(&mut world); register_gltf_mesh_extras_functions(&mut world); + register_gltf_mesh_name_functions(&mut world); register_gltf_material_extras_functions(&mut world); register_gltf_material_name_functions(&mut world); } diff --git a/crates/bindings/bevy_image_bms_bindings/Cargo.toml b/crates/bindings/bevy_image_bms_bindings/Cargo.toml index c8e3120e66..5dfdefa293 100644 --- a/crates/bindings/bevy_image_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_image_bms_bindings/Cargo.toml @@ -17,49 +17,39 @@ bevy_ecs = { workspace = true, features = ["std", "bevy_reflect"] } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_image = { version = "0.16.1", features = [ - "bevy_reflect", - "hdr", - "ktx2", - "png", - "ruzstd", - "zstd", -], default-features = true } +bevy_image = { version = "0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} -bevy_app = { version = "^0.16.1", features = [], default-features = true } +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} -bevy_asset = { version = "^0.16.1", features = [], default-features = true } +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} -bevy_color = { version = "^0.16.2", features = [], default-features = true } +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} -bevy_math = { version = "^0.16.1", features = [ - "bevy_reflect", -], default-features = false } +bevy_math = { version = "^0.17.2", features = ["bevy_reflect", "alloc", "std", "rand", "curve"], default-features = true} -bevy_reflect = { version = "^0.16.1", features = [], default-features = true } +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_utils = { version = "^0.16.1", features = [], default-features = true } +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} -bitflags = { version = "^2.3", features = [], default-features = true } +bitflags = { version = "^2.3", features = [], default-features = true} -bytemuck = { version = "^1.5", features = [], default-features = true } +bytemuck = { version = "^1.5", features = [], default-features = true} -futures-lite = { version = "^2.0.1", features = [], default-features = true } +futures-lite = { version = "^2.0.1", features = [], default-features = true} -guillotiere = { version = "^0.6.0", features = [], default-features = true } +guillotiere = { version = "^0.6.0", features = [], default-features = true} -half = { version = "^2.4.1", features = [], default-features = true } +half = { version = "^2.4.1", features = [], default-features = true} -image = { version = "^0.25.2", features = [ - "hdr", - "png", -], default-features = false } +image = { version = "^0.25.2", features = ["hdr", "png"], default-features = false} -ktx2 = { version = "^0.3.0", features = [], default-features = true } +ktx2 = { version = "^0.4.0", features = [], default-features = true} -rectangle-pack = { version = "^0.4", features = [], default-features = true } +rectangle-pack = { version = "^0.4", features = [], default-features = true} + +ruzstd = { version = "^0.8.0", features = [], default-features = true} + +serde = { version = "^1", features = [], default-features = true} -ruzstd = { version = "^0.8.0", features = [], default-features = true } -serde = { version = "^1", features = [], default-features = true } diff --git a/crates/bindings/bevy_image_bms_bindings/src/lib.rs b/crates/bindings/bevy_image_bms_bindings/src/lib.rs index 252a5e1c98..45ce2fbf62 100644 --- a/crates/bindings/bevy_image_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_image_bms_bindings/src/lib.rs @@ -69,6 +69,24 @@ pub(crate) fn register_texture_atlas_functions(world: &mut World) { }, "", &["_self", "other"], + ) + .register_documented( + "with_index", + |_self: Val<::bevy_image::prelude::TextureAtlas>, index: usize| { + let output: Val<::bevy_image::prelude::TextureAtlas> = { + { + let output: Val<::bevy_image::prelude::TextureAtlas> = ::bevy_image::prelude::TextureAtlas::with_index( + _self.into_inner(), + index, + ) + .into(); + output + } + }; + output + }, + " Returns this [`TextureAtlas`] with the specified index.", + &["_self", "index"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -269,6 +287,26 @@ pub(crate) fn register_image_functions(world: &mut World) { " Creates a new uninitialized 1x1x1 image", &[], ) + .register_documented( + "eq", + | + _self: Ref<::bevy_image::prelude::Image>, + other: Ref<::bevy_image::prelude::Image>| + { + let output: bool = { + { + let output: bool = <::bevy_image::prelude::Image as ::std::cmp::PartialEq< + ::bevy_image::prelude::Image, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) .register_documented( "height", |_self: Ref<::bevy_image::prelude::Image>| { diff --git a/crates/bindings/bevy_input_bms_bindings/Cargo.toml b/crates/bindings/bevy_input_bms_bindings/Cargo.toml index 7f79eb62a0..35c5329b27 100644 --- a/crates/bindings/bevy_input_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_input_bms_bindings/Cargo.toml @@ -17,38 +17,17 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_input = { version = "0.16.1", features = [ - "std", - "bevy_reflect", - "smol_str", -], default-features = true } - - -bevy_app = { version = "^0.16.1", features = [ - "std", - "bevy_reflect", -], default-features = false } - -bevy_ecs = { version = "^0.16.1", features = [ - "std", - "bevy_reflect", - "async_executor", -], default-features = false } - -bevy_math = { version = "^0.16.1", features = [ - "std", - "bevy_reflect", -], default-features = false } - -bevy_platform = { version = "^0.16.1", features = [ - "std", -], default-features = false } - -bevy_reflect = { version = "^0.16.1", features = [ - "std", - "smol_str", -], default-features = false } - -bevy_utils = { version = "^0.16.1", features = [ - "std", -], default-features = false } +bevy_input = { version = "0.17.2", features = ["std", "bevy_reflect", "smol_str"], default-features = true} + + +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "reflect_auto_register", "error_panic_hook"], default-features = true} + +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "multi_threaded", "reflect_auto_register", "backtrace", "serialize"], default-features = true} + +bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "alloc", "rand", "curve"], default-features = true} + +bevy_platform = { version = "^0.17.2", features = ["std", "alloc", "serialize"], default-features = true} + +bevy_reflect = { version = "^0.17.2", features = ["std", "smol_str", "glam", "uuid", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} + + diff --git a/crates/bindings/bevy_input_bms_bindings/src/lib.rs b/crates/bindings/bevy_input_bms_bindings/src/lib.rs index 786041ec21..8129117e7e 100644 --- a/crates/bindings/bevy_input_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_input_bms_bindings/src/lib.rs @@ -513,6 +513,72 @@ pub(crate) fn register_touch_input_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } +pub(crate) fn register_key_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_input::keyboard::Key, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_input::keyboard::Key>| { + let output: () = { + { + let output: () = <::bevy_input::keyboard::Key as ::core::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_input::keyboard::Key>| { + let output: Val<::bevy_input::keyboard::Key> = { + { + let output: Val<::bevy_input::keyboard::Key> = <::bevy_input::keyboard::Key as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_input::keyboard::Key>, + other: Ref<::bevy_input::keyboard::Key>| + { + let output: bool = { + { + let output: bool = <::bevy_input::keyboard::Key as ::core::cmp::PartialEq< + ::bevy_input::keyboard::Key, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_input::keyboard::Key, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} pub(crate) fn register_keyboard_focus_lost_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_input::keyboard::KeyboardFocusLost, @@ -1150,55 +1216,6 @@ pub(crate) fn register_gamepad_button_state_changed_event_functions(world: &mut bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_gamepad_connection_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_input::gamepad::GamepadConnection, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_input::gamepad::GamepadConnection>| { - let output: Val<::bevy_input::gamepad::GamepadConnection> = { - { - let output: Val<::bevy_input::gamepad::GamepadConnection> = - <::bevy_input::gamepad::GamepadConnection as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_input::gamepad::GamepadConnection>, - other: Ref<::bevy_input::gamepad::GamepadConnection>| { - let output: bool = { - { - let output: bool = - <::bevy_input::gamepad::GamepadConnection as ::core::cmp::PartialEq< - ::bevy_input::gamepad::GamepadConnection, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_input::gamepad::GamepadConnection, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} pub(crate) fn register_gamepad_connection_event_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_input::gamepad::GamepadConnectionEvent, @@ -1352,72 +1369,6 @@ pub(crate) fn register_gamepad_event_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_gamepad_input_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_input::gamepad::GamepadInput, - >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_input::gamepad::GamepadInput>| { - let output: () = { - { - let output: () = <::bevy_input::gamepad::GamepadInput as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_input::gamepad::GamepadInput>| { - let output: Val<::bevy_input::gamepad::GamepadInput> = { - { - let output: Val<::bevy_input::gamepad::GamepadInput> = <::bevy_input::gamepad::GamepadInput as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_input::gamepad::GamepadInput>, - other: Ref<::bevy_input::gamepad::GamepadInput>| - { - let output: bool = { - { - let output: bool = <::bevy_input::gamepad::GamepadInput as ::core::cmp::PartialEq< - ::bevy_input::gamepad::GamepadInput, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_input::gamepad::GamepadInput, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} pub(crate) fn register_gamepad_rumble_request_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_input::gamepad::GamepadRumbleRequest, @@ -1940,6 +1891,121 @@ pub(crate) fn register_button_state_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } +pub(crate) fn register_gamepad_connection_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_input::gamepad::GamepadConnection, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_input::gamepad::GamepadConnection>| { + let output: Val<::bevy_input::gamepad::GamepadConnection> = { + { + let output: Val<::bevy_input::gamepad::GamepadConnection> = + <::bevy_input::gamepad::GamepadConnection as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_input::gamepad::GamepadConnection>, + other: Ref<::bevy_input::gamepad::GamepadConnection>| { + let output: bool = { + { + let output: bool = + <::bevy_input::gamepad::GamepadConnection as ::core::cmp::PartialEq< + ::bevy_input::gamepad::GamepadConnection, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_input::gamepad::GamepadConnection, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_gamepad_input_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_input::gamepad::GamepadInput, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_input::gamepad::GamepadInput>| { + let output: () = { + { + let output: () = <::bevy_input::gamepad::GamepadInput as ::core::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_input::gamepad::GamepadInput>| { + let output: Val<::bevy_input::gamepad::GamepadInput> = { + { + let output: Val<::bevy_input::gamepad::GamepadInput> = <::bevy_input::gamepad::GamepadInput as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_input::gamepad::GamepadInput>, + other: Ref<::bevy_input::gamepad::GamepadInput>| + { + let output: bool = { + { + let output: bool = <::bevy_input::gamepad::GamepadInput as ::core::cmp::PartialEq< + ::bevy_input::gamepad::GamepadInput, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_input::gamepad::GamepadInput, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} pub(crate) fn register_button_settings_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_input::gamepad::ButtonSettings, @@ -2450,72 +2516,6 @@ pub(crate) fn register_gamepad_rumble_intensity_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_key_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_input::keyboard::Key, - >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_input::keyboard::Key>| { - let output: () = { - { - let output: () = <::bevy_input::keyboard::Key as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_input::keyboard::Key>| { - let output: Val<::bevy_input::keyboard::Key> = { - { - let output: Val<::bevy_input::keyboard::Key> = <::bevy_input::keyboard::Key as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_input::keyboard::Key>, - other: Ref<::bevy_input::keyboard::Key>| - { - let output: bool = { - { - let output: bool = <::bevy_input::keyboard::Key as ::core::cmp::PartialEq< - ::bevy_input::keyboard::Key, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_input::keyboard::Key, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} pub(crate) fn register_native_key_code_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_input::keyboard::NativeKeyCode, @@ -2837,6 +2837,7 @@ impl Plugin for BevyInputScriptingPlugin { register_key_code_functions(&mut world); register_mouse_button_functions(&mut world); register_touch_input_functions(&mut world); + register_key_functions(&mut world); register_keyboard_focus_lost_functions(&mut world); register_keyboard_input_functions(&mut world); register_accumulated_mouse_motion_functions(&mut world); @@ -2847,10 +2848,8 @@ impl Plugin for BevyInputScriptingPlugin { register_gamepad_axis_changed_event_functions(&mut world); register_gamepad_button_changed_event_functions(&mut world); register_gamepad_button_state_changed_event_functions(&mut world); - register_gamepad_connection_functions(&mut world); register_gamepad_connection_event_functions(&mut world); register_gamepad_event_functions(&mut world); - register_gamepad_input_functions(&mut world); register_gamepad_rumble_request_functions(&mut world); register_raw_gamepad_axis_changed_event_functions(&mut world); register_raw_gamepad_button_changed_event_functions(&mut world); @@ -2860,11 +2859,12 @@ impl Plugin for BevyInputScriptingPlugin { register_double_tap_gesture_functions(&mut world); register_pan_gesture_functions(&mut world); register_button_state_functions(&mut world); + register_gamepad_connection_functions(&mut world); + register_gamepad_input_functions(&mut world); register_button_settings_functions(&mut world); register_axis_settings_functions(&mut world); register_button_axis_settings_functions(&mut world); register_gamepad_rumble_intensity_functions(&mut world); - register_key_functions(&mut world); register_native_key_code_functions(&mut world); register_native_key_functions(&mut world); register_mouse_scroll_unit_functions(&mut world); diff --git a/crates/bindings/bevy_input_focus_bms_bindings/Cargo.toml b/crates/bindings/bevy_input_focus_bms_bindings/Cargo.toml index b1fe305da3..f5fe7df372 100644 --- a/crates/bindings/bevy_input_focus_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_input_focus_bms_bindings/Cargo.toml @@ -17,38 +17,19 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_input_focus = { version = "0.16.1", features = [ - "std", - "bevy_reflect", -], default-features = true } - - -bevy_app = { version = "^0.16.1", features = [ - "std", - "bevy_reflect", -], default-features = false } - -bevy_ecs = { version = "^0.16.1", features = [ - "std", - "bevy_reflect", - "async_executor", -], default-features = false } - -bevy_input = { version = "^0.16.1", features = [ - "std", - "bevy_reflect", -], default-features = false } - -bevy_math = { version = "^0.16.1", features = [ - "std", - "bevy_reflect", -], default-features = false } - -bevy_reflect = { version = "^0.16.1", features = [ - "std", -], default-features = false } - -bevy_window = { version = "^0.16.1", features = [ - "std", - "bevy_reflect", -], default-features = false } +bevy_input_focus = { version = "0.17.2", features = ["std", "bevy_reflect"], default-features = true} + + +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "reflect_auto_register", "error_panic_hook"], default-features = true} + +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "multi_threaded", "reflect_auto_register", "backtrace", "serialize"], default-features = true} + +bevy_input = { version = "^0.17.2", features = ["std", "bevy_reflect", "smol_str"], default-features = true} + +bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "alloc", "rand", "curve"], default-features = true} + +bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} + +bevy_window = { version = "^0.17.2", features = ["std", "bevy_reflect", "bevy_image", "bevy_asset", "custom_cursor"], default-features = true} + + diff --git a/crates/bindings/bevy_light_bms_bindings/Cargo.toml b/crates/bindings/bevy_light_bms_bindings/Cargo.toml new file mode 100644 index 0000000000..bdcddafacb --- /dev/null +++ b/crates/bindings/bevy_light_bms_bindings/Cargo.toml @@ -0,0 +1,47 @@ +[package] +name = "bevy_light_bms_bindings" +description = "Automatically generated bindings for bevy_light crate" +readme = "README.md" +version.workspace = true +edition.workspace = true +authors.workspace = true +license.workspace = true +homepage.workspace = true +repository.workspace = true +keywords.workspace = true +categories.workspace = true + +[dependencies] + + +bevy_mod_scripting_core = { workspace = true } +bevy_mod_scripting_bindings = { workspace = true } +bevy_mod_scripting_derive = { workspace = true } +bevy_light = { version = "0.17.2", features = ["webgl"], default-features = true} + + +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} + +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} + +bevy_camera = { version = "^0.17.2", features = [], default-features = true} + +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} + +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} + +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} + +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} + +bevy_mesh = { version = "^0.17.2", features = [], default-features = true} + +bevy_platform = { version = "^0.17.2", features = ["alloc", "std", "serialize"], default-features = true} + +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} + +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} + +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} + + diff --git a/crates/bindings/bevy_light_bms_bindings/README.md b/crates/bindings/bevy_light_bms_bindings/README.md new file mode 100644 index 0000000000..99a687def2 --- /dev/null +++ b/crates/bindings/bevy_light_bms_bindings/README.md @@ -0,0 +1,4 @@ +# bevy_light bindings +This crate is part of the [bevy_mod_scripting](http://github.com/makspll/bevy_mod_scripting) project. + +The code inside is fully generated via a custom rustc plugin. \ No newline at end of file diff --git a/crates/bindings/bevy_light_bms_bindings/src/lib.rs b/crates/bindings/bevy_light_bms_bindings/src/lib.rs new file mode 100644 index 0000000000..6bfb72014a --- /dev/null +++ b/crates/bindings/bevy_light_bms_bindings/src/lib.rs @@ -0,0 +1,862 @@ +#![allow(clippy::all)] +#![allow(unused, deprecated, dead_code)] + +use bevy_app::{App, Plugin}; +use bevy_ecs::prelude::*; +use bevy_mod_scripting_bindings::{ + ReflectReference, + function::{ + from::{Mut, Ref, Val}, + namespace::NamespaceBuilder, + }, +}; +use bevy_mod_scripting_derive::script_bindings; +pub struct BevyLightScriptingPlugin; +pub(crate) fn register_clustered_decal_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::cluster::ClusteredDecal, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::cluster::ClusteredDecal>| { + let output: Val<::bevy_light::cluster::ClusteredDecal> = { + { + let output: Val<::bevy_light::cluster::ClusteredDecal> = + <::bevy_light::cluster::ClusteredDecal as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::cluster::ClusteredDecal, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_ambient_light_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::AmbientLight, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::AmbientLight>| { + let output: Val<::bevy_light::AmbientLight> = { + { + let output: Val<::bevy_light::AmbientLight> = <::bevy_light::AmbientLight as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::AmbientLight, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_environment_map_light_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::EnvironmentMapLight, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::EnvironmentMapLight>| { + let output: Val<::bevy_light::EnvironmentMapLight> = { + { + let output: Val<::bevy_light::EnvironmentMapLight> = + <::bevy_light::EnvironmentMapLight as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::EnvironmentMapLight, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_generated_environment_map_light_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::GeneratedEnvironmentMapLight, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::GeneratedEnvironmentMapLight>| { + let output: Val<::bevy_light::GeneratedEnvironmentMapLight> = { + { + let output: Val<::bevy_light::GeneratedEnvironmentMapLight> = + <::bevy_light::GeneratedEnvironmentMapLight as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::GeneratedEnvironmentMapLight, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_irradiance_volume_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::IrradianceVolume, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::IrradianceVolume>| { + let output: Val<::bevy_light::IrradianceVolume> = { + { + let output: Val<::bevy_light::IrradianceVolume> = + <::bevy_light::IrradianceVolume as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::IrradianceVolume, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_light_probe_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::LightProbe, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::LightProbe>| { + let output: Val<::bevy_light::LightProbe> = { + { + let output: Val<::bevy_light::LightProbe> = <::bevy_light::LightProbe as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "new", + || { + let output: Val<::bevy_light::LightProbe> = { + { + let output: Val<::bevy_light::LightProbe> = ::bevy_light::LightProbe::new() + .into(); + output + } + }; + output + }, + " Creates a new light probe component.", + &[], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::LightProbe, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_fog_volume_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::FogVolume, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::FogVolume>| { + let output: Val<::bevy_light::FogVolume> = { + { + let output: Val<::bevy_light::FogVolume> = <::bevy_light::FogVolume as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::FogVolume, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_volumetric_fog_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::VolumetricFog, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::VolumetricFog>| { + let output: Val<::bevy_light::VolumetricFog> = { + { + let output: Val<::bevy_light::VolumetricFog> = <::bevy_light::VolumetricFog as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::VolumetricFog, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_volumetric_light_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::VolumetricLight, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::VolumetricLight>| { + let output: Val<::bevy_light::VolumetricLight> = { + { + let output: Val<::bevy_light::VolumetricLight> = + <::bevy_light::VolumetricLight as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::VolumetricLight, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_cascade_shadow_config_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::cascade::CascadeShadowConfig, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::cascade::CascadeShadowConfig>| { + let output: Val<::bevy_light::cascade::CascadeShadowConfig> = { + { + let output: Val<::bevy_light::cascade::CascadeShadowConfig> = + <::bevy_light::cascade::CascadeShadowConfig as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::cascade::CascadeShadowConfig, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_cascades_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::cascade::Cascades, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::cascade::Cascades>| { + let output: Val<::bevy_light::cascade::Cascades> = { + { + let output: Val<::bevy_light::cascade::Cascades> = + <::bevy_light::cascade::Cascades as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::cascade::Cascades, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_point_light_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::PointLight, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::PointLight>| { + let output: Val<::bevy_light::PointLight> = { + { + let output: Val<::bevy_light::PointLight> = <::bevy_light::PointLight as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::PointLight, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_point_light_shadow_map_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::PointLightShadowMap, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::PointLightShadowMap>| { + let output: Val<::bevy_light::PointLightShadowMap> = { + { + let output: Val<::bevy_light::PointLightShadowMap> = + <::bevy_light::PointLightShadowMap as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::PointLightShadowMap, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_point_light_texture_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::PointLightTexture, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::PointLightTexture>| { + let output: Val<::bevy_light::PointLightTexture> = { + { + let output: Val<::bevy_light::PointLightTexture> = + <::bevy_light::PointLightTexture as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::PointLightTexture, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_spot_light_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::SpotLight, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::SpotLight>| { + let output: Val<::bevy_light::SpotLight> = { + { + let output: Val<::bevy_light::SpotLight> = <::bevy_light::SpotLight as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::SpotLight, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_spot_light_texture_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::SpotLightTexture, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::SpotLightTexture>| { + let output: Val<::bevy_light::SpotLightTexture> = { + { + let output: Val<::bevy_light::SpotLightTexture> = + <::bevy_light::SpotLightTexture as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::SpotLightTexture, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_directional_light_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::DirectionalLight, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::DirectionalLight>| { + let output: Val<::bevy_light::DirectionalLight> = { + { + let output: Val<::bevy_light::DirectionalLight> = + <::bevy_light::DirectionalLight as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::DirectionalLight, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_directional_light_shadow_map_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::DirectionalLightShadowMap, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::DirectionalLightShadowMap>| { + let output: Val<::bevy_light::DirectionalLightShadowMap> = { + { + let output: Val<::bevy_light::DirectionalLightShadowMap> = + <::bevy_light::DirectionalLightShadowMap as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::DirectionalLightShadowMap, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_directional_light_texture_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::DirectionalLightTexture, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::DirectionalLightTexture>| { + let output: Val<::bevy_light::DirectionalLightTexture> = { + { + let output: Val<::bevy_light::DirectionalLightTexture> = + <::bevy_light::DirectionalLightTexture as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::DirectionalLightTexture, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_not_shadow_caster_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::NotShadowCaster, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::NotShadowCaster>| { + let output: Val<::bevy_light::NotShadowCaster> = { + { + let output: Val<::bevy_light::NotShadowCaster> = + <::bevy_light::NotShadowCaster as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_light::NotShadowCaster>, other: Ref<::bevy_light::NotShadowCaster>| { + let output: bool = { + { + let output: bool = <::bevy_light::NotShadowCaster as ::std::cmp::PartialEq< + ::bevy_light::NotShadowCaster, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::NotShadowCaster, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_not_shadow_receiver_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::NotShadowReceiver, + >::new(world); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::NotShadowReceiver, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_transmitted_shadow_receiver_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::TransmittedShadowReceiver, + >::new(world); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::TransmittedShadowReceiver, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_shadow_filtering_method_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::ShadowFilteringMethod, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_light::ShadowFilteringMethod>| { + let output: () = { + { + let output: () = <::bevy_light::ShadowFilteringMethod as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_light::ShadowFilteringMethod>| { + let output: Val<::bevy_light::ShadowFilteringMethod> = { + { + let output: Val<::bevy_light::ShadowFilteringMethod> = <::bevy_light::ShadowFilteringMethod as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_light::ShadowFilteringMethod>, + other: Ref<::bevy_light::ShadowFilteringMethod>| + { + let output: bool = { + { + let output: bool = <::bevy_light::ShadowFilteringMethod as ::std::cmp::PartialEq< + ::bevy_light::ShadowFilteringMethod, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::ShadowFilteringMethod, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_cluster_far_z_mode_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::cluster::ClusterFarZMode, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::cluster::ClusterFarZMode>| { + let output: Val<::bevy_light::cluster::ClusterFarZMode> = { + { + let output: Val<::bevy_light::cluster::ClusterFarZMode> = + <::bevy_light::cluster::ClusterFarZMode as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::cluster::ClusterFarZMode, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_cluster_z_config_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::cluster::ClusterZConfig, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::cluster::ClusterZConfig>| { + let output: Val<::bevy_light::cluster::ClusterZConfig> = { + { + let output: Val<::bevy_light::cluster::ClusterZConfig> = + <::bevy_light::cluster::ClusterZConfig as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::cluster::ClusterZConfig, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_cluster_config_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::cluster::ClusterConfig, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::cluster::ClusterConfig>| { + let output: Val<::bevy_light::cluster::ClusterConfig> = { + { + let output: Val<::bevy_light::cluster::ClusterConfig> = + <::bevy_light::cluster::ClusterConfig as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::cluster::ClusterConfig, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_cascade_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_light::cascade::Cascade, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_light::cascade::Cascade>| { + let output: Val<::bevy_light::cascade::Cascade> = { + { + let output: Val<::bevy_light::cascade::Cascade> = + <::bevy_light::cascade::Cascade as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_light::cascade::Cascade, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +impl Plugin for BevyLightScriptingPlugin { + fn build(&self, app: &mut App) { + let mut world = app.world_mut(); + register_clustered_decal_functions(&mut world); + register_ambient_light_functions(&mut world); + register_environment_map_light_functions(&mut world); + register_generated_environment_map_light_functions(&mut world); + register_irradiance_volume_functions(&mut world); + register_light_probe_functions(&mut world); + register_fog_volume_functions(&mut world); + register_volumetric_fog_functions(&mut world); + register_volumetric_light_functions(&mut world); + register_cascade_shadow_config_functions(&mut world); + register_cascades_functions(&mut world); + register_point_light_functions(&mut world); + register_point_light_shadow_map_functions(&mut world); + register_point_light_texture_functions(&mut world); + register_spot_light_functions(&mut world); + register_spot_light_texture_functions(&mut world); + register_directional_light_functions(&mut world); + register_directional_light_shadow_map_functions(&mut world); + register_directional_light_texture_functions(&mut world); + register_not_shadow_caster_functions(&mut world); + register_not_shadow_receiver_functions(&mut world); + register_transmitted_shadow_receiver_functions(&mut world); + register_shadow_filtering_method_functions(&mut world); + register_cluster_far_z_mode_functions(&mut world); + register_cluster_z_config_functions(&mut world); + register_cluster_config_functions(&mut world); + register_cascade_functions(&mut world); + } +} diff --git a/crates/bindings/bevy_math_bms_bindings/Cargo.toml b/crates/bindings/bevy_math_bms_bindings/Cargo.toml index 5fcfab24ec..dc18f5c448 100644 --- a/crates/bindings/bevy_math_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_math_bms_bindings/Cargo.toml @@ -17,41 +17,21 @@ bevy_app = { workspace = true, features = ["std"] } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_math = { version = "0.16.1", features = [ - "std", - "rand", - "curve", - "alloc", - "bevy_reflect", -], default-features = true } +bevy_math = { version = "0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} -bevy_reflect = { version = "^0.16.1", features = [ - "std", -], default-features = false } +bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} -derive_more = { version = "^1", features = ["std"], default-features = false } +derive_more = { version = "^2", features = ["std"], default-features = false} -glam = { version = "^0.29.3", features = [ - "std", - "rand", -], default-features = false } +glam = { version = "^0.30.1", features = ["std", "rand"], default-features = false} -itertools = { version = "^0.14.0", features = [ - "use_std", - "use_alloc", -], default-features = false } +itertools = { version = "^0.14.0", features = ["use_alloc", "use_std"], default-features = false} -rand = { version = "^0.8", features = [ - "std", - "alloc", -], default-features = false } +rand = { version = "^0.9", features = ["alloc", "std"], default-features = false} -rand_distr = { version = "^0.4.3", features = [ - "std", - "alloc", -], default-features = false } +rand_distr = { version = "^0.5", features = ["alloc", "std"], default-features = false} + +variadics_please = { version = "^1.1", features = [], default-features = true} -smallvec = { version = "^1.11", features = [], default-features = true } -variadics_please = { version = "^1.1", features = [], default-features = true } diff --git a/crates/bindings/bevy_math_bms_bindings/src/lib.rs b/crates/bindings/bevy_math_bms_bindings/src/lib.rs index fff6a798ec..90ba957907 100644 --- a/crates/bindings/bevy_math_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_math_bms_bindings/src/lib.rs @@ -1020,7 +1020,7 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { }; output }, - " Returns the rotation in degrees in the `(-180, 180]` range.", + " Returns a corresponding rotation angle in degrees in the `(-180, 180]` range.", &["_self"], ) .register_documented( @@ -1037,7 +1037,7 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { }; output }, - " Returns the rotation in radians in the `(-pi, pi]` range.", + " Returns a corresponding rotation angle in radians in the `(-pi, pi]` range.", &["_self"], ) .register_documented( @@ -1054,7 +1054,7 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { }; output }, - " Returns the rotation as a fraction of a full 360 degree turn.", + " Returns a corresponding rotation angle as a fraction of a full 360 degree turn in the `(-0.5, 0.5]` range.", &["_self"], ) .register_documented( @@ -1088,7 +1088,7 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { }; output }, - " Creates a [`Rot2`] from a counterclockwise angle in degrees.\n # Note\n The input rotation will always be clamped to the range `(-180°, 180°]` by design.\n # Example\n ```\n # use bevy_math::Rot2;\n # use approx::assert_relative_eq;\n let rot1 = Rot2::degrees(270.0);\n let rot2 = Rot2::degrees(-90.0);\n #[cfg(feature = \"approx\")]\n assert_relative_eq!(rot1, rot2);\n let rot3 = Rot2::degrees(180.0);\n #[cfg(feature = \"approx\")]\n assert_relative_eq!(rot1 * rot1, rot3);\n ```", + " Creates a [`Rot2`] from a counterclockwise angle in degrees.\n A negative argument corresponds to a clockwise rotation.\n # Note\n Angles larger than or equal to 360° (in either direction) loop around to smaller rotations, since a full rotation returns an object to its starting orientation.\n # Example\n ```\n # use bevy_math::Rot2;\n # use approx::{assert_relative_eq, assert_abs_diff_eq};\n let rot1 = Rot2::degrees(270.0);\n let rot2 = Rot2::degrees(-90.0);\n #[cfg(feature = \"approx\")]\n assert_relative_eq!(rot1, rot2);\n let rot3 = Rot2::degrees(180.0);\n #[cfg(feature = \"approx\")]\n assert_relative_eq!(rot1 * rot1, rot3);\n // A rotation by 365° and 5° are the same\n #[cfg(feature = \"approx\")]\n assert_abs_diff_eq!(Rot2::degrees(365.0), Rot2::degrees(5.0), epsilon = 2e-7);\n ```", &["degrees"], ) .register_documented( @@ -1140,7 +1140,7 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { }; output }, - " Creates a [`Rot2`] from the sine and cosine of an angle in radians.\n The rotation is only valid if `sin * sin + cos * cos == 1.0`.\n # Panics\n Panics if `sin * sin + cos * cos != 1.0` when the `glam_assert` feature is enabled.", + " Creates a [`Rot2`] from the sine and cosine of an angle.\n The rotation is only valid if `sin * sin + cos * cos == 1.0`.\n # Panics\n Panics if `sin * sin + cos * cos != 1.0` when the `glam_assert` feature is enabled.", &["sin", "cos"], ) .register_documented( @@ -1376,7 +1376,7 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { }; output }, - " Creates a [`Rot2`] from a counterclockwise angle in radians.\n # Note\n The input rotation will always be clamped to the range `(-π, π]` by design.\n # Example\n ```\n # use bevy_math::Rot2;\n # use approx::assert_relative_eq;\n # use std::f32::consts::{FRAC_PI_2, PI};\n let rot1 = Rot2::radians(3.0 * FRAC_PI_2);\n let rot2 = Rot2::radians(-FRAC_PI_2);\n #[cfg(feature = \"approx\")]\n assert_relative_eq!(rot1, rot2);\n let rot3 = Rot2::radians(PI);\n #[cfg(feature = \"approx\")]\n assert_relative_eq!(rot1 * rot1, rot3);\n ```", + " Creates a [`Rot2`] from a counterclockwise angle in radians.\n A negative argument corresponds to a clockwise rotation.\n # Note\n Angles larger than or equal to 2π (in either direction) loop around to smaller rotations, since a full rotation returns an object to its starting orientation.\n # Example\n ```\n # use bevy_math::Rot2;\n # use approx::assert_relative_eq;\n # use std::f32::consts::{FRAC_PI_2, PI};\n let rot1 = Rot2::radians(3.0 * FRAC_PI_2);\n let rot2 = Rot2::radians(-FRAC_PI_2);\n #[cfg(feature = \"approx\")]\n assert_relative_eq!(rot1, rot2);\n let rot3 = Rot2::radians(PI);\n #[cfg(feature = \"approx\")]\n assert_relative_eq!(rot1 * rot1, rot3);\n // A rotation by 3π and 1π are the same\n #[cfg(feature = \"approx\")]\n assert_relative_eq!(Rot2::radians(3.0 * PI), Rot2::radians(PI));\n ```", &["radians"], ) .register_documented( @@ -1393,7 +1393,7 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { }; output }, - " Returns the sine and cosine of the rotation angle in radians.", + " Returns the sine and cosine of the rotation angle.", &["_self"], ) .register_documented( @@ -1429,7 +1429,7 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { }; output }, - " Creates a [`Rot2`] from a counterclockwise fraction of a full turn of 360 degrees.\n # Note\n The input rotation will always be clamped to the range `(-50%, 50%]` by design.\n # Example\n ```\n # use bevy_math::Rot2;\n # use approx::assert_relative_eq;\n let rot1 = Rot2::turn_fraction(0.75);\n let rot2 = Rot2::turn_fraction(-0.25);\n #[cfg(feature = \"approx\")]\n assert_relative_eq!(rot1, rot2);\n let rot3 = Rot2::turn_fraction(0.5);\n #[cfg(feature = \"approx\")]\n assert_relative_eq!(rot1 * rot1, rot3);\n ```", + " Creates a [`Rot2`] from a counterclockwise fraction of a full turn of 360 degrees.\n A negative argument corresponds to a clockwise rotation.\n # Note\n Angles larger than or equal to 1 turn (in either direction) loop around to smaller rotations, since a full rotation returns an object to its starting orientation.\n # Example\n ```\n # use bevy_math::Rot2;\n # use approx::assert_relative_eq;\n let rot1 = Rot2::turn_fraction(0.75);\n let rot2 = Rot2::turn_fraction(-0.25);\n #[cfg(feature = \"approx\")]\n assert_relative_eq!(rot1, rot2);\n let rot3 = Rot2::turn_fraction(0.5);\n #[cfg(feature = \"approx\")]\n assert_relative_eq!(rot1 * rot1, rot3);\n // A rotation by 1.5 turns and 0.5 turns are the same\n #[cfg(feature = \"approx\")]\n assert_relative_eq!(Rot2::turn_fraction(1.5), Rot2::turn_fraction(0.5));\n ```", &["fraction"], ); let registry = world.get_resource_or_init::(); @@ -5456,6 +5456,27 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "closest_point", + | + _self: Ref<::bevy_math::primitives::Segment2d>, + point: Val<::bevy_math::prelude::Vec2>| + { + let output: Val<::bevy_math::prelude::Vec2> = { + { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Segment2d::closest_point( + &_self, + point.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the point on the [`Segment2d`] that is closest to the specified `point`.", + &["_self", "point"], + ) .register_documented( "direction", |_self: Ref<::bevy_math::primitives::Segment2d>| { @@ -6023,6 +6044,193 @@ pub(crate) fn register_triangle_2_d_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } +pub(crate) fn register_convex_polygon_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::ConvexPolygon, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::ConvexPolygon>| { + let output: Val<::bevy_math::primitives::ConvexPolygon> = { + { + let output: Val<::bevy_math::primitives::ConvexPolygon> = + <::bevy_math::primitives::ConvexPolygon as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_math::primitives::ConvexPolygon>, + other: Ref<::bevy_math::primitives::ConvexPolygon>| { + let output: bool = { + { + let output: bool = + <::bevy_math::primitives::ConvexPolygon as ::core::cmp::PartialEq< + ::bevy_math::primitives::ConvexPolygon, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::ConvexPolygon, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_polygon_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Polygon, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Polygon>| { + let output: Val<::bevy_math::primitives::Polygon> = { + { + let output: Val<::bevy_math::primitives::Polygon> = <::bevy_math::primitives::Polygon as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::primitives::Polygon>, + other: Ref<::bevy_math::primitives::Polygon>| + { + let output: bool = { + { + let output: bool = <::bevy_math::primitives::Polygon as ::core::cmp::PartialEq< + ::bevy_math::primitives::Polygon, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "is_simple", + |_self: Ref<::bevy_math::primitives::Polygon>| { + let output: bool = { + { + let output: bool = ::bevy_math::primitives::Polygon::is_simple( + &_self, + ) + .into(); + output + } + }; + output + }, + " Tests if the polygon is simple.\n A polygon is simple if it is not self intersecting and not self tangent.\n As such, no two edges of the polygon may cross each other and each vertex must not lie on another edge.", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::Polygon, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_polyline_2_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Polyline2d, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Polyline2d>| { + let output: Val<::bevy_math::primitives::Polyline2d> = { + { + let output: Val<::bevy_math::primitives::Polyline2d> = <::bevy_math::primitives::Polyline2d as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::primitives::Polyline2d>, + other: Ref<::bevy_math::primitives::Polyline2d>| + { + let output: bool = { + { + let output: bool = <::bevy_math::primitives::Polyline2d as ::core::cmp::PartialEq< + ::bevy_math::primitives::Polyline2d, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "with_subdivisions", + | + start: Val<::bevy_math::prelude::Vec2>, + end: Val<::bevy_math::prelude::Vec2>, + subdivisions: usize| + { + let output: Val<::bevy_math::primitives::Polyline2d> = { + { + let output: Val<::bevy_math::primitives::Polyline2d> = ::bevy_math::primitives::Polyline2d::with_subdivisions( + start.into_inner(), + end.into_inner(), + subdivisions, + ) + .into(); + output + } + }; + output + }, + " Create a new `Polyline2d` from two endpoints with subdivision points.\n `subdivisions = 0` creates a simple line with just start and end points.\n `subdivisions = 1` adds one point in the middle, creating 2 segments, etc.", + &["start", "end", "subdivisions"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::Polyline2d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} pub(crate) fn register_aabb_3_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_math::bounding::Aabb3d, @@ -6986,6 +7194,27 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "closest_point", + | + _self: Ref<::bevy_math::primitives::Segment3d>, + point: Val<::bevy_math::prelude::Vec3>| + { + let output: Val<::bevy_math::prelude::Vec3> = { + { + let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::primitives::Segment3d::closest_point( + &_self, + point.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the point on the [`Segment3d`] that is closest to the specified `point`.", + &["_self", "point"], + ) .register_documented( "direction", |_self: Ref<::bevy_math::primitives::Segment3d>| { @@ -7620,6 +7849,78 @@ pub(crate) fn register_triangle_3_d_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } +pub(crate) fn register_polyline_3_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Polyline3d, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Polyline3d>| { + let output: Val<::bevy_math::primitives::Polyline3d> = { + { + let output: Val<::bevy_math::primitives::Polyline3d> = <::bevy_math::primitives::Polyline3d as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::primitives::Polyline3d>, + other: Ref<::bevy_math::primitives::Polyline3d>| + { + let output: bool = { + { + let output: bool = <::bevy_math::primitives::Polyline3d as ::core::cmp::PartialEq< + ::bevy_math::primitives::Polyline3d, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "with_subdivisions", + | + start: Val<::bevy_math::prelude::Vec3>, + end: Val<::bevy_math::prelude::Vec3>, + subdivisions: usize| + { + let output: Val<::bevy_math::primitives::Polyline3d> = { + { + let output: Val<::bevy_math::primitives::Polyline3d> = ::bevy_math::primitives::Polyline3d::with_subdivisions( + start.into_inner(), + end.into_inner(), + subdivisions, + ) + .into(); + output + } + }; + output + }, + " Create a new `Polyline3d` from two endpoints with subdivision points.\n `subdivisions = 0` creates a simple line with just start and end points.\n `subdivisions = 1` adds one point in the middle, creating 2 segments, etc.", + &["start", "end", "subdivisions"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::Polyline3d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} pub(crate) fn register_ray_cast_2_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_math::bounding::RayCast2d, @@ -8363,6 +8664,154 @@ pub(crate) fn register_interval_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } +pub(crate) fn register_dir_4_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::Dir4, + >::new(world) + .register_documented( + "as_vec4", + |_self: Ref<::bevy_math::Dir4>| { + let output: Val<::bevy_math::prelude::Vec4> = { + { + let output: Val<::bevy_math::prelude::Vec4> = ::bevy_math::Dir4::as_vec4( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the inner [`Vec4`]", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_math::Dir4>| { + let output: Val<::bevy_math::Dir4> = { + { + let output: Val<::bevy_math::Dir4> = <::bevy_math::Dir4 as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_math::Dir4>, other: Ref<::bevy_math::Dir4>| { + let output: bool = { + { + let output: bool = <::bevy_math::Dir4 as ::core::cmp::PartialEq< + ::bevy_math::Dir4, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "fast_renormalize", + |_self: Val<::bevy_math::Dir4>| { + let output: Val<::bevy_math::Dir4> = { + { + let output: Val<::bevy_math::Dir4> = ::bevy_math::Dir4::fast_renormalize( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns `self` after an approximate normalization, assuming the value is already nearly normalized.\n Useful for preventing numerical error accumulation.", + &["_self"], + ) + .register_documented( + "from_xyzw_unchecked", + |x: f32, y: f32, z: f32, w: f32| { + let output: Val<::bevy_math::Dir4> = { + { + let output: Val<::bevy_math::Dir4> = ::bevy_math::Dir4::from_xyzw_unchecked( + x, + y, + z, + w, + ) + .into(); + output + } + }; + output + }, + " Create a direction from its `x`, `y`, `z`, and `w` components, assuming the resulting vector is normalized.\n # Warning\n The vector produced from `x`, `y`, `z`, and `w` must be normalized, i.e its length must be `1.0`.", + &["x", "y", "z", "w"], + ) + .register_documented( + "mul", + |_self: Val<::bevy_math::Dir4>, rhs: f32| { + let output: Val<::bevy_math::prelude::Vec4> = { + { + let output: Val<::bevy_math::prelude::Vec4> = <::bevy_math::Dir4 as ::core::ops::Mul< + f32, + >>::mul(_self.into_inner(), rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "neg", + |_self: Val<::bevy_math::Dir4>| { + let output: Val<::bevy_math::Dir4> = { + { + let output: Val<::bevy_math::Dir4> = <::bevy_math::Dir4 as ::core::ops::Neg>::neg( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "new_unchecked", + |value: Val<::bevy_math::prelude::Vec4>| { + let output: Val<::bevy_math::Dir4> = { + { + let output: Val<::bevy_math::Dir4> = ::bevy_math::Dir4::new_unchecked( + value.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a [`Dir4`] from a [`Vec4`] that is already normalized.\n # Warning\n `value` must be normalized, i.e its length must be `1.0`.", + &["value"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::<::bevy_math::Dir4, bevy_mod_scripting_bindings::MarkAsGenerated>(); +} pub(crate) fn register_float_ord_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_math::FloatOrd, @@ -8819,6 +9268,9 @@ impl Plugin for BevyMathScriptingPlugin { register_rhombus_functions(&mut world); register_segment_2_d_functions(&mut world); register_triangle_2_d_functions(&mut world); + register_convex_polygon_functions(&mut world); + register_polygon_functions(&mut world); + register_polyline_2_d_functions(&mut world); register_aabb_3_d_functions(&mut world); register_bounding_sphere_functions(&mut world); register_sphere_functions(&mut world); @@ -8832,6 +9284,7 @@ impl Plugin for BevyMathScriptingPlugin { register_segment_3_d_functions(&mut world); register_torus_functions(&mut world); register_triangle_3_d_functions(&mut world); + register_polyline_3_d_functions(&mut world); register_ray_cast_2_d_functions(&mut world); register_aabb_cast_2_d_functions(&mut world); register_bounding_circle_cast_functions(&mut world); @@ -8839,6 +9292,7 @@ impl Plugin for BevyMathScriptingPlugin { register_aabb_cast_3_d_functions(&mut world); register_bounding_sphere_cast_functions(&mut world); register_interval_functions(&mut world); + register_dir_4_functions(&mut world); register_float_ord_functions(&mut world); register_plane_3_d_functions(&mut world); register_tetrahedron_functions(&mut world); diff --git a/crates/bindings/bevy_mesh_bms_bindings/Cargo.toml b/crates/bindings/bevy_mesh_bms_bindings/Cargo.toml index 153e5a66eb..12a4cbd5da 100644 --- a/crates/bindings/bevy_mesh_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_mesh_bms_bindings/Cargo.toml @@ -13,36 +13,35 @@ categories.workspace = true [dependencies] -bevy_app = { workspace = true, features = ["std"] } + bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_mesh = { version = "0.16.1", features = [], default-features = true } +bevy_mesh = { version = "0.17.2", features = [], default-features = true} + +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} -bevy_asset = { version = "^0.16.1", features = [], default-features = true } +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} -bevy_derive = { version = "^0.16.1", features = [], default-features = true } +bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.16.1", features = [], default-features = true } +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_image = { version = "^0.16.1", features = [], default-features = true } +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} -bevy_math = { version = "^0.16.1", features = [], default-features = true } +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} -bevy_mikktspace = { version = "^0.16.1", features = [ -], default-features = true } +bevy_mikktspace = { version = "^0.17.0-dev", features = [], default-features = true} -bevy_reflect = { version = "^0.16.1", features = [], default-features = true } +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_transform = { version = "^0.16.1", features = [], default-features = true } +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.16.1", features = [], default-features = true } +bitflags = { version = "^2.3", features = [], default-features = true} -bitflags = { version = "^2.3", features = [], default-features = true } +bytemuck = { version = "^1.5", features = [], default-features = true} -bytemuck = { version = "^1.5", features = [], default-features = true } +hexasphere = { version = "^16.0", features = [], default-features = true} -hexasphere = { version = "^15.0", features = [], default-features = true } -serde = { version = "^1", features = [], default-features = true } diff --git a/crates/bindings/bevy_mesh_bms_bindings/src/lib.rs b/crates/bindings/bevy_mesh_bms_bindings/src/lib.rs index c9e7179f3a..90a8ffb06b 100644 --- a/crates/bindings/bevy_mesh_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_mesh_bms_bindings/src/lib.rs @@ -12,16 +12,44 @@ use bevy_mod_scripting_bindings::{ }; use bevy_mod_scripting_derive::script_bindings; pub struct BevyMeshScriptingPlugin; -pub(crate) fn register_indices_functions(world: &mut World) { +pub(crate) fn register_morph_weights_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::Indices, + ::bevy_mesh::morph::MorphWeights, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_mesh::morph::MorphWeights>| { + let output: Val<::bevy_mesh::morph::MorphWeights> = { + { + let output: Val<::bevy_mesh::morph::MorphWeights> = + <::bevy_mesh::morph::MorphWeights as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_mesh::morph::MorphWeights, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_mesh_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_mesh::prelude::Mesh, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_mesh::Indices>| { - let output: Val<::bevy_mesh::Indices> = { + |_self: Ref<::bevy_mesh::prelude::Mesh>| { + let output: Val<::bevy_mesh::prelude::Mesh> = { { - let output: Val<::bevy_mesh::Indices> = <::bevy_mesh::Indices as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::prelude::Mesh> = <::bevy_mesh::prelude::Mesh as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -34,64 +62,12 @@ pub(crate) fn register_indices_functions(world: &mut World) { &["_self"], ) .register_documented( - "is_empty", - |_self: Ref<::bevy_mesh::Indices>| { - let output: bool = { - { - let output: bool = ::bevy_mesh::Indices::is_empty(&_self).into(); - output - } - }; - output - }, - " Returns `true` if there are no indices.", - &["_self"], - ) - .register_documented( - "len", - |_self: Ref<::bevy_mesh::Indices>| { - let output: usize = { - { - let output: usize = ::bevy_mesh::Indices::len(&_self).into(); - output - } - }; - output - }, - " Returns the number of indices.", - &["_self"], - ) - .register_documented( - "push", - |mut _self: Mut<::bevy_mesh::Indices>, index: u32| { + "compute_area_weighted_normals", + |mut _self: Mut<::bevy_mesh::prelude::Mesh>| { let output: () = { { - let output: () = ::bevy_mesh::Indices::push(&mut _self, index) - .into(); - output - } - }; - output - }, - " Add an index. If the index is greater than `u16::MAX`,\n the storage will be converted to `u32`.", - &["_self", "index"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::<::bevy_mesh::Indices, bevy_mod_scripting_bindings::MarkAsGenerated>(); -} -pub(crate) fn register_mesh_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::Mesh, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_mesh::Mesh>| { - let output: Val<::bevy_mesh::Mesh> = { - { - let output: Val<::bevy_mesh::Mesh> = <::bevy_mesh::Mesh as ::std::clone::Clone>::clone( - &_self, + let output: () = ::bevy_mesh::prelude::Mesh::compute_area_weighted_normals( + &mut _self, ) .into(); output @@ -99,15 +75,15 @@ pub(crate) fn register_mesh_functions(world: &mut World) { }; output }, - "", + " Calculates the [`Mesh::ATTRIBUTE_NORMAL`] of an indexed mesh, smoothing normals for shared\n vertices.\n This method weights normals by the area of each triangle containing the vertex. Thus,\n larger triangles will skew the normals of their vertices towards their own normal more\n than smaller triangles will.\n This method is actually somewhat faster than [`Mesh::compute_smooth_normals`] because an\n intermediate result of triangle normal calculation is already scaled by the triangle's area.\n If you would rather have the computed normals be influenced only by the angles of connected\n edges, see [`Mesh::compute_smooth_normals`] instead. If you need to weight them in some\n other way, see [`Mesh::compute_custom_smooth_normals`].\n # Panics\n Panics if [`Mesh::ATTRIBUTE_POSITION`] is not of type `float3`.\n Panics if the mesh has any other topology than [`PrimitiveTopology::TriangleList`].\n Panics if the mesh does not have indices defined.", &["_self"], ) .register_documented( "compute_flat_normals", - |mut _self: Mut<::bevy_mesh::Mesh>| { + |mut _self: Mut<::bevy_mesh::prelude::Mesh>| { let output: () = { { - let output: () = ::bevy_mesh::Mesh::compute_flat_normals( + let output: () = ::bevy_mesh::prelude::Mesh::compute_flat_normals( &mut _self, ) .into(); @@ -121,25 +97,27 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "compute_normals", - |mut _self: Mut<::bevy_mesh::Mesh>| { + |mut _self: Mut<::bevy_mesh::prelude::Mesh>| { let output: () = { { - let output: () = ::bevy_mesh::Mesh::compute_normals(&mut _self) + let output: () = ::bevy_mesh::prelude::Mesh::compute_normals( + &mut _self, + ) .into(); output } }; output }, - " Calculates the [`Mesh::ATTRIBUTE_NORMAL`] of a mesh.\n If the mesh is indexed, this defaults to smooth normals. Otherwise, it defaults to flat\n normals.\n # Panics\n Panics if [`Mesh::ATTRIBUTE_POSITION`] is not of type `float3`.\n Panics if the mesh has any other topology than [`PrimitiveTopology::TriangleList`].\n FIXME: This should handle more cases since this is called as a part of gltf\n mesh loading where we can't really blame users for loading meshes that might\n not conform to the limitations here!", + " Calculates the [`Mesh::ATTRIBUTE_NORMAL`] of a mesh.\n If the mesh is indexed, this defaults to smooth normals. Otherwise, it defaults to flat\n normals.\n # Panics\n Panics if [`Mesh::ATTRIBUTE_POSITION`] is not of type `float3`.\n Panics if the mesh has any other topology than [`PrimitiveTopology::TriangleList`].=", &["_self"], ) .register_documented( "compute_smooth_normals", - |mut _self: Mut<::bevy_mesh::Mesh>| { + |mut _self: Mut<::bevy_mesh::prelude::Mesh>| { let output: () = { { - let output: () = ::bevy_mesh::Mesh::compute_smooth_normals( + let output: () = ::bevy_mesh::prelude::Mesh::compute_smooth_normals( &mut _self, ) .into(); @@ -148,15 +126,17 @@ pub(crate) fn register_mesh_functions(world: &mut World) { }; output }, - " Calculates the [`Mesh::ATTRIBUTE_NORMAL`] of an indexed mesh, smoothing normals for shared\n vertices.\n # Panics\n Panics if [`Mesh::ATTRIBUTE_POSITION`] is not of type `float3`.\n Panics if the mesh has any other topology than [`PrimitiveTopology::TriangleList`].\n Panics if the mesh does not have indices defined.\n FIXME: This should handle more cases since this is called as a part of gltf\n mesh loading where we can't really blame users for loading meshes that might\n not conform to the limitations here!", + " Calculates the [`Mesh::ATTRIBUTE_NORMAL`] of an indexed mesh, smoothing normals for shared\n vertices.\n This method weights normals by the angles of the corners of connected triangles, thus\n eliminating triangle area and count as factors in the final normal. This does make it\n somewhat slower than [`Mesh::compute_area_weighted_normals`] which does not need to\n greedily normalize each triangle's normal or calculate corner angles.\n If you would rather have the computed normals be weighted by triangle area, see\n [`Mesh::compute_area_weighted_normals`] instead. If you need to weight them in some other\n way, see [`Mesh::compute_custom_smooth_normals`].\n # Panics\n Panics if [`Mesh::ATTRIBUTE_POSITION`] is not of type `float3`.\n Panics if the mesh has any other topology than [`PrimitiveTopology::TriangleList`].\n Panics if the mesh does not have indices defined.", &["_self"], ) .register_documented( "count_vertices", - |_self: Ref<::bevy_mesh::Mesh>| { + |_self: Ref<::bevy_mesh::prelude::Mesh>| { let output: usize = { { - let output: usize = ::bevy_mesh::Mesh::count_vertices(&_self) + let output: usize = ::bevy_mesh::prelude::Mesh::count_vertices( + &_self, + ) .into(); output } @@ -168,10 +148,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "create_packed_vertex_buffer_data", - |_self: Ref<::bevy_mesh::Mesh>| { + |_self: Ref<::bevy_mesh::prelude::Mesh>| { let output: ::std::vec::Vec = { { - let output: ::std::vec::Vec = ::bevy_mesh::Mesh::create_packed_vertex_buffer_data( + let output: ::std::vec::Vec = ::bevy_mesh::prelude::Mesh::create_packed_vertex_buffer_data( &_self, ) .into(); @@ -185,10 +165,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "duplicate_vertices", - |mut _self: Mut<::bevy_mesh::Mesh>| { + |mut _self: Mut<::bevy_mesh::prelude::Mesh>| { let output: () = { { - let output: () = ::bevy_mesh::Mesh::duplicate_vertices( + let output: () = ::bevy_mesh::prelude::Mesh::duplicate_vertices( &mut _self, ) .into(); @@ -200,12 +180,32 @@ pub(crate) fn register_mesh_functions(world: &mut World) { " Duplicates the vertex attributes so that no vertices are shared.\n This can dramatically increase the vertex count, so make sure this is what you want.\n Does nothing if no [Indices] are set.", &["_self"], ) + .register_documented( + "eq", + | + _self: Ref<::bevy_mesh::prelude::Mesh>, + other: Ref<::bevy_mesh::prelude::Mesh>| + { + let output: bool = { + { + let output: bool = <::bevy_mesh::prelude::Mesh as ::std::cmp::PartialEq< + ::bevy_mesh::prelude::Mesh, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) .register_documented( "get_vertex_buffer_size", - |_self: Ref<::bevy_mesh::Mesh>| { + |_self: Ref<::bevy_mesh::prelude::Mesh>| { let output: usize = { { - let output: usize = ::bevy_mesh::Mesh::get_vertex_buffer_size( + let output: usize = ::bevy_mesh::prelude::Mesh::get_vertex_buffer_size( &_self, ) .into(); @@ -219,10 +219,12 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "get_vertex_size", - |_self: Ref<::bevy_mesh::Mesh>| { + |_self: Ref<::bevy_mesh::prelude::Mesh>| { let output: u64 = { { - let output: u64 = ::bevy_mesh::Mesh::get_vertex_size(&_self) + let output: u64 = ::bevy_mesh::prelude::Mesh::get_vertex_size( + &_self, + ) .into(); output } @@ -234,10 +236,12 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "has_morph_targets", - |_self: Ref<::bevy_mesh::Mesh>| { + |_self: Ref<::bevy_mesh::prelude::Mesh>| { let output: bool = { { - let output: bool = ::bevy_mesh::Mesh::has_morph_targets(&_self) + let output: bool = ::bevy_mesh::prelude::Mesh::has_morph_targets( + &_self, + ) .into(); output } @@ -249,10 +253,13 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "insert_indices", - |mut _self: Mut<::bevy_mesh::Mesh>, indices: Val<::bevy_mesh::Indices>| { + | + mut _self: Mut<::bevy_mesh::prelude::Mesh>, + indices: Val<::bevy_mesh::Indices>| + { let output: () = { { - let output: () = ::bevy_mesh::Mesh::insert_indices( + let output: () = ::bevy_mesh::prelude::Mesh::insert_indices( &mut _self, indices.into_inner(), ) @@ -267,10 +274,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "normalize_joint_weights", - |mut _self: Mut<::bevy_mesh::Mesh>| { + |mut _self: Mut<::bevy_mesh::prelude::Mesh>| { let output: () = { { - let output: () = ::bevy_mesh::Mesh::normalize_joint_weights( + let output: () = ::bevy_mesh::prelude::Mesh::normalize_joint_weights( &mut _self, ) .into(); @@ -284,10 +291,13 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "rotate_by", - |mut _self: Mut<::bevy_mesh::Mesh>, rotation: Val<::bevy_math::Quat>| { + | + mut _self: Mut<::bevy_mesh::prelude::Mesh>, + rotation: Val<::bevy_math::Quat>| + { let output: () = { { - let output: () = ::bevy_mesh::Mesh::rotate_by( + let output: () = ::bevy_mesh::prelude::Mesh::rotate_by( &mut _self, rotation.into_inner(), ) @@ -302,10 +312,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "rotated_by", - |_self: Val<::bevy_mesh::Mesh>, rotation: Val<::bevy_math::Quat>| { - let output: Val<::bevy_mesh::Mesh> = { + |_self: Val<::bevy_mesh::prelude::Mesh>, rotation: Val<::bevy_math::Quat>| { + let output: Val<::bevy_mesh::prelude::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::rotated_by( + let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::rotated_by( _self.into_inner(), rotation.into_inner(), ) @@ -320,10 +330,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "scale_by", - |mut _self: Mut<::bevy_mesh::Mesh>, scale: Val<::bevy_math::Vec3>| { + |mut _self: Mut<::bevy_mesh::prelude::Mesh>, scale: Val<::bevy_math::Vec3>| { let output: () = { { - let output: () = ::bevy_mesh::Mesh::scale_by( + let output: () = ::bevy_mesh::prelude::Mesh::scale_by( &mut _self, scale.into_inner(), ) @@ -338,10 +348,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "scaled_by", - |_self: Val<::bevy_mesh::Mesh>, scale: Val<::bevy_math::Vec3>| { - let output: Val<::bevy_mesh::Mesh> = { + |_self: Val<::bevy_mesh::prelude::Mesh>, scale: Val<::bevy_math::Vec3>| { + let output: Val<::bevy_mesh::prelude::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::scaled_by( + let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::scaled_by( _self.into_inner(), scale.into_inner(), ) @@ -357,12 +367,12 @@ pub(crate) fn register_mesh_functions(world: &mut World) { .register_documented( "set_morph_target_names", | - mut _self: Mut<::bevy_mesh::Mesh>, + mut _self: Mut<::bevy_mesh::prelude::Mesh>, names: ::std::vec::Vec<::std::string::String>| { let output: () = { { - let output: () = ::bevy_mesh::Mesh::set_morph_target_names( + let output: () = ::bevy_mesh::prelude::Mesh::set_morph_target_names( &mut _self, names, ) @@ -378,12 +388,12 @@ pub(crate) fn register_mesh_functions(world: &mut World) { .register_documented( "transform_by", | - mut _self: Mut<::bevy_mesh::Mesh>, + mut _self: Mut<::bevy_mesh::prelude::Mesh>, transform: Val<::bevy_transform::components::Transform>| { let output: () = { { - let output: () = ::bevy_mesh::Mesh::transform_by( + let output: () = ::bevy_mesh::prelude::Mesh::transform_by( &mut _self, transform.into_inner(), ) @@ -399,12 +409,12 @@ pub(crate) fn register_mesh_functions(world: &mut World) { .register_documented( "transformed_by", | - _self: Val<::bevy_mesh::Mesh>, + _self: Val<::bevy_mesh::prelude::Mesh>, transform: Val<::bevy_transform::components::Transform>| { - let output: Val<::bevy_mesh::Mesh> = { + let output: Val<::bevy_mesh::prelude::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::transformed_by( + let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::transformed_by( _self.into_inner(), transform.into_inner(), ) @@ -419,10 +429,13 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "translate_by", - |mut _self: Mut<::bevy_mesh::Mesh>, translation: Val<::bevy_math::Vec3>| { + | + mut _self: Mut<::bevy_mesh::prelude::Mesh>, + translation: Val<::bevy_math::Vec3>| + { let output: () = { { - let output: () = ::bevy_mesh::Mesh::translate_by( + let output: () = ::bevy_mesh::prelude::Mesh::translate_by( &mut _self, translation.into_inner(), ) @@ -437,10 +450,13 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "translated_by", - |_self: Val<::bevy_mesh::Mesh>, translation: Val<::bevy_math::Vec3>| { - let output: Val<::bevy_mesh::Mesh> = { + | + _self: Val<::bevy_mesh::prelude::Mesh>, + translation: Val<::bevy_math::Vec3>| + { + let output: Val<::bevy_mesh::prelude::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::translated_by( + let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::translated_by( _self.into_inner(), translation.into_inner(), ) @@ -453,12 +469,29 @@ pub(crate) fn register_mesh_functions(world: &mut World) { " Translates the vertex positions of the mesh by the given [`Vec3`].\n `Aabb` of entities with modified mesh are not updated automatically.", &["_self", "translation"], ) + .register_documented( + "with_computed_area_weighted_normals", + |_self: Val<::bevy_mesh::prelude::Mesh>| { + let output: Val<::bevy_mesh::prelude::Mesh> = { + { + let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::with_computed_area_weighted_normals( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Consumes the mesh and returns a mesh with calculated [`Mesh::ATTRIBUTE_NORMAL`].\n (Alternatively, you can use [`Mesh::compute_area_weighted_normals`] to mutate an existing mesh in-place)\n This method weights normals by the area of each triangle containing the vertex. Thus,\n larger triangles will skew the normals of their vertices towards their own normal more\n than smaller triangles will. If you would rather have the computed normals be influenced\n only by the angles of connected edges, see [`Mesh::with_computed_smooth_normals`] instead.\n # Panics\n Panics if [`Mesh::ATTRIBUTE_POSITION`] is not of type `float3`.\n Panics if the mesh has any other topology than [`PrimitiveTopology::TriangleList`].\n Panics if the mesh does not have indices defined.", + &["_self"], + ) .register_documented( "with_computed_flat_normals", - |_self: Val<::bevy_mesh::Mesh>| { - let output: Val<::bevy_mesh::Mesh> = { + |_self: Val<::bevy_mesh::prelude::Mesh>| { + let output: Val<::bevy_mesh::prelude::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::with_computed_flat_normals( + let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::with_computed_flat_normals( _self.into_inner(), ) .into(); @@ -472,10 +505,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "with_computed_normals", - |_self: Val<::bevy_mesh::Mesh>| { - let output: Val<::bevy_mesh::Mesh> = { + |_self: Val<::bevy_mesh::prelude::Mesh>| { + let output: Val<::bevy_mesh::prelude::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::with_computed_normals( + let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::with_computed_normals( _self.into_inner(), ) .into(); @@ -489,10 +522,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "with_computed_smooth_normals", - |_self: Val<::bevy_mesh::Mesh>| { - let output: Val<::bevy_mesh::Mesh> = { + |_self: Val<::bevy_mesh::prelude::Mesh>| { + let output: Val<::bevy_mesh::prelude::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::with_computed_smooth_normals( + let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::with_computed_smooth_normals( _self.into_inner(), ) .into(); @@ -501,15 +534,15 @@ pub(crate) fn register_mesh_functions(world: &mut World) { }; output }, - " Consumes the mesh and returns a mesh with calculated [`Mesh::ATTRIBUTE_NORMAL`].\n (Alternatively, you can use [`Mesh::compute_smooth_normals`] to mutate an existing mesh in-place)\n # Panics\n Panics if [`Mesh::ATTRIBUTE_POSITION`] is not of type `float3`.\n Panics if the mesh has any other topology than [`PrimitiveTopology::TriangleList`].\n Panics if the mesh does not have indices defined.", + " Consumes the mesh and returns a mesh with calculated [`Mesh::ATTRIBUTE_NORMAL`].\n (Alternatively, you can use [`Mesh::compute_smooth_normals`] to mutate an existing mesh in-place)\n This method weights normals by the angles of triangle corners connected to each vertex. If\n you would rather have the computed normals be weighted by triangle area, see\n [`Mesh::with_computed_area_weighted_normals`] instead.\n # Panics\n Panics if [`Mesh::ATTRIBUTE_POSITION`] is not of type `float3`.\n Panics if the mesh has any other topology than [`PrimitiveTopology::TriangleList`].\n Panics if the mesh does not have indices defined.", &["_self"], ) .register_documented( "with_duplicated_vertices", - |_self: Val<::bevy_mesh::Mesh>| { - let output: Val<::bevy_mesh::Mesh> = { + |_self: Val<::bevy_mesh::prelude::Mesh>| { + let output: Val<::bevy_mesh::prelude::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::with_duplicated_vertices( + let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::with_duplicated_vertices( _self.into_inner(), ) .into(); @@ -523,10 +556,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "with_inserted_indices", - |_self: Val<::bevy_mesh::Mesh>, indices: Val<::bevy_mesh::Indices>| { - let output: Val<::bevy_mesh::Mesh> = { + |_self: Val<::bevy_mesh::prelude::Mesh>, indices: Val<::bevy_mesh::Indices>| { + let output: Val<::bevy_mesh::prelude::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::with_inserted_indices( + let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::with_inserted_indices( _self.into_inner(), indices.into_inner(), ) @@ -542,12 +575,12 @@ pub(crate) fn register_mesh_functions(world: &mut World) { .register_documented( "with_morph_target_names", | - _self: Val<::bevy_mesh::Mesh>, + _self: Val<::bevy_mesh::prelude::Mesh>, names: ::std::vec::Vec<::std::string::String>| { - let output: Val<::bevy_mesh::Mesh> = { + let output: Val<::bevy_mesh::prelude::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::with_morph_target_names( + let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::with_morph_target_names( _self.into_inner(), names, ) @@ -562,10 +595,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "with_removed_indices", - |_self: Val<::bevy_mesh::Mesh>| { - let output: Val<::bevy_mesh::Mesh> = { + |_self: Val<::bevy_mesh::prelude::Mesh>| { + let output: Val<::bevy_mesh::prelude::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::with_removed_indices( + let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::with_removed_indices( _self.into_inner(), ) .into(); @@ -580,36 +613,289 @@ pub(crate) fn register_mesh_functions(world: &mut World) { let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::bevy_mesh::Mesh, bevy_mod_scripting_bindings::MarkAsGenerated>(); + .register_type_data::< + ::bevy_mesh::prelude::Mesh, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } -pub(crate) fn register_morph_weights_functions(world: &mut World) { +pub(crate) fn register_mesh_2_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::morph::MorphWeights, + ::bevy_mesh::prelude::Mesh2d, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_mesh::morph::MorphWeights>| { - let output: Val<::bevy_mesh::morph::MorphWeights> = { - { - let output: Val<::bevy_mesh::morph::MorphWeights> = - <::bevy_mesh::morph::MorphWeights as ::std::clone::Clone>::clone(&_self) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_mesh::prelude::Mesh2d>| { + let output: () = { + { + let output: () = <::bevy_mesh::prelude::Mesh2d as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_mesh::prelude::Mesh2d>| { + let output: Val<::bevy_mesh::prelude::Mesh2d> = { + { + let output: Val<::bevy_mesh::prelude::Mesh2d> = <::bevy_mesh::prelude::Mesh2d as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_mesh::prelude::Mesh2d>, + other: Ref<::bevy_mesh::prelude::Mesh2d>| + { + let output: bool = { + { + let output: bool = <::bevy_mesh::prelude::Mesh2d as ::std::cmp::PartialEq< + ::bevy_mesh::prelude::Mesh2d, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::morph::MorphWeights, + ::bevy_mesh::prelude::Mesh2d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_mesh_3_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_mesh::prelude::Mesh3d, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_mesh::prelude::Mesh3d>| { + let output: () = { + { + let output: () = <::bevy_mesh::prelude::Mesh3d as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_mesh::prelude::Mesh3d>| { + let output: Val<::bevy_mesh::prelude::Mesh3d> = { + { + let output: Val<::bevy_mesh::prelude::Mesh3d> = <::bevy_mesh::prelude::Mesh3d as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_mesh::prelude::Mesh3d>, + other: Ref<::bevy_mesh::prelude::Mesh3d>| + { + let output: bool = { + { + let output: bool = <::bevy_mesh::prelude::Mesh3d as ::std::cmp::PartialEq< + ::bevy_mesh::prelude::Mesh3d, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_mesh::prelude::Mesh3d, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } +pub(crate) fn register_mesh_tag_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_mesh::MeshTag, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_mesh::MeshTag>| { + let output: () = { + { + let output: () = <::bevy_mesh::MeshTag as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_mesh::MeshTag>| { + let output: Val<::bevy_mesh::MeshTag> = { + { + let output: Val<::bevy_mesh::MeshTag> = <::bevy_mesh::MeshTag as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_mesh::MeshTag>, other: Ref<::bevy_mesh::MeshTag>| { + let output: bool = { + { + let output: bool = <::bevy_mesh::MeshTag as ::std::cmp::PartialEq< + ::bevy_mesh::MeshTag, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::<::bevy_mesh::MeshTag, bevy_mod_scripting_bindings::MarkAsGenerated>(); +} +pub(crate) fn register_indices_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_mesh::Indices, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_mesh::Indices>| { + let output: Val<::bevy_mesh::Indices> = { + { + let output: Val<::bevy_mesh::Indices> = <::bevy_mesh::Indices as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_mesh::Indices>, other: Ref<::bevy_mesh::Indices>| { + let output: bool = { + { + let output: bool = <::bevy_mesh::Indices as ::std::cmp::PartialEq< + ::bevy_mesh::Indices, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "is_empty", + |_self: Ref<::bevy_mesh::Indices>| { + let output: bool = { + { + let output: bool = ::bevy_mesh::Indices::is_empty(&_self).into(); + output + } + }; + output + }, + " Returns `true` if there are no indices.", + &["_self"], + ) + .register_documented( + "len", + |_self: Ref<::bevy_mesh::Indices>| { + let output: usize = { + { + let output: usize = ::bevy_mesh::Indices::len(&_self).into(); + output + } + }; + output + }, + " Returns the number of indices.", + &["_self"], + ) + .register_documented( + "push", + |mut _self: Mut<::bevy_mesh::Indices>, index: u32| { + let output: () = { + { + let output: () = ::bevy_mesh::Indices::push(&mut _self, index) + .into(); + output + } + }; + output + }, + " Add an index. If the index is greater than `u16::MAX`,\n the storage will be converted to `u32`.", + &["_self", "index"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::<::bevy_mesh::Indices, bevy_mod_scripting_bindings::MarkAsGenerated>(); +} pub(crate) fn register_mesh_morph_weights_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_mesh::morph::MeshMorphWeights, @@ -960,6 +1246,37 @@ pub(crate) fn register_circular_segment_mesh_builder_functions(world: &mut World bevy_mod_scripting_bindings::MarkAsGenerated, >(); } +pub(crate) fn register_convex_polygon_mesh_builder_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_mesh::primitives::ConvexPolygonMeshBuilder, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_mesh::primitives::ConvexPolygonMeshBuilder>| { + let output: Val<::bevy_mesh::primitives::ConvexPolygonMeshBuilder> = { + { + let output: Val< + ::bevy_mesh::primitives::ConvexPolygonMeshBuilder, + > = <::bevy_mesh::primitives::ConvexPolygonMeshBuilder as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_mesh::primitives::ConvexPolygonMeshBuilder, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} pub(crate) fn register_regular_polygon_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_mesh::primitives::RegularPolygonMeshBuilder, @@ -1077,6 +1394,37 @@ pub(crate) fn register_ellipse_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } +pub(crate) fn register_polyline_2_d_mesh_builder_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_mesh::primitives::Polyline2dMeshBuilder, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_mesh::primitives::Polyline2dMeshBuilder>| { + let output: Val<::bevy_mesh::primitives::Polyline2dMeshBuilder> = { + { + let output: Val< + ::bevy_mesh::primitives::Polyline2dMeshBuilder, + > = <::bevy_mesh::primitives::Polyline2dMeshBuilder as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_mesh::primitives::Polyline2dMeshBuilder, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} pub(crate) fn register_annulus_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_mesh::primitives::AnnulusMeshBuilder, @@ -2052,6 +2400,68 @@ pub(crate) fn register_plane_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } +pub(crate) fn register_polyline_3_d_mesh_builder_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::primitives::dim3::polyline3d::Polyline3dMeshBuilder, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::primitives::dim3::polyline3d::Polyline3dMeshBuilder>| { + let output: Val<::primitives::dim3::polyline3d::Polyline3dMeshBuilder> = { + { + let output: Val< + ::primitives::dim3::polyline3d::Polyline3dMeshBuilder, + > = <::primitives::dim3::polyline3d::Polyline3dMeshBuilder as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::primitives::dim3::polyline3d::Polyline3dMeshBuilder, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_segment_3_d_mesh_builder_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::primitives::dim3::segment3d::Segment3dMeshBuilder, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::primitives::dim3::segment3d::Segment3dMeshBuilder>| { + let output: Val<::primitives::dim3::segment3d::Segment3dMeshBuilder> = { + { + let output: Val< + ::primitives::dim3::segment3d::Segment3dMeshBuilder, + > = <::primitives::dim3::segment3d::Segment3dMeshBuilder as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::primitives::dim3::segment3d::Segment3dMeshBuilder, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} pub(crate) fn register_sphere_kind_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_mesh::primitives::SphereKind, @@ -2147,9 +2557,9 @@ pub(crate) fn register_sphere_mesh_builder_functions(world: &mut World) { sectors: u32, stacks: u32| { - let output: Val<::bevy_mesh::Mesh> = { + let output: Val<::bevy_mesh::prelude::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::primitives::SphereMeshBuilder::uv( + let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::primitives::SphereMeshBuilder::uv( &_self, sectors, stacks, @@ -2347,16 +2757,21 @@ pub(crate) fn register_skinned_mesh_functions(world: &mut World) { impl Plugin for BevyMeshScriptingPlugin { fn build(&self, app: &mut App) { let mut world = app.world_mut(); - register_indices_functions(&mut world); - register_mesh_functions(&mut world); register_morph_weights_functions(&mut world); + register_mesh_functions(&mut world); + register_mesh_2_d_functions(&mut world); + register_mesh_3_d_functions(&mut world); + register_mesh_tag_functions(&mut world); + register_indices_functions(&mut world); register_mesh_morph_weights_functions(&mut world); register_circle_mesh_builder_functions(&mut world); register_circular_mesh_uv_mode_functions(&mut world); register_circular_sector_mesh_builder_functions(&mut world); register_circular_segment_mesh_builder_functions(&mut world); + register_convex_polygon_mesh_builder_functions(&mut world); register_regular_polygon_mesh_builder_functions(&mut world); register_ellipse_mesh_builder_functions(&mut world); + register_polyline_2_d_mesh_builder_functions(&mut world); register_annulus_mesh_builder_functions(&mut world); register_rhombus_mesh_builder_functions(&mut world); register_triangle_2_d_mesh_builder_functions(&mut world); @@ -2371,6 +2786,8 @@ impl Plugin for BevyMeshScriptingPlugin { register_cylinder_anchor_functions(&mut world); register_cylinder_mesh_builder_functions(&mut world); register_plane_mesh_builder_functions(&mut world); + register_polyline_3_d_mesh_builder_functions(&mut world); + register_segment_3_d_mesh_builder_functions(&mut world); register_sphere_kind_functions(&mut world); register_sphere_mesh_builder_functions(&mut world); register_tetrahedron_mesh_builder_functions(&mut world); diff --git a/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml b/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml index 0f7eea19bd..0fe487789d 100644 --- a/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml @@ -17,51 +17,53 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_pbr = { version = "0.16.1", features = ["webgl"], default-features = true } +bevy_pbr = { version = "0.17.2", features = ["webgl"], default-features = true} -bevy_app = { version = "^0.16.1", features = [], default-features = true } +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} -bevy_asset = { version = "^0.16.1", features = [], default-features = true } +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} -bevy_color = { version = "^0.16.2", features = [], default-features = true } +bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_core_pipeline = { version = "^0.16.1", features = [ -], default-features = true } +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} -bevy_derive = { version = "^0.16.1", features = [], default-features = true } +bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} -bevy_diagnostic = { version = "^0.16.1", features = [ -], default-features = true } +bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.16.1", features = [], default-features = true } +bevy_diagnostic = { version = "^0.17.2", features = ["std", "sysinfo", "sysinfo_plugin"], default-features = true} -bevy_image = { version = "^0.16.1", features = [], default-features = true } +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_math = { version = "^0.16.1", features = [], default-features = true } +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} -bevy_reflect = { version = "^0.16.1", features = [], default-features = true } +bevy_light = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_render = { version = "^0.16.1", features = [], default-features = true } +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} -bevy_transform = { version = "^0.16.1", features = [], default-features = true } +bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_utils = { version = "^0.16.1", features = [], default-features = true } +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_window = { version = "^0.16.1", features = [], default-features = true } +bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} -bitflags = { version = "^2.3", features = [], default-features = true } +bevy_shader = { version = "^0.17.2", features = [], default-features = true} -bytemuck = { version = "^1", features = [], default-features = true } +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -fixedbitset = { version = "^0.5", features = [], default-features = true } +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} -nonmax = { version = "^0.5", features = [], default-features = true } +bitflags = { version = "^2.3", features = [], default-features = true} -offset-allocator = { version = "^0.2", features = [], default-features = true } +bytemuck = { version = "^1", features = [], default-features = true} -radsort = { version = "^0.1", features = [], default-features = true } +fixedbitset = { version = "^0.5", features = [], default-features = true} + +nonmax = { version = "^0.5", features = [], default-features = true} + +offset-allocator = { version = "^0.2", features = [], default-features = true} + +static_assertions = { version = "^1", features = [], default-features = true} -smallvec = { version = "^1.6", features = [], default-features = true } -static_assertions = { version = "^1", features = [], default-features = true } diff --git a/crates/bindings/bevy_pbr_bms_bindings/src/lib.rs b/crates/bindings/bevy_pbr_bms_bindings/src/lib.rs index efcc781654..e15c7d247f 100644 --- a/crates/bindings/bevy_pbr_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_pbr_bms_bindings/src/lib.rs @@ -12,91 +12,6 @@ use bevy_mod_scripting_bindings::{ }; use bevy_mod_scripting_derive::script_bindings; pub struct BevyPbrScriptingPlugin; -pub(crate) fn register_fog_volume_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::FogVolume, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::FogVolume>| { - let output: Val<::bevy_pbr::FogVolume> = { - { - let output: Val<::bevy_pbr::FogVolume> = <::bevy_pbr::FogVolume as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::<::bevy_pbr::FogVolume, bevy_mod_scripting_bindings::MarkAsGenerated>( - ); -} -pub(crate) fn register_volumetric_fog_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::VolumetricFog, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::VolumetricFog>| { - let output: Val<::bevy_pbr::VolumetricFog> = { - { - let output: Val<::bevy_pbr::VolumetricFog> = <::bevy_pbr::VolumetricFog as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_pbr::VolumetricFog, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_volumetric_light_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::VolumetricLight, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::VolumetricLight>| { - let output: Val<::bevy_pbr::VolumetricLight> = { - { - let output: Val<::bevy_pbr::VolumetricLight> = <::bevy_pbr::VolumetricLight as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_pbr::VolumetricLight, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} pub(crate) fn register_distance_fog_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_pbr::prelude::DistanceFog, @@ -336,193 +251,6 @@ pub(crate) fn register_fog_falloff_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_ambient_light_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::prelude::AmbientLight, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::prelude::AmbientLight>| { - let output: Val<::bevy_pbr::prelude::AmbientLight> = { - { - let output: Val<::bevy_pbr::prelude::AmbientLight> = - <::bevy_pbr::prelude::AmbientLight as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_pbr::prelude::AmbientLight, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_directional_light_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::prelude::DirectionalLight, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::prelude::DirectionalLight>| { - let output: Val<::bevy_pbr::prelude::DirectionalLight> = { - { - let output: Val<::bevy_pbr::prelude::DirectionalLight> = - <::bevy_pbr::prelude::DirectionalLight as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_pbr::prelude::DirectionalLight, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_point_light_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::prelude::PointLight, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::prelude::PointLight>| { - let output: Val<::bevy_pbr::prelude::PointLight> = { - { - let output: Val<::bevy_pbr::prelude::PointLight> = - <::bevy_pbr::prelude::PointLight as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_pbr::prelude::PointLight, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_spot_light_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::prelude::SpotLight, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::prelude::SpotLight>| { - let output: Val<::bevy_pbr::prelude::SpotLight> = { - { - let output: Val<::bevy_pbr::prelude::SpotLight> = - <::bevy_pbr::prelude::SpotLight as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_pbr::prelude::SpotLight, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_environment_map_light_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::prelude::EnvironmentMapLight, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::prelude::EnvironmentMapLight>| { - let output: Val<::bevy_pbr::prelude::EnvironmentMapLight> = { - { - let output: Val<::bevy_pbr::prelude::EnvironmentMapLight> = - <::bevy_pbr::prelude::EnvironmentMapLight as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_pbr::prelude::EnvironmentMapLight, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_light_probe_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::prelude::LightProbe, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::prelude::LightProbe>| { - let output: Val<::bevy_pbr::prelude::LightProbe> = { - { - let output: Val<::bevy_pbr::prelude::LightProbe> = - <::bevy_pbr::prelude::LightProbe as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "new", - || { - let output: Val<::bevy_pbr::prelude::LightProbe> = { - { - let output: Val<::bevy_pbr::prelude::LightProbe> = - ::bevy_pbr::prelude::LightProbe::new().into(); - output - } - }; - output - }, - " Creates a new light probe component.", - &[], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_pbr::prelude::LightProbe, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} pub(crate) fn register_parallax_mapping_method_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_pbr::prelude::ParallaxMappingMethod, @@ -701,352 +429,37 @@ pub(crate) fn register_screen_space_ambient_occlusion_functions(world: &mut Worl ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_pbr::ScreenSpaceAmbientOcclusion, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_screen_space_reflections_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::ScreenSpaceReflections, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::ScreenSpaceReflections>| { - let output: Val<::bevy_pbr::ScreenSpaceReflections> = { - { - let output: Val<::bevy_pbr::ScreenSpaceReflections> = - <::bevy_pbr::ScreenSpaceReflections as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_pbr::ScreenSpaceReflections, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_cascade_shadow_config_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::CascadeShadowConfig, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::CascadeShadowConfig>| { - let output: Val<::bevy_pbr::CascadeShadowConfig> = { - { - let output: Val<::bevy_pbr::CascadeShadowConfig> = - <::bevy_pbr::CascadeShadowConfig as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_pbr::CascadeShadowConfig, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_cascades_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::Cascades, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::Cascades>| { - let output: Val<::bevy_pbr::Cascades> = { - { - let output: Val<::bevy_pbr::Cascades> = <::bevy_pbr::Cascades as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::<::bevy_pbr::Cascades, bevy_mod_scripting_bindings::MarkAsGenerated>(); -} -pub(crate) fn register_cascades_visible_entities_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::CascadesVisibleEntities, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::CascadesVisibleEntities>| { - let output: Val<::bevy_pbr::CascadesVisibleEntities> = { - { - let output: Val<::bevy_pbr::CascadesVisibleEntities> = - <::bevy_pbr::CascadesVisibleEntities as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_pbr::CascadesVisibleEntities, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_visible_mesh_entities_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::VisibleMeshEntities, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::VisibleMeshEntities>| { - let output: Val<::bevy_pbr::VisibleMeshEntities> = { - { - let output: Val<::bevy_pbr::VisibleMeshEntities> = - <::bevy_pbr::VisibleMeshEntities as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_pbr::VisibleMeshEntities, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_cluster_config_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::ClusterConfig, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::ClusterConfig>| { - let output: Val<::bevy_pbr::ClusterConfig> = { - { - let output: Val<::bevy_pbr::ClusterConfig> = <::bevy_pbr::ClusterConfig as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_pbr::ClusterConfig, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_cubemap_visible_entities_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::CubemapVisibleEntities, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::CubemapVisibleEntities>| { - let output: Val<::bevy_pbr::CubemapVisibleEntities> = { - { - let output: Val<::bevy_pbr::CubemapVisibleEntities> = - <::bevy_pbr::CubemapVisibleEntities as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_pbr::CubemapVisibleEntities, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_directional_light_shadow_map_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::DirectionalLightShadowMap, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::DirectionalLightShadowMap>| { - let output: Val<::bevy_pbr::DirectionalLightShadowMap> = { - { - let output: Val<::bevy_pbr::DirectionalLightShadowMap> = - <::bevy_pbr::DirectionalLightShadowMap as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_pbr::DirectionalLightShadowMap, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_not_shadow_caster_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::NotShadowCaster, - >::new(world); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_pbr::NotShadowCaster, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_not_shadow_receiver_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::NotShadowReceiver, - >::new(world); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_pbr::NotShadowReceiver, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_point_light_shadow_map_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::PointLightShadowMap, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::PointLightShadowMap>| { - let output: Val<::bevy_pbr::PointLightShadowMap> = { - { - let output: Val<::bevy_pbr::PointLightShadowMap> = - <::bevy_pbr::PointLightShadowMap as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_pbr::PointLightShadowMap, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_shadow_filtering_method_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::ShadowFilteringMethod, - >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_pbr::ShadowFilteringMethod>| { - let output: () = { - { - let output: () = <::bevy_pbr::ShadowFilteringMethod as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::ShadowFilteringMethod>| { - let output: Val<::bevy_pbr::ShadowFilteringMethod> = { - { - let output: Val<::bevy_pbr::ShadowFilteringMethod> = <::bevy_pbr::ShadowFilteringMethod as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_pbr::ShadowFilteringMethod>, - other: Ref<::bevy_pbr::ShadowFilteringMethod>| - { - let output: bool = { - { - let output: bool = <::bevy_pbr::ShadowFilteringMethod as ::std::cmp::PartialEq< - ::bevy_pbr::ShadowFilteringMethod, - >>::eq(&_self, &other) + registry + .register_type_data::< + ::bevy_pbr::ScreenSpaceAmbientOcclusion, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_screen_space_reflections_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_pbr::ScreenSpaceReflections, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_pbr::ScreenSpaceReflections>| { + let output: Val<::bevy_pbr::ScreenSpaceReflections> = { + { + let output: Val<::bevy_pbr::ScreenSpaceReflections> = + <::bevy_pbr::ScreenSpaceReflections as ::std::clone::Clone>::clone(&_self) .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_pbr::ShadowFilteringMethod, + ::bevy_pbr::ScreenSpaceReflections, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -1170,16 +583,46 @@ pub(crate) fn register_wireframe_material_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_no_wireframe_functions(world: &mut World) { +pub(crate) fn register_wireframe_config_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::wireframe::NoWireframe, + ::bevy_pbr::wireframe::WireframeConfig, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_pbr::wireframe::WireframeConfig>| { + let output: Val<::bevy_pbr::wireframe::WireframeConfig> = { + { + let output: Val<::bevy_pbr::wireframe::WireframeConfig> = + <::bevy_pbr::wireframe::WireframeConfig as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_pbr::wireframe::WireframeConfig, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_wireframe_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_pbr::wireframe::Wireframe, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_pbr::wireframe::NoWireframe>| { + |_self: Ref<::bevy_pbr::wireframe::Wireframe>| { let output: () = { { - let output: () = <::bevy_pbr::wireframe::NoWireframe as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_pbr::wireframe::Wireframe as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -1193,10 +636,10 @@ pub(crate) fn register_no_wireframe_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_pbr::wireframe::NoWireframe>| { - let output: Val<::bevy_pbr::wireframe::NoWireframe> = { + |_self: Ref<::bevy_pbr::wireframe::Wireframe>| { + let output: Val<::bevy_pbr::wireframe::Wireframe> = { { - let output: Val<::bevy_pbr::wireframe::NoWireframe> = <::bevy_pbr::wireframe::NoWireframe as ::std::clone::Clone>::clone( + let output: Val<::bevy_pbr::wireframe::Wireframe> = <::bevy_pbr::wireframe::Wireframe as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1211,13 +654,13 @@ pub(crate) fn register_no_wireframe_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_pbr::wireframe::NoWireframe>, - other: Ref<::bevy_pbr::wireframe::NoWireframe>| + _self: Ref<::bevy_pbr::wireframe::Wireframe>, + other: Ref<::bevy_pbr::wireframe::Wireframe>| { let output: bool = { { - let output: bool = <::bevy_pbr::wireframe::NoWireframe as ::std::cmp::PartialEq< - ::bevy_pbr::wireframe::NoWireframe, + let output: bool = <::bevy_pbr::wireframe::Wireframe as ::std::cmp::PartialEq< + ::bevy_pbr::wireframe::Wireframe, >>::eq(&_self, &other) .into(); output @@ -1232,37 +675,7 @@ pub(crate) fn register_no_wireframe_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_pbr::wireframe::NoWireframe, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_wireframe_config_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::wireframe::WireframeConfig, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::wireframe::WireframeConfig>| { - let output: Val<::bevy_pbr::wireframe::WireframeConfig> = { - { - let output: Val<::bevy_pbr::wireframe::WireframeConfig> = - <::bevy_pbr::wireframe::WireframeConfig as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_pbr::wireframe::WireframeConfig, + ::bevy_pbr::wireframe::Wireframe, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -1296,16 +709,16 @@ pub(crate) fn register_wireframe_color_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_wireframe_functions(world: &mut World) { +pub(crate) fn register_no_wireframe_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::wireframe::Wireframe, + ::bevy_pbr::wireframe::NoWireframe, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_pbr::wireframe::Wireframe>| { + |_self: Ref<::bevy_pbr::wireframe::NoWireframe>| { let output: () = { { - let output: () = <::bevy_pbr::wireframe::Wireframe as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_pbr::wireframe::NoWireframe as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -1319,10 +732,10 @@ pub(crate) fn register_wireframe_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_pbr::wireframe::Wireframe>| { - let output: Val<::bevy_pbr::wireframe::Wireframe> = { + |_self: Ref<::bevy_pbr::wireframe::NoWireframe>| { + let output: Val<::bevy_pbr::wireframe::NoWireframe> = { { - let output: Val<::bevy_pbr::wireframe::Wireframe> = <::bevy_pbr::wireframe::Wireframe as ::std::clone::Clone>::clone( + let output: Val<::bevy_pbr::wireframe::NoWireframe> = <::bevy_pbr::wireframe::NoWireframe as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1337,13 +750,13 @@ pub(crate) fn register_wireframe_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_pbr::wireframe::Wireframe>, - other: Ref<::bevy_pbr::wireframe::Wireframe>| + _self: Ref<::bevy_pbr::wireframe::NoWireframe>, + other: Ref<::bevy_pbr::wireframe::NoWireframe>| { let output: bool = { { - let output: bool = <::bevy_pbr::wireframe::Wireframe as ::std::cmp::PartialEq< - ::bevy_pbr::wireframe::Wireframe, + let output: bool = <::bevy_pbr::wireframe::NoWireframe as ::std::cmp::PartialEq< + ::bevy_pbr::wireframe::NoWireframe, >>::eq(&_self, &other) .into(); output @@ -1358,7 +771,7 @@ pub(crate) fn register_wireframe_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_pbr::wireframe::Wireframe, + ::bevy_pbr::wireframe::NoWireframe, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -1473,17 +886,17 @@ pub(crate) fn register_atmosphere_functions(world: &mut World) { .register_type_data::<::bevy_pbr::Atmosphere, bevy_mod_scripting_bindings::MarkAsGenerated>( ); } -pub(crate) fn register_atmosphere_settings_functions(world: &mut World) { +pub(crate) fn register_gpu_atmosphere_settings_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::AtmosphereSettings, + ::bevy_pbr::GpuAtmosphereSettings, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_pbr::AtmosphereSettings>| { - let output: Val<::bevy_pbr::AtmosphereSettings> = { + |_self: Ref<::bevy_pbr::GpuAtmosphereSettings>| { + let output: Val<::bevy_pbr::GpuAtmosphereSettings> = { { - let output: Val<::bevy_pbr::AtmosphereSettings> = - <::bevy_pbr::AtmosphereSettings as ::std::clone::Clone>::clone(&_self) + let output: Val<::bevy_pbr::GpuAtmosphereSettings> = + <::bevy_pbr::GpuAtmosphereSettings as ::std::clone::Clone>::clone(&_self) .into(); output } @@ -1497,109 +910,48 @@ pub(crate) fn register_atmosphere_settings_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_pbr::AtmosphereSettings, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_cluster_far_z_mode_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::ClusterFarZMode, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::ClusterFarZMode>| { - let output: Val<::bevy_pbr::ClusterFarZMode> = { - { - let output: Val<::bevy_pbr::ClusterFarZMode> = <::bevy_pbr::ClusterFarZMode as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_pbr::ClusterFarZMode, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_cluster_z_config_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::ClusterZConfig, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::ClusterZConfig>| { - let output: Val<::bevy_pbr::ClusterZConfig> = { - { - let output: Val<::bevy_pbr::ClusterZConfig> = <::bevy_pbr::ClusterZConfig as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_pbr::ClusterZConfig, + ::bevy_pbr::GpuAtmosphereSettings, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_clustered_decal_functions(world: &mut World) { +pub(crate) fn register_atmosphere_settings_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::decal::clustered::ClusteredDecal, + ::bevy_pbr::AtmosphereSettings, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::decal::clustered::ClusteredDecal>| { - let output: Val<::bevy_pbr::decal::clustered::ClusteredDecal> = { - { - let output: Val<::bevy_pbr::decal::clustered::ClusteredDecal> = <::bevy_pbr::decal::clustered::ClusteredDecal as ::std::clone::Clone>::clone( - &_self, - ) + .register_documented( + "clone", + |_self: Ref<::bevy_pbr::AtmosphereSettings>| { + let output: Val<::bevy_pbr::AtmosphereSettings> = { + { + let output: Val<::bevy_pbr::AtmosphereSettings> = + <::bevy_pbr::AtmosphereSettings as ::std::clone::Clone>::clone(&_self) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_pbr::decal::clustered::ClusteredDecal, + ::bevy_pbr::AtmosphereSettings, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_irradiance_volume_functions(world: &mut World) { +pub(crate) fn register_atmosphere_mode_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::irradiance_volume::IrradianceVolume, + ::bevy_pbr::AtmosphereMode, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_pbr::irradiance_volume::IrradianceVolume>| { - let output: Val<::bevy_pbr::irradiance_volume::IrradianceVolume> = { + |_self: Ref<::bevy_pbr::AtmosphereMode>| { + let output: Val<::bevy_pbr::AtmosphereMode> = { { - let output: Val< - ::bevy_pbr::irradiance_volume::IrradianceVolume, - > = <::bevy_pbr::irradiance_volume::IrradianceVolume as ::std::clone::Clone>::clone( + let output: Val<::bevy_pbr::AtmosphereMode> = <::bevy_pbr::AtmosphereMode as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1615,7 +967,7 @@ pub(crate) fn register_irradiance_volume_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_pbr::irradiance_volume::IrradianceVolume, + ::bevy_pbr::AtmosphereMode, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -1768,42 +1120,6 @@ pub(crate) fn register_opaque_renderer_method_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_cascade_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<::bevy_pbr::Cascade>::new( - world, - ) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::Cascade>| { - let output: Val<::bevy_pbr::Cascade> = { - { - let output: Val<::bevy_pbr::Cascade> = - <::bevy_pbr::Cascade as ::std::clone::Clone>::clone(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::<::bevy_pbr::Cascade, bevy_mod_scripting_bindings::MarkAsGenerated>(); -} -pub(crate) fn register_transmitted_shadow_receiver_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::TransmittedShadowReceiver, - >::new(world); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_pbr::TransmittedShadowReceiver, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} pub(crate) fn register_lightmap_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_pbr::Lightmap, @@ -2103,52 +1419,28 @@ pub(crate) fn register_screen_space_ambient_occlusion_quality_level_functions(wo impl Plugin for BevyPbrScriptingPlugin { fn build(&self, app: &mut App) { let mut world = app.world_mut(); - register_fog_volume_functions(&mut world); - register_volumetric_fog_functions(&mut world); - register_volumetric_light_functions(&mut world); register_distance_fog_functions(&mut world); register_fog_falloff_functions(&mut world); - register_ambient_light_functions(&mut world); - register_directional_light_functions(&mut world); - register_point_light_functions(&mut world); - register_spot_light_functions(&mut world); - register_environment_map_light_functions(&mut world); - register_light_probe_functions(&mut world); register_parallax_mapping_method_functions(&mut world); register_standard_material_functions(&mut world); register_screen_space_ambient_occlusion_functions(&mut world); register_screen_space_reflections_functions(&mut world); - register_cascade_shadow_config_functions(&mut world); - register_cascades_functions(&mut world); - register_cascades_visible_entities_functions(&mut world); - register_visible_mesh_entities_functions(&mut world); - register_cluster_config_functions(&mut world); - register_cubemap_visible_entities_functions(&mut world); - register_directional_light_shadow_map_functions(&mut world); - register_not_shadow_caster_functions(&mut world); - register_not_shadow_receiver_functions(&mut world); - register_point_light_shadow_map_functions(&mut world); - register_shadow_filtering_method_functions(&mut world); register_default_opaque_renderer_method_functions(&mut world); register_wireframe_material_functions(&mut world); - register_no_wireframe_functions(&mut world); register_wireframe_config_functions(&mut world); - register_wireframe_color_functions(&mut world); register_wireframe_functions(&mut world); + register_wireframe_color_functions(&mut world); + register_no_wireframe_functions(&mut world); register_mesh_3_d_wireframe_functions(&mut world); register_atmosphere_functions(&mut world); + register_gpu_atmosphere_settings_functions(&mut world); register_atmosphere_settings_functions(&mut world); - register_cluster_far_z_mode_functions(&mut world); - register_cluster_z_config_functions(&mut world); - register_clustered_decal_functions(&mut world); - register_irradiance_volume_functions(&mut world); + register_atmosphere_mode_functions(&mut world); register_render_visible_mesh_entities_functions(&mut world); register_render_cubemap_visible_entities_functions(&mut world); register_render_cascades_visible_entities_functions(&mut world); register_forward_decal_functions(&mut world); register_opaque_renderer_method_functions(&mut world); - register_cascade_functions(&mut world); - register_transmitted_shadow_receiver_functions(&mut world); register_lightmap_functions(&mut world); register_material_binding_id_functions(&mut world); register_material_bind_group_slot_functions(&mut world); diff --git a/crates/bindings/bevy_picking_bms_bindings/Cargo.toml b/crates/bindings/bevy_picking_bms_bindings/Cargo.toml index e8463f8076..77612c0975 100644 --- a/crates/bindings/bevy_picking_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_picking_bms_bindings/Cargo.toml @@ -17,37 +17,35 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_picking = { version = "0.16.1", features = [ - "bevy_mesh_picking_backend", -], default-features = true } +bevy_picking = { version = "0.17.2", features = ["bevy_mesh_picking_backend"], default-features = true} -bevy_app = { version = "^0.16.1", features = [], default-features = true } +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} -bevy_asset = { version = "^0.16.1", features = [], default-features = true } +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} -bevy_derive = { version = "^0.16.1", features = [], default-features = true } +bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.16.1", features = [], default-features = true } +bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_input = { version = "^0.16.1", features = [], default-features = true } +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_math = { version = "^0.16.1", features = [], default-features = true } +bevy_input = { version = "^0.17.2", features = ["std", "bevy_reflect", "smol_str"], default-features = true} -bevy_mesh = { version = "^0.16.1", features = [], default-features = true } +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} -bevy_reflect = { version = "^0.16.1", features = [], default-features = true } +bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_render = { version = "^0.16.1", features = [], default-features = true } +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_time = { version = "^0.16.1", features = [], default-features = true } +bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_transform = { version = "^0.16.1", features = [], default-features = true } +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.16.1", features = [], default-features = true } +bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} -bevy_window = { version = "^0.16.1", features = [], default-features = true } +crossbeam-channel = { version = "^0.5", features = [], default-features = true} + +uuid = { version = "^1.13.1", features = [], default-features = true} -crossbeam-channel = { version = "^0.5", features = [], default-features = true } -uuid = { version = "^1.13.1", features = [], default-features = true } diff --git a/crates/bindings/bevy_picking_bms_bindings/src/lib.rs b/crates/bindings/bevy_picking_bms_bindings/src/lib.rs index 0a336cf46c..185673486c 100644 --- a/crates/bindings/bevy_picking_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_picking_bms_bindings/src/lib.rs @@ -12,6 +12,52 @@ use bevy_mod_scripting_bindings::{ }; use bevy_mod_scripting_derive::script_bindings; pub struct BevyPickingScriptingPlugin; +pub(crate) fn register_release_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_picking::events::Release, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_picking::events::Release>| { + let output: Val<::bevy_picking::events::Release> = { + { + let output: Val<::bevy_picking::events::Release> = + <::bevy_picking::events::Release as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_picking::events::Release>, + other: Ref<::bevy_picking::events::Release>| { + let output: bool = { + { + let output: bool = <::bevy_picking::events::Release as ::std::cmp::PartialEq< + ::bevy_picking::events::Release, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_picking::events::Release, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} pub(crate) fn register_ray_cast_backfaces_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_picking::mesh_picking::ray_cast::RayCastBackfaces, @@ -121,37 +167,6 @@ pub(crate) fn register_mesh_picking_settings_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_pointer_input_plugin_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::input::prelude::PointerInputPlugin, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::input::prelude::PointerInputPlugin>| { - let output: Val<::bevy_picking::input::prelude::PointerInputPlugin> = { - { - let output: Val< - ::bevy_picking::input::prelude::PointerInputPlugin, - > = <::bevy_picking::input::prelude::PointerInputPlugin as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_picking::input::prelude::PointerInputPlugin, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} pub(crate) fn register_pointer_button_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_picking::pointer::PointerButton, @@ -284,20 +299,18 @@ pub(crate) fn register_pickable_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_picking_plugin_functions(world: &mut World) { +pub(crate) fn register_picking_settings_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::prelude::PickingPlugin, + ::bevy_picking::PickingSettings, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_picking::prelude::PickingPlugin>| { - let output: Val<::bevy_picking::prelude::PickingPlugin> = { + |_self: Ref<::bevy_picking::PickingSettings>| { + let output: Val<::bevy_picking::PickingSettings> = { { - let output: Val<::bevy_picking::prelude::PickingPlugin> = - <::bevy_picking::prelude::PickingPlugin as ::std::clone::Clone>::clone( - &_self, - ) - .into(); + let output: Val<::bevy_picking::PickingSettings> = + <::bevy_picking::PickingSettings as ::std::clone::Clone>::clone(&_self) + .into(); output } }; @@ -310,7 +323,7 @@ pub(crate) fn register_picking_plugin_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::prelude::PickingPlugin, + ::bevy_picking::PickingSettings, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -437,537 +450,199 @@ pub(crate) fn register_pointer_hits_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_picking_interaction_functions(world: &mut World) { +pub(crate) fn register_cancel_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::hover::PickingInteraction, + ::bevy_picking::events::Cancel, >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_picking::hover::PickingInteraction>| { - let output: () = { - { - let output: () = <::bevy_picking::hover::PickingInteraction as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) + .register_documented( + "clone", + |_self: Ref<::bevy_picking::events::Cancel>| { + let output: Val<::bevy_picking::events::Cancel> = { + { + let output: Val<::bevy_picking::events::Cancel> = + <::bevy_picking::events::Cancel as ::std::clone::Clone>::clone(&_self) .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::hover::PickingInteraction>| { - let output: Val<::bevy_picking::hover::PickingInteraction> = { - { - let output: Val<::bevy_picking::hover::PickingInteraction> = <::bevy_picking::hover::PickingInteraction as ::std::clone::Clone>::clone( - &_self, - ) + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_picking::events::Cancel>, other: Ref<::bevy_picking::events::Cancel>| { + let output: bool = { + { + let output: bool = <::bevy_picking::events::Cancel as ::std::cmp::PartialEq< + ::bevy_picking::events::Cancel, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_picking::events::Cancel, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_click_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_picking::events::Click, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_picking::events::Click>| { + let output: Val<::bevy_picking::events::Click> = { + { + let output: Val<::bevy_picking::events::Click> = + <::bevy_picking::events::Click as ::std::clone::Clone>::clone(&_self) .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_picking::hover::PickingInteraction>, - other: Ref<::bevy_picking::hover::PickingInteraction>| - { - let output: bool = { - { - let output: bool = <::bevy_picking::hover::PickingInteraction as ::std::cmp::PartialEq< - ::bevy_picking::hover::PickingInteraction, - >>::eq(&_self, &other) + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_picking::events::Click>, other: Ref<::bevy_picking::events::Click>| { + let output: bool = { + { + let output: bool = <::bevy_picking::events::Click as ::std::cmp::PartialEq< + ::bevy_picking::events::Click, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_picking::events::Click, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_press_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_picking::events::Press, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_picking::events::Press>| { + let output: Val<::bevy_picking::events::Press> = { + { + let output: Val<::bevy_picking::events::Press> = + <::bevy_picking::events::Press as ::std::clone::Clone>::clone(&_self) .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_picking::events::Press>, other: Ref<::bevy_picking::events::Press>| { + let output: bool = { + { + let output: bool = <::bevy_picking::events::Press as ::std::cmp::PartialEq< + ::bevy_picking::events::Press, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::hover::PickingInteraction, + ::bevy_picking::events::Press, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_pointer_id_functions(world: &mut World) { +pub(crate) fn register_drag_drop_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::backend::prelude::PointerId, + ::bevy_picking::events::DragDrop, >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_picking::backend::prelude::PointerId>| { - let output: () = { - { - let output: () = <::bevy_picking::backend::prelude::PointerId as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) + .register_documented( + "clone", + |_self: Ref<::bevy_picking::events::DragDrop>| { + let output: Val<::bevy_picking::events::DragDrop> = { + { + let output: Val<::bevy_picking::events::DragDrop> = + <::bevy_picking::events::DragDrop as ::std::clone::Clone>::clone(&_self) .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::backend::prelude::PointerId>| { - let output: Val<::bevy_picking::backend::prelude::PointerId> = { - { - let output: Val<::bevy_picking::backend::prelude::PointerId> = <::bevy_picking::backend::prelude::PointerId as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_picking::backend::prelude::PointerId>, - other: Ref<::bevy_picking::backend::prelude::PointerId>| - { - let output: bool = { - { - let output: bool = <::bevy_picking::backend::prelude::PointerId as ::std::cmp::PartialEq< - ::bevy_picking::backend::prelude::PointerId, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "get_touch_id", - |_self: Ref<::bevy_picking::backend::prelude::PointerId>| { - let output: ::std::option::Option = { - { - let output: ::std::option::Option = ::bevy_picking::backend::prelude::PointerId::get_touch_id( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the touch id if the pointer is a touch input.", - &["_self"], - ) - .register_documented( - "is_custom", - |_self: Ref<::bevy_picking::backend::prelude::PointerId>| { - let output: bool = { - { - let output: bool = ::bevy_picking::backend::prelude::PointerId::is_custom( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns true if the pointer is a custom input.", - &["_self"], - ) - .register_documented( - "is_mouse", - |_self: Ref<::bevy_picking::backend::prelude::PointerId>| { - let output: bool = { - { - let output: bool = ::bevy_picking::backend::prelude::PointerId::is_mouse( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns true if the pointer is the mouse.", - &["_self"], - ) - .register_documented( - "is_touch", - |_self: Ref<::bevy_picking::backend::prelude::PointerId>| { - let output: bool = { - { - let output: bool = ::bevy_picking::backend::prelude::PointerId::is_touch( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns true if the pointer is a touch input.", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_picking::backend::prelude::PointerId, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_pointer_location_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::backend::prelude::PointerLocation, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::backend::prelude::PointerLocation>| { - let output: Val<::bevy_picking::backend::prelude::PointerLocation> = { - { - let output: Val< - ::bevy_picking::backend::prelude::PointerLocation, - > = <::bevy_picking::backend::prelude::PointerLocation as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_picking::backend::prelude::PointerLocation>, - other: Ref<::bevy_picking::backend::prelude::PointerLocation>| - { - let output: bool = { - { - let output: bool = <::bevy_picking::backend::prelude::PointerLocation as ::std::cmp::PartialEq< - ::bevy_picking::backend::prelude::PointerLocation, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "new", - |location: Val<::bevy_picking::pointer::Location>| { - let output: Val<::bevy_picking::backend::prelude::PointerLocation> = { - { - let output: Val< - ::bevy_picking::backend::prelude::PointerLocation, - > = ::bevy_picking::backend::prelude::PointerLocation::new( - location.into_inner(), - ) - .into(); - output - } - }; - output - }, - "Returns a [`PointerLocation`] associated with the given location", - &["location"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_picking::backend::prelude::PointerLocation, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_pointer_press_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::pointer::PointerPress, - >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_picking::pointer::PointerPress>| { - let output: () = { - { - let output: () = <::bevy_picking::pointer::PointerPress as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::pointer::PointerPress>| { - let output: Val<::bevy_picking::pointer::PointerPress> = { - { - let output: Val<::bevy_picking::pointer::PointerPress> = <::bevy_picking::pointer::PointerPress as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_picking::pointer::PointerPress>, - other: Ref<::bevy_picking::pointer::PointerPress>| - { - let output: bool = { - { - let output: bool = <::bevy_picking::pointer::PointerPress as ::std::cmp::PartialEq< - ::bevy_picking::pointer::PointerPress, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "is_any_pressed", - |_self: Ref<::bevy_picking::pointer::PointerPress>| { - let output: bool = { - { - let output: bool = ::bevy_picking::pointer::PointerPress::is_any_pressed( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns true if any pointer button is pressed.", - &["_self"], - ) - .register_documented( - "is_middle_pressed", - |_self: Ref<::bevy_picking::pointer::PointerPress>| { - let output: bool = { - { - let output: bool = ::bevy_picking::pointer::PointerPress::is_middle_pressed( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns true if the middle (tertiary) pointer button is pressed.", - &["_self"], - ) - .register_documented( - "is_primary_pressed", - |_self: Ref<::bevy_picking::pointer::PointerPress>| { - let output: bool = { - { - let output: bool = ::bevy_picking::pointer::PointerPress::is_primary_pressed( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns true if the primary pointer button is pressed.", - &["_self"], - ) - .register_documented( - "is_secondary_pressed", - |_self: Ref<::bevy_picking::pointer::PointerPress>| { - let output: bool = { - { - let output: bool = ::bevy_picking::pointer::PointerPress::is_secondary_pressed( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns true if the secondary pointer button is pressed.", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_picking::pointer::PointerPress, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_pointer_interaction_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::pointer::PointerInteraction, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::pointer::PointerInteraction>| { - let output: Val<::bevy_picking::pointer::PointerInteraction> = { - { - let output: Val<::bevy_picking::pointer::PointerInteraction> = <::bevy_picking::pointer::PointerInteraction as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_picking::pointer::PointerInteraction, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_ray_id_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::backend::ray::RayId, - >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_picking::backend::ray::RayId>| { - let output: () = { - { - let output: () = <::bevy_picking::backend::ray::RayId as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::backend::ray::RayId>| { - let output: Val<::bevy_picking::backend::ray::RayId> = { - { - let output: Val<::bevy_picking::backend::ray::RayId> = <::bevy_picking::backend::ray::RayId as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_picking::backend::ray::RayId>, - other: Ref<::bevy_picking::backend::ray::RayId>| - { - let output: bool = { - { - let output: bool = <::bevy_picking::backend::ray::RayId as ::std::cmp::PartialEq< - ::bevy_picking::backend::ray::RayId, + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_picking::events::DragDrop>, + other: Ref<::bevy_picking::events::DragDrop>| { + let output: bool = { + { + let output: bool = + <::bevy_picking::events::DragDrop as ::std::cmp::PartialEq< + ::bevy_picking::events::DragDrop, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "new", - | - camera: Val<::bevy_ecs::entity::Entity>, - pointer: Val<::bevy_picking::backend::prelude::PointerId>| - { - let output: Val<::bevy_picking::backend::ray::RayId> = { - { - let output: Val<::bevy_picking::backend::ray::RayId> = ::bevy_picking::backend::ray::RayId::new( - camera.into_inner(), - pointer.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Construct a [`RayId`].", - &["camera", "pointer"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::backend::ray::RayId, + ::bevy_picking::events::DragDrop, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_cancel_functions(world: &mut World) { +pub(crate) fn register_drag_end_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::events::Cancel, + ::bevy_picking::events::DragEnd, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_picking::events::Cancel>| { - let output: Val<::bevy_picking::events::Cancel> = { + |_self: Ref<::bevy_picking::events::DragEnd>| { + let output: Val<::bevy_picking::events::DragEnd> = { { - let output: Val<::bevy_picking::events::Cancel> = - <::bevy_picking::events::Cancel as ::std::clone::Clone>::clone(&_self) + let output: Val<::bevy_picking::events::DragEnd> = + <::bevy_picking::events::DragEnd as ::std::clone::Clone>::clone(&_self) .into(); output } @@ -979,11 +654,12 @@ pub(crate) fn register_cancel_functions(world: &mut World) { ) .register_documented( "eq", - |_self: Ref<::bevy_picking::events::Cancel>, other: Ref<::bevy_picking::events::Cancel>| { + |_self: Ref<::bevy_picking::events::DragEnd>, + other: Ref<::bevy_picking::events::DragEnd>| { let output: bool = { { - let output: bool = <::bevy_picking::events::Cancel as ::std::cmp::PartialEq< - ::bevy_picking::events::Cancel, + let output: bool = <::bevy_picking::events::DragEnd as ::std::cmp::PartialEq< + ::bevy_picking::events::DragEnd, >>::eq(&_self, &other) .into(); output @@ -998,21 +674,21 @@ pub(crate) fn register_cancel_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::events::Cancel, + ::bevy_picking::events::DragEnd, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_click_functions(world: &mut World) { +pub(crate) fn register_drag_enter_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::events::Click, + ::bevy_picking::events::DragEnter, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_picking::events::Click>| { - let output: Val<::bevy_picking::events::Click> = { + |_self: Ref<::bevy_picking::events::DragEnter>| { + let output: Val<::bevy_picking::events::DragEnter> = { { - let output: Val<::bevy_picking::events::Click> = - <::bevy_picking::events::Click as ::std::clone::Clone>::clone(&_self) + let output: Val<::bevy_picking::events::DragEnter> = + <::bevy_picking::events::DragEnter as ::std::clone::Clone>::clone(&_self) .into(); output } @@ -1024,13 +700,15 @@ pub(crate) fn register_click_functions(world: &mut World) { ) .register_documented( "eq", - |_self: Ref<::bevy_picking::events::Click>, other: Ref<::bevy_picking::events::Click>| { + |_self: Ref<::bevy_picking::events::DragEnter>, + other: Ref<::bevy_picking::events::DragEnter>| { let output: bool = { { - let output: bool = <::bevy_picking::events::Click as ::std::cmp::PartialEq< - ::bevy_picking::events::Click, - >>::eq(&_self, &other) - .into(); + let output: bool = + <::bevy_picking::events::DragEnter as ::std::cmp::PartialEq< + ::bevy_picking::events::DragEnter, + >>::eq(&_self, &other) + .into(); output } }; @@ -1043,22 +721,21 @@ pub(crate) fn register_click_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::events::Click, + ::bevy_picking::events::DragEnter, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_pressed_functions(world: &mut World) { +pub(crate) fn register_drag_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::events::Pressed, + ::bevy_picking::events::Drag, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_picking::events::Pressed>| { - let output: Val<::bevy_picking::events::Pressed> = { + |_self: Ref<::bevy_picking::events::Drag>| { + let output: Val<::bevy_picking::events::Drag> = { { - let output: Val<::bevy_picking::events::Pressed> = - <::bevy_picking::events::Pressed as ::std::clone::Clone>::clone(&_self) - .into(); + let output: Val<::bevy_picking::events::Drag> = + <::bevy_picking::events::Drag as ::std::clone::Clone>::clone(&_self).into(); output } }; @@ -1069,12 +746,11 @@ pub(crate) fn register_pressed_functions(world: &mut World) { ) .register_documented( "eq", - |_self: Ref<::bevy_picking::events::Pressed>, - other: Ref<::bevy_picking::events::Pressed>| { + |_self: Ref<::bevy_picking::events::Drag>, other: Ref<::bevy_picking::events::Drag>| { let output: bool = { { - let output: bool = <::bevy_picking::events::Pressed as ::std::cmp::PartialEq< - ::bevy_picking::events::Pressed, + let output: bool = <::bevy_picking::events::Drag as ::std::cmp::PartialEq< + ::bevy_picking::events::Drag, >>::eq(&_self, &other) .into(); output @@ -1089,21 +765,21 @@ pub(crate) fn register_pressed_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::events::Pressed, + ::bevy_picking::events::Drag, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_drag_drop_functions(world: &mut World) { +pub(crate) fn register_drag_leave_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::events::DragDrop, + ::bevy_picking::events::DragLeave, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_picking::events::DragDrop>| { - let output: Val<::bevy_picking::events::DragDrop> = { + |_self: Ref<::bevy_picking::events::DragLeave>| { + let output: Val<::bevy_picking::events::DragLeave> = { { - let output: Val<::bevy_picking::events::DragDrop> = - <::bevy_picking::events::DragDrop as ::std::clone::Clone>::clone(&_self) + let output: Val<::bevy_picking::events::DragLeave> = + <::bevy_picking::events::DragLeave as ::std::clone::Clone>::clone(&_self) .into(); output } @@ -1115,13 +791,13 @@ pub(crate) fn register_drag_drop_functions(world: &mut World) { ) .register_documented( "eq", - |_self: Ref<::bevy_picking::events::DragDrop>, - other: Ref<::bevy_picking::events::DragDrop>| { + |_self: Ref<::bevy_picking::events::DragLeave>, + other: Ref<::bevy_picking::events::DragLeave>| { let output: bool = { { let output: bool = - <::bevy_picking::events::DragDrop as ::std::cmp::PartialEq< - ::bevy_picking::events::DragDrop, + <::bevy_picking::events::DragLeave as ::std::cmp::PartialEq< + ::bevy_picking::events::DragLeave, >>::eq(&_self, &other) .into(); output @@ -1136,21 +812,21 @@ pub(crate) fn register_drag_drop_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::events::DragDrop, + ::bevy_picking::events::DragLeave, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_drag_end_functions(world: &mut World) { +pub(crate) fn register_drag_over_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::events::DragEnd, + ::bevy_picking::events::DragOver, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_picking::events::DragEnd>| { - let output: Val<::bevy_picking::events::DragEnd> = { + |_self: Ref<::bevy_picking::events::DragOver>| { + let output: Val<::bevy_picking::events::DragOver> = { { - let output: Val<::bevy_picking::events::DragEnd> = - <::bevy_picking::events::DragEnd as ::std::clone::Clone>::clone(&_self) + let output: Val<::bevy_picking::events::DragOver> = + <::bevy_picking::events::DragOver as ::std::clone::Clone>::clone(&_self) .into(); output } @@ -1162,14 +838,15 @@ pub(crate) fn register_drag_end_functions(world: &mut World) { ) .register_documented( "eq", - |_self: Ref<::bevy_picking::events::DragEnd>, - other: Ref<::bevy_picking::events::DragEnd>| { + |_self: Ref<::bevy_picking::events::DragOver>, + other: Ref<::bevy_picking::events::DragOver>| { let output: bool = { { - let output: bool = <::bevy_picking::events::DragEnd as ::std::cmp::PartialEq< - ::bevy_picking::events::DragEnd, - >>::eq(&_self, &other) - .into(); + let output: bool = + <::bevy_picking::events::DragOver as ::std::cmp::PartialEq< + ::bevy_picking::events::DragOver, + >>::eq(&_self, &other) + .into(); output } }; @@ -1182,21 +859,21 @@ pub(crate) fn register_drag_end_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::events::DragEnd, + ::bevy_picking::events::DragOver, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_drag_enter_functions(world: &mut World) { +pub(crate) fn register_drag_start_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::events::DragEnter, + ::bevy_picking::events::DragStart, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_picking::events::DragEnter>| { - let output: Val<::bevy_picking::events::DragEnter> = { + |_self: Ref<::bevy_picking::events::DragStart>| { + let output: Val<::bevy_picking::events::DragStart> = { { - let output: Val<::bevy_picking::events::DragEnter> = - <::bevy_picking::events::DragEnter as ::std::clone::Clone>::clone(&_self) + let output: Val<::bevy_picking::events::DragStart> = + <::bevy_picking::events::DragStart as ::std::clone::Clone>::clone(&_self) .into(); output } @@ -1208,13 +885,13 @@ pub(crate) fn register_drag_enter_functions(world: &mut World) { ) .register_documented( "eq", - |_self: Ref<::bevy_picking::events::DragEnter>, - other: Ref<::bevy_picking::events::DragEnter>| { + |_self: Ref<::bevy_picking::events::DragStart>, + other: Ref<::bevy_picking::events::DragStart>| { let output: bool = { { let output: bool = - <::bevy_picking::events::DragEnter as ::std::cmp::PartialEq< - ::bevy_picking::events::DragEnter, + <::bevy_picking::events::DragStart as ::std::cmp::PartialEq< + ::bevy_picking::events::DragStart, >>::eq(&_self, &other) .into(); output @@ -1229,21 +906,21 @@ pub(crate) fn register_drag_enter_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::events::DragEnter, + ::bevy_picking::events::DragStart, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_drag_functions(world: &mut World) { +pub(crate) fn register_move_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::events::Drag, + ::bevy_picking::events::Move, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_picking::events::Drag>| { - let output: Val<::bevy_picking::events::Drag> = { + |_self: Ref<::bevy_picking::events::Move>| { + let output: Val<::bevy_picking::events::Move> = { { - let output: Val<::bevy_picking::events::Drag> = - <::bevy_picking::events::Drag as ::std::clone::Clone>::clone(&_self).into(); + let output: Val<::bevy_picking::events::Move> = + <::bevy_picking::events::Move as ::std::clone::Clone>::clone(&_self).into(); output } }; @@ -1254,11 +931,11 @@ pub(crate) fn register_drag_functions(world: &mut World) { ) .register_documented( "eq", - |_self: Ref<::bevy_picking::events::Drag>, other: Ref<::bevy_picking::events::Drag>| { + |_self: Ref<::bevy_picking::events::Move>, other: Ref<::bevy_picking::events::Move>| { let output: bool = { { - let output: bool = <::bevy_picking::events::Drag as ::std::cmp::PartialEq< - ::bevy_picking::events::Drag, + let output: bool = <::bevy_picking::events::Move as ::std::cmp::PartialEq< + ::bevy_picking::events::Move, >>::eq(&_self, &other) .into(); output @@ -1273,22 +950,70 @@ pub(crate) fn register_drag_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::events::Drag, + ::bevy_picking::events::Move, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_drag_leave_functions(world: &mut World) { +pub(crate) fn register_out_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::events::DragLeave, + ::bevy_picking::events::Out, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_picking::events::Out>| { + let output: Val<::bevy_picking::events::Out> = { + { + let output: Val<::bevy_picking::events::Out> = <::bevy_picking::events::Out as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::events::Out>, + other: Ref<::bevy_picking::events::Out>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::events::Out as ::std::cmp::PartialEq< + ::bevy_picking::events::Out, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_picking::events::Out, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_over_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_picking::events::Over, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_picking::events::DragLeave>| { - let output: Val<::bevy_picking::events::DragLeave> = { + |_self: Ref<::bevy_picking::events::Over>| { + let output: Val<::bevy_picking::events::Over> = { { - let output: Val<::bevy_picking::events::DragLeave> = - <::bevy_picking::events::DragLeave as ::std::clone::Clone>::clone(&_self) - .into(); + let output: Val<::bevy_picking::events::Over> = + <::bevy_picking::events::Over as ::std::clone::Clone>::clone(&_self).into(); output } }; @@ -1299,15 +1024,13 @@ pub(crate) fn register_drag_leave_functions(world: &mut World) { ) .register_documented( "eq", - |_self: Ref<::bevy_picking::events::DragLeave>, - other: Ref<::bevy_picking::events::DragLeave>| { + |_self: Ref<::bevy_picking::events::Over>, other: Ref<::bevy_picking::events::Over>| { let output: bool = { { - let output: bool = - <::bevy_picking::events::DragLeave as ::std::cmp::PartialEq< - ::bevy_picking::events::DragLeave, - >>::eq(&_self, &other) - .into(); + let output: bool = <::bevy_picking::events::Over as ::std::cmp::PartialEq< + ::bevy_picking::events::Over, + >>::eq(&_self, &other) + .into(); output } }; @@ -1320,21 +1043,21 @@ pub(crate) fn register_drag_leave_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::events::DragLeave, + ::bevy_picking::events::Over, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_drag_over_functions(world: &mut World) { +pub(crate) fn register_scroll_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::events::DragOver, + ::bevy_picking::events::Scroll, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_picking::events::DragOver>| { - let output: Val<::bevy_picking::events::DragOver> = { + |_self: Ref<::bevy_picking::events::Scroll>| { + let output: Val<::bevy_picking::events::Scroll> = { { - let output: Val<::bevy_picking::events::DragOver> = - <::bevy_picking::events::DragOver as ::std::clone::Clone>::clone(&_self) + let output: Val<::bevy_picking::events::Scroll> = + <::bevy_picking::events::Scroll as ::std::clone::Clone>::clone(&_self) .into(); output } @@ -1346,15 +1069,13 @@ pub(crate) fn register_drag_over_functions(world: &mut World) { ) .register_documented( "eq", - |_self: Ref<::bevy_picking::events::DragOver>, - other: Ref<::bevy_picking::events::DragOver>| { + |_self: Ref<::bevy_picking::events::Scroll>, other: Ref<::bevy_picking::events::Scroll>| { let output: bool = { { - let output: bool = - <::bevy_picking::events::DragOver as ::std::cmp::PartialEq< - ::bevy_picking::events::DragOver, - >>::eq(&_self, &other) - .into(); + let output: bool = <::bevy_picking::events::Scroll as ::std::cmp::PartialEq< + ::bevy_picking::events::Scroll, + >>::eq(&_self, &other) + .into(); output } }; @@ -1367,22 +1088,24 @@ pub(crate) fn register_drag_over_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::events::DragOver, + ::bevy_picking::events::Scroll, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_drag_start_functions(world: &mut World) { +pub(crate) fn register_hit_data_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::events::DragStart, + ::bevy_picking::backend::prelude::HitData, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_picking::events::DragStart>| { - let output: Val<::bevy_picking::events::DragStart> = { + |_self: Ref<::bevy_picking::backend::prelude::HitData>| { + let output: Val<::bevy_picking::backend::prelude::HitData> = { { - let output: Val<::bevy_picking::events::DragStart> = - <::bevy_picking::events::DragStart as ::std::clone::Clone>::clone(&_self) - .into(); + let output: Val<::bevy_picking::backend::prelude::HitData> = + <::bevy_picking::backend::prelude::HitData as ::std::clone::Clone>::clone( + &_self, + ) + .into(); output } }; @@ -1393,13 +1116,13 @@ pub(crate) fn register_drag_start_functions(world: &mut World) { ) .register_documented( "eq", - |_self: Ref<::bevy_picking::events::DragStart>, - other: Ref<::bevy_picking::events::DragStart>| { + |_self: Ref<::bevy_picking::backend::prelude::HitData>, + other: Ref<::bevy_picking::backend::prelude::HitData>| { let output: bool = { { let output: bool = - <::bevy_picking::events::DragStart as ::std::cmp::PartialEq< - ::bevy_picking::events::DragStart, + <::bevy_picking::backend::prelude::HitData as ::std::cmp::PartialEq< + ::bevy_picking::backend::prelude::HitData, >>::eq(&_self, &other) .into(); output @@ -1414,64 +1137,156 @@ pub(crate) fn register_drag_start_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::events::DragStart, + ::bevy_picking::backend::prelude::HitData, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_move_functions(world: &mut World) { +pub(crate) fn register_pointer_id_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::events::Move, + ::bevy_picking::backend::prelude::PointerId, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::events::Move>| { - let output: Val<::bevy_picking::events::Move> = { - { - let output: Val<::bevy_picking::events::Move> = - <::bevy_picking::events::Move as ::std::clone::Clone>::clone(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_picking::events::Move>, other: Ref<::bevy_picking::events::Move>| { - let output: bool = { - { - let output: bool = <::bevy_picking::events::Move as ::std::cmp::PartialEq< - ::bevy_picking::events::Move, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_picking::backend::prelude::PointerId>| { + let output: () = { + { + let output: () = <::bevy_picking::backend::prelude::PointerId as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_picking::backend::prelude::PointerId>| { + let output: Val<::bevy_picking::backend::prelude::PointerId> = { + { + let output: Val<::bevy_picking::backend::prelude::PointerId> = <::bevy_picking::backend::prelude::PointerId as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::backend::prelude::PointerId>, + other: Ref<::bevy_picking::backend::prelude::PointerId>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::backend::prelude::PointerId as ::std::cmp::PartialEq< + ::bevy_picking::backend::prelude::PointerId, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "get_touch_id", + |_self: Ref<::bevy_picking::backend::prelude::PointerId>| { + let output: ::std::option::Option = { + { + let output: ::std::option::Option = ::bevy_picking::backend::prelude::PointerId::get_touch_id( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the touch id if the pointer is a touch input.", + &["_self"], + ) + .register_documented( + "is_custom", + |_self: Ref<::bevy_picking::backend::prelude::PointerId>| { + let output: bool = { + { + let output: bool = ::bevy_picking::backend::prelude::PointerId::is_custom( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns true if the pointer is a custom input.", + &["_self"], + ) + .register_documented( + "is_mouse", + |_self: Ref<::bevy_picking::backend::prelude::PointerId>| { + let output: bool = { + { + let output: bool = ::bevy_picking::backend::prelude::PointerId::is_mouse( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns true if the pointer is the mouse.", + &["_self"], + ) + .register_documented( + "is_touch", + |_self: Ref<::bevy_picking::backend::prelude::PointerId>| { + let output: bool = { + { + let output: bool = ::bevy_picking::backend::prelude::PointerId::is_touch( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns true if the pointer is a touch input.", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::events::Move, + ::bevy_picking::backend::prelude::PointerId, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_out_functions(world: &mut World) { +pub(crate) fn register_pointer_location_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::events::Out, + ::bevy_picking::backend::prelude::PointerLocation, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_picking::events::Out>| { - let output: Val<::bevy_picking::events::Out> = { + |_self: Ref<::bevy_picking::backend::prelude::PointerLocation>| { + let output: Val<::bevy_picking::backend::prelude::PointerLocation> = { { - let output: Val<::bevy_picking::events::Out> = <::bevy_picking::events::Out as ::std::clone::Clone>::clone( + let output: Val< + ::bevy_picking::backend::prelude::PointerLocation, + > = <::bevy_picking::backend::prelude::PointerLocation as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1486,13 +1301,13 @@ pub(crate) fn register_out_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_picking::events::Out>, - other: Ref<::bevy_picking::events::Out>| + _self: Ref<::bevy_picking::backend::prelude::PointerLocation>, + other: Ref<::bevy_picking::backend::prelude::PointerLocation>| { let output: bool = { { - let output: bool = <::bevy_picking::events::Out as ::std::cmp::PartialEq< - ::bevy_picking::events::Out, + let output: bool = <::bevy_picking::backend::prelude::PointerLocation as ::std::cmp::PartialEq< + ::bevy_picking::backend::prelude::PointerLocation, >>::eq(&_self, &other) .into(); output @@ -1502,70 +1317,132 @@ pub(crate) fn register_out_functions(world: &mut World) { }, "", &["_self", "other"], + ) + .register_documented( + "new", + |location: Val<::bevy_picking::pointer::Location>| { + let output: Val<::bevy_picking::backend::prelude::PointerLocation> = { + { + let output: Val< + ::bevy_picking::backend::prelude::PointerLocation, + > = ::bevy_picking::backend::prelude::PointerLocation::new( + location.into_inner(), + ) + .into(); + output + } + }; + output + }, + "Returns a [`PointerLocation`] associated with the given location", + &["location"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::events::Out, + ::bevy_picking::backend::prelude::PointerLocation, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_over_functions(world: &mut World) { +pub(crate) fn register_ray_id_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::events::Over, + ::bevy_picking::backend::ray::RayId, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::events::Over>| { - let output: Val<::bevy_picking::events::Over> = { - { - let output: Val<::bevy_picking::events::Over> = - <::bevy_picking::events::Over as ::std::clone::Clone>::clone(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_picking::events::Over>, other: Ref<::bevy_picking::events::Over>| { - let output: bool = { - { - let output: bool = <::bevy_picking::events::Over as ::std::cmp::PartialEq< - ::bevy_picking::events::Over, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_picking::backend::ray::RayId>| { + let output: () = { + { + let output: () = <::bevy_picking::backend::ray::RayId as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_picking::backend::ray::RayId>| { + let output: Val<::bevy_picking::backend::ray::RayId> = { + { + let output: Val<::bevy_picking::backend::ray::RayId> = <::bevy_picking::backend::ray::RayId as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::backend::ray::RayId>, + other: Ref<::bevy_picking::backend::ray::RayId>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::backend::ray::RayId as ::std::cmp::PartialEq< + ::bevy_picking::backend::ray::RayId, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "new", + | + camera: Val<::bevy_ecs::entity::Entity>, + pointer: Val<::bevy_picking::backend::prelude::PointerId>| + { + let output: Val<::bevy_picking::backend::ray::RayId> = { + { + let output: Val<::bevy_picking::backend::ray::RayId> = ::bevy_picking::backend::ray::RayId::new( + camera.into_inner(), + pointer.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Construct a [`RayId`].", + &["camera", "pointer"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::events::Over, + ::bevy_picking::backend::ray::RayId, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_released_functions(world: &mut World) { +pub(crate) fn register_location_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::events::Released, + ::bevy_picking::pointer::Location, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_picking::events::Released>| { - let output: Val<::bevy_picking::events::Released> = { + |_self: Ref<::bevy_picking::pointer::Location>| { + let output: Val<::bevy_picking::pointer::Location> = { { - let output: Val<::bevy_picking::events::Released> = - <::bevy_picking::events::Released as ::std::clone::Clone>::clone(&_self) + let output: Val<::bevy_picking::pointer::Location> = + <::bevy_picking::pointer::Location as ::std::clone::Clone>::clone(&_self) .into(); output } @@ -1577,13 +1454,13 @@ pub(crate) fn register_released_functions(world: &mut World) { ) .register_documented( "eq", - |_self: Ref<::bevy_picking::events::Released>, - other: Ref<::bevy_picking::events::Released>| { + |_self: Ref<::bevy_picking::pointer::Location>, + other: Ref<::bevy_picking::pointer::Location>| { let output: bool = { { let output: bool = - <::bevy_picking::events::Released as ::std::cmp::PartialEq< - ::bevy_picking::events::Released, + <::bevy_picking::pointer::Location as ::std::cmp::PartialEq< + ::bevy_picking::pointer::Location, >>::eq(&_self, &other) .into(); output @@ -1598,69 +1475,52 @@ pub(crate) fn register_released_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::events::Released, + ::bevy_picking::pointer::Location, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_scroll_functions(world: &mut World) { +pub(crate) fn register_pointer_action_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::events::Scroll, + ::bevy_picking::pointer::PointerAction, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_picking::events::Scroll>| { - let output: Val<::bevy_picking::events::Scroll> = { - { - let output: Val<::bevy_picking::events::Scroll> = - <::bevy_picking::events::Scroll as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_picking::events::Scroll>, other: Ref<::bevy_picking::events::Scroll>| { - let output: bool = { + |_self: Ref<::bevy_picking::pointer::PointerAction>| { + let output: Val<::bevy_picking::pointer::PointerAction> = { { - let output: bool = <::bevy_picking::events::Scroll as ::std::cmp::PartialEq< - ::bevy_picking::events::Scroll, - >>::eq(&_self, &other) - .into(); + let output: Val<::bevy_picking::pointer::PointerAction> = + <::bevy_picking::pointer::PointerAction as ::std::clone::Clone>::clone( + &_self, + ) + .into(); output } }; output }, "", - &["_self", "other"], + &["_self"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::events::Scroll, + ::bevy_picking::pointer::PointerAction, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_hit_data_functions(world: &mut World) { +pub(crate) fn register_drag_entry_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::backend::prelude::HitData, + ::bevy_picking::events::DragEntry, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_picking::backend::prelude::HitData>| { - let output: Val<::bevy_picking::backend::prelude::HitData> = { + |_self: Ref<::bevy_picking::events::DragEntry>| { + let output: Val<::bevy_picking::events::DragEntry> = { { - let output: Val<::bevy_picking::backend::prelude::HitData> = - <::bevy_picking::backend::prelude::HitData as ::std::clone::Clone>::clone( - &_self, - ) - .into(); + let output: Val<::bevy_picking::events::DragEntry> = + <::bevy_picking::events::DragEntry as ::std::clone::Clone>::clone(&_self) + .into(); output } }; @@ -1671,13 +1531,13 @@ pub(crate) fn register_hit_data_functions(world: &mut World) { ) .register_documented( "eq", - |_self: Ref<::bevy_picking::backend::prelude::HitData>, - other: Ref<::bevy_picking::backend::prelude::HitData>| { + |_self: Ref<::bevy_picking::events::DragEntry>, + other: Ref<::bevy_picking::events::DragEntry>| { let output: bool = { { let output: bool = - <::bevy_picking::backend::prelude::HitData as ::std::cmp::PartialEq< - ::bevy_picking::backend::prelude::HitData, + <::bevy_picking::events::DragEntry as ::std::cmp::PartialEq< + ::bevy_picking::events::DragEntry, >>::eq(&_self, &other) .into(); output @@ -1692,148 +1552,413 @@ pub(crate) fn register_hit_data_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::backend::prelude::HitData, + ::bevy_picking::events::DragEntry, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_location_functions(world: &mut World) { +pub(crate) fn register_pointer_interaction_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::pointer::Location, + ::bevy_picking::pointer::PointerInteraction, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::pointer::Location>| { - let output: Val<::bevy_picking::pointer::Location> = { - { - let output: Val<::bevy_picking::pointer::Location> = - <::bevy_picking::pointer::Location as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_picking::pointer::PointerInteraction>| { + let output: Val<::bevy_picking::pointer::PointerInteraction> = { + { + let output: Val<::bevy_picking::pointer::PointerInteraction> = <::bevy_picking::pointer::PointerInteraction as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_picking::pointer::Location>, - other: Ref<::bevy_picking::pointer::Location>| { - let output: bool = { - { - let output: bool = - <::bevy_picking::pointer::Location as ::std::cmp::PartialEq< - ::bevy_picking::pointer::Location, + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_picking::pointer::PointerInteraction, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_pointer_press_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_picking::pointer::PointerPress, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_picking::pointer::PointerPress>| { + let output: () = { + { + let output: () = <::bevy_picking::pointer::PointerPress as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_picking::pointer::PointerPress>| { + let output: Val<::bevy_picking::pointer::PointerPress> = { + { + let output: Val<::bevy_picking::pointer::PointerPress> = <::bevy_picking::pointer::PointerPress as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::pointer::PointerPress>, + other: Ref<::bevy_picking::pointer::PointerPress>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::pointer::PointerPress as ::std::cmp::PartialEq< + ::bevy_picking::pointer::PointerPress, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "is_any_pressed", + |_self: Ref<::bevy_picking::pointer::PointerPress>| { + let output: bool = { + { + let output: bool = ::bevy_picking::pointer::PointerPress::is_any_pressed( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns true if any pointer button is pressed.", + &["_self"], + ) + .register_documented( + "is_middle_pressed", + |_self: Ref<::bevy_picking::pointer::PointerPress>| { + let output: bool = { + { + let output: bool = ::bevy_picking::pointer::PointerPress::is_middle_pressed( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns true if the middle (tertiary) pointer button is pressed.", + &["_self"], + ) + .register_documented( + "is_primary_pressed", + |_self: Ref<::bevy_picking::pointer::PointerPress>| { + let output: bool = { + { + let output: bool = ::bevy_picking::pointer::PointerPress::is_primary_pressed( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns true if the primary pointer button is pressed.", + &["_self"], + ) + .register_documented( + "is_secondary_pressed", + |_self: Ref<::bevy_picking::pointer::PointerPress>| { + let output: bool = { + { + let output: bool = ::bevy_picking::pointer::PointerPress::is_secondary_pressed( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns true if the secondary pointer button is pressed.", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_picking::pointer::PointerPress, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_picking_interaction_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_picking::hover::PickingInteraction, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_picking::hover::PickingInteraction>| { + let output: () = { + { + let output: () = <::bevy_picking::hover::PickingInteraction as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_picking::hover::PickingInteraction>| { + let output: Val<::bevy_picking::hover::PickingInteraction> = { + { + let output: Val<::bevy_picking::hover::PickingInteraction> = <::bevy_picking::hover::PickingInteraction as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::hover::PickingInteraction>, + other: Ref<::bevy_picking::hover::PickingInteraction>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::hover::PickingInteraction as ::std::cmp::PartialEq< + ::bevy_picking::hover::PickingInteraction, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::pointer::Location, + ::bevy_picking::hover::PickingInteraction, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_pointer_action_functions(world: &mut World) { +pub(crate) fn register_hovered_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::pointer::PointerAction, + ::bevy_picking::hover::Hovered, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::pointer::PointerAction>| { - let output: Val<::bevy_picking::pointer::PointerAction> = { - { - let output: Val<::bevy_picking::pointer::PointerAction> = - <::bevy_picking::pointer::PointerAction as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_picking::hover::Hovered>| { + let output: () = { + { + let output: () = <::bevy_picking::hover::Hovered as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_picking::hover::Hovered>| { + let output: Val<::bevy_picking::hover::Hovered> = { + { + let output: Val<::bevy_picking::hover::Hovered> = <::bevy_picking::hover::Hovered as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::hover::Hovered>, + other: Ref<::bevy_picking::hover::Hovered>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::hover::Hovered as ::std::cmp::PartialEq< + ::bevy_picking::hover::Hovered, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "get", + |_self: Ref<::bevy_picking::hover::Hovered>| { + let output: bool = { + { + let output: bool = ::bevy_picking::hover::Hovered::get(&_self) + .into(); + output + } + }; + output + }, + " Get whether the entity is currently hovered.", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::pointer::PointerAction, + ::bevy_picking::hover::Hovered, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_drag_entry_functions(world: &mut World) { +pub(crate) fn register_directly_hovered_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::events::DragEntry, + ::bevy_picking::hover::DirectlyHovered, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::events::DragEntry>| { - let output: Val<::bevy_picking::events::DragEntry> = { - { - let output: Val<::bevy_picking::events::DragEntry> = - <::bevy_picking::events::DragEntry as ::std::clone::Clone>::clone(&_self) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_picking::hover::DirectlyHovered>| { + let output: () = { + { + let output: () = <::bevy_picking::hover::DirectlyHovered as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_picking::events::DragEntry>, - other: Ref<::bevy_picking::events::DragEntry>| { - let output: bool = { - { - let output: bool = - <::bevy_picking::events::DragEntry as ::std::cmp::PartialEq< - ::bevy_picking::events::DragEntry, + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_picking::hover::DirectlyHovered>| { + let output: Val<::bevy_picking::hover::DirectlyHovered> = { + { + let output: Val<::bevy_picking::hover::DirectlyHovered> = <::bevy_picking::hover::DirectlyHovered as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::hover::DirectlyHovered>, + other: Ref<::bevy_picking::hover::DirectlyHovered>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::hover::DirectlyHovered as ::std::cmp::PartialEq< + ::bevy_picking::hover::DirectlyHovered, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "get", + |_self: Ref<::bevy_picking::hover::DirectlyHovered>| { + let output: bool = { + { + let output: bool = ::bevy_picking::hover::DirectlyHovered::get( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get whether the entity is currently hovered.", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::events::DragEntry, + ::bevy_picking::hover::DirectlyHovered, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_simplified_mesh_functions(world: &mut World) { +pub(crate) fn register_pointer_input_settings_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::mesh_picking::ray_cast::SimplifiedMesh, + ::bevy_picking::input::PointerInputSettings, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_picking::mesh_picking::ray_cast::SimplifiedMesh>| { - let output: Val< - ::bevy_picking::mesh_picking::ray_cast::SimplifiedMesh, - > = { + |_self: Ref<::bevy_picking::input::PointerInputSettings>| { + let output: Val<::bevy_picking::input::PointerInputSettings> = { { - let output: Val< - ::bevy_picking::mesh_picking::ray_cast::SimplifiedMesh, - > = <::bevy_picking::mesh_picking::ray_cast::SimplifiedMesh as ::std::clone::Clone>::clone( + let output: Val<::bevy_picking::input::PointerInputSettings> = <::bevy_picking::input::PointerInputSettings as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1849,7 +1974,7 @@ pub(crate) fn register_simplified_mesh_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::mesh_picking::ray_cast::SimplifiedMesh, + ::bevy_picking::input::PointerInputSettings, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -1915,6 +2040,39 @@ pub(crate) fn register_backfaces_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } +pub(crate) fn register_simplified_mesh_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_picking::mesh_picking::ray_cast::SimplifiedMesh, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_picking::mesh_picking::ray_cast::SimplifiedMesh>| { + let output: Val< + ::bevy_picking::mesh_picking::ray_cast::SimplifiedMesh, + > = { + { + let output: Val< + ::bevy_picking::mesh_picking::ray_cast::SimplifiedMesh, + > = <::bevy_picking::mesh_picking::ray_cast::SimplifiedMesh as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_picking::mesh_picking::ray_cast::SimplifiedMesh, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} pub(crate) fn register_press_direction_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_picking::pointer::PressDirection, @@ -1984,25 +2142,19 @@ pub(crate) fn register_press_direction_functions(world: &mut World) { impl Plugin for BevyPickingScriptingPlugin { fn build(&self, app: &mut App) { let mut world = app.world_mut(); + register_release_functions(&mut world); register_ray_cast_backfaces_functions(&mut world); register_ray_cast_visibility_functions(&mut world); register_mesh_picking_camera_functions(&mut world); register_mesh_picking_settings_functions(&mut world); - register_pointer_input_plugin_functions(&mut world); register_pointer_button_functions(&mut world); register_pickable_functions(&mut world); - register_picking_plugin_functions(&mut world); + register_picking_settings_functions(&mut world); register_pointer_input_functions(&mut world); register_pointer_hits_functions(&mut world); - register_picking_interaction_functions(&mut world); - register_pointer_id_functions(&mut world); - register_pointer_location_functions(&mut world); - register_pointer_press_functions(&mut world); - register_pointer_interaction_functions(&mut world); - register_ray_id_functions(&mut world); register_cancel_functions(&mut world); register_click_functions(&mut world); - register_pressed_functions(&mut world); + register_press_functions(&mut world); register_drag_drop_functions(&mut world); register_drag_end_functions(&mut world); register_drag_enter_functions(&mut world); @@ -2013,15 +2165,23 @@ impl Plugin for BevyPickingScriptingPlugin { register_move_functions(&mut world); register_out_functions(&mut world); register_over_functions(&mut world); - register_released_functions(&mut world); register_scroll_functions(&mut world); register_hit_data_functions(&mut world); + register_pointer_id_functions(&mut world); + register_pointer_location_functions(&mut world); + register_ray_id_functions(&mut world); register_location_functions(&mut world); register_pointer_action_functions(&mut world); register_drag_entry_functions(&mut world); - register_simplified_mesh_functions(&mut world); + register_pointer_interaction_functions(&mut world); + register_pointer_press_functions(&mut world); + register_picking_interaction_functions(&mut world); + register_hovered_functions(&mut world); + register_directly_hovered_functions(&mut world); + register_pointer_input_settings_functions(&mut world); register_ray_mesh_hit_functions(&mut world); register_backfaces_functions(&mut world); + register_simplified_mesh_functions(&mut world); register_press_direction_functions(&mut world); } } diff --git a/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml b/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml new file mode 100644 index 0000000000..a694159e18 --- /dev/null +++ b/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml @@ -0,0 +1,59 @@ +[package] +name = "bevy_post_process_bms_bindings" +description = "Automatically generated bindings for bevy_post_process crate" +readme = "README.md" +version.workspace = true +edition.workspace = true +authors.workspace = true +license.workspace = true +homepage.workspace = true +repository.workspace = true +keywords.workspace = true +categories.workspace = true + +[dependencies] + + +bevy_mod_scripting_core = { workspace = true } +bevy_mod_scripting_bindings = { workspace = true } +bevy_mod_scripting_derive = { workspace = true } +bevy_post_process = { version = "0.17.2", features = [], default-features = true} + + +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} + +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} + +bevy_camera = { version = "^0.17.2", features = [], default-features = true} + +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} + +bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} + +bevy_derive = { version = "^0.17.2", features = [], default-features = true} + +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} + +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} + +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} + +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} + +bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} + +bevy_shader = { version = "^0.17.2", features = [], default-features = true} + +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} + +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} + +bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} + +bitflags = { version = "^2.3", features = [], default-features = true} + +nonmax = { version = "^0.5", features = [], default-features = true} + +radsort = { version = "^0.1", features = [], default-features = true} + + diff --git a/crates/bindings/bevy_post_process_bms_bindings/README.md b/crates/bindings/bevy_post_process_bms_bindings/README.md new file mode 100644 index 0000000000..b59cbf9db5 --- /dev/null +++ b/crates/bindings/bevy_post_process_bms_bindings/README.md @@ -0,0 +1,4 @@ +# bevy_post_process bindings +This crate is part of the [bevy_mod_scripting](http://github.com/makspll/bevy_mod_scripting) project. + +The code inside is fully generated via a custom rustc plugin. \ No newline at end of file diff --git a/crates/bindings/bevy_post_process_bms_bindings/src/lib.rs b/crates/bindings/bevy_post_process_bms_bindings/src/lib.rs new file mode 100644 index 0000000000..ac0cb0ad90 --- /dev/null +++ b/crates/bindings/bevy_post_process_bms_bindings/src/lib.rs @@ -0,0 +1,363 @@ +#![allow(clippy::all)] +#![allow(unused, deprecated, dead_code)] + +use bevy_app::{App, Plugin}; +use bevy_ecs::prelude::*; +use bevy_mod_scripting_bindings::{ + ReflectReference, + function::{ + from::{Mut, Ref, Val}, + namespace::NamespaceBuilder, + }, +}; +use bevy_mod_scripting_derive::script_bindings; +pub struct BevyPostProcessScriptingPlugin; +pub(crate) fn register_auto_exposure_compensation_curve_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_post_process::auto_exposure::AutoExposureCompensationCurve, + >::new(world) + .register_documented( + "clone", + | + _self: Ref< + ::bevy_post_process::auto_exposure::AutoExposureCompensationCurve, + >| + { + let output: Val< + ::bevy_post_process::auto_exposure::AutoExposureCompensationCurve, + > = { + { + let output: Val< + ::bevy_post_process::auto_exposure::AutoExposureCompensationCurve, + > = <::bevy_post_process::auto_exposure::AutoExposureCompensationCurve as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_post_process::auto_exposure::AutoExposureCompensationCurve, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_auto_exposure_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_post_process::auto_exposure::AutoExposure, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_post_process::auto_exposure::AutoExposure>| { + let output: Val<::bevy_post_process::auto_exposure::AutoExposure> = { + { + let output: Val< + ::bevy_post_process::auto_exposure::AutoExposure, + > = <::bevy_post_process::auto_exposure::AutoExposure as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_post_process::auto_exposure::AutoExposure, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_bloom_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_post_process::bloom::Bloom, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_post_process::bloom::Bloom>| { + let output: Val<::bevy_post_process::bloom::Bloom> = { + { + let output: Val<::bevy_post_process::bloom::Bloom> = + <::bevy_post_process::bloom::Bloom as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_post_process::bloom::Bloom, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_bloom_composite_mode_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_post_process::bloom::BloomCompositeMode, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_post_process::bloom::BloomCompositeMode>| { + let output: () = { + { + let output: () = <::bevy_post_process::bloom::BloomCompositeMode as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_post_process::bloom::BloomCompositeMode>| { + let output: Val<::bevy_post_process::bloom::BloomCompositeMode> = { + { + let output: Val< + ::bevy_post_process::bloom::BloomCompositeMode, + > = <::bevy_post_process::bloom::BloomCompositeMode as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_post_process::bloom::BloomCompositeMode>, + other: Ref<::bevy_post_process::bloom::BloomCompositeMode>| + { + let output: bool = { + { + let output: bool = <::bevy_post_process::bloom::BloomCompositeMode as ::std::cmp::PartialEq< + ::bevy_post_process::bloom::BloomCompositeMode, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_post_process::bloom::BloomCompositeMode, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_bloom_prefilter_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_post_process::bloom::BloomPrefilter, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_post_process::bloom::BloomPrefilter>| { + let output: Val<::bevy_post_process::bloom::BloomPrefilter> = { + { + let output: Val<::bevy_post_process::bloom::BloomPrefilter> = + <::bevy_post_process::bloom::BloomPrefilter as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_post_process::bloom::BloomPrefilter, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_depth_of_field_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_post_process::dof::DepthOfField, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_post_process::dof::DepthOfField>| { + let output: Val<::bevy_post_process::dof::DepthOfField> = { + { + let output: Val<::bevy_post_process::dof::DepthOfField> = + <::bevy_post_process::dof::DepthOfField as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_post_process::dof::DepthOfField, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_depth_of_field_mode_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_post_process::dof::DepthOfFieldMode, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_post_process::dof::DepthOfFieldMode>| { + let output: Val<::bevy_post_process::dof::DepthOfFieldMode> = { + { + let output: Val<::bevy_post_process::dof::DepthOfFieldMode> = + <::bevy_post_process::dof::DepthOfFieldMode as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_post_process::dof::DepthOfFieldMode>, + other: Ref<::bevy_post_process::dof::DepthOfFieldMode>| { + let output: bool = { + { + let output: bool = + <::bevy_post_process::dof::DepthOfFieldMode as ::std::cmp::PartialEq< + ::bevy_post_process::dof::DepthOfFieldMode, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_post_process::dof::DepthOfFieldMode, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_chromatic_aberration_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_post_process::effect_stack::ChromaticAberration, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_post_process::effect_stack::ChromaticAberration>| { + let output: Val< + ::bevy_post_process::effect_stack::ChromaticAberration, + > = { + { + let output: Val< + ::bevy_post_process::effect_stack::ChromaticAberration, + > = <::bevy_post_process::effect_stack::ChromaticAberration as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_post_process::effect_stack::ChromaticAberration, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_motion_blur_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_post_process::motion_blur::MotionBlur, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_post_process::motion_blur::MotionBlur>| { + let output: Val<::bevy_post_process::motion_blur::MotionBlur> = { + { + let output: Val<::bevy_post_process::motion_blur::MotionBlur> = <::bevy_post_process::motion_blur::MotionBlur as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_post_process::motion_blur::MotionBlur, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +impl Plugin for BevyPostProcessScriptingPlugin { + fn build(&self, app: &mut App) { + let mut world = app.world_mut(); + register_auto_exposure_compensation_curve_functions(&mut world); + register_auto_exposure_functions(&mut world); + register_bloom_functions(&mut world); + register_bloom_composite_mode_functions(&mut world); + register_bloom_prefilter_functions(&mut world); + register_depth_of_field_functions(&mut world); + register_depth_of_field_mode_functions(&mut world); + register_chromatic_aberration_functions(&mut world); + register_motion_blur_functions(&mut world); + } +} diff --git a/crates/bindings/bevy_reflect_bms_bindings/Cargo.toml b/crates/bindings/bevy_reflect_bms_bindings/Cargo.toml index 4bf85cf9fb..1fb53448a4 100644 --- a/crates/bindings/bevy_reflect_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_reflect_bms_bindings/Cargo.toml @@ -17,45 +17,31 @@ bevy_app = { workspace = true, features = ["std"] } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_reflect = { version = "0.16.1", features = [ - "glam", - "uuid", - "smol_str", - "std", - "smallvec", - "debug", - "debug_stack", -], default-features = true } +bevy_reflect = { version = "0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} -assert_type_match = { version = "^0.1.1", features = [ -], default-features = true } +assert_type_match = { version = "^0.1.1", features = [], default-features = true} -bevy_platform = { version = "^0.16.1", features = [ - "std", -], default-features = false } +bevy_platform = { version = "^0.17.2", features = ["std", "alloc", "serialize"], default-features = true} -bevy_ptr = { version = "^0.16.1", features = [], default-features = true } +bevy_ptr = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect_derive = { version = "^0.16.1", features = [ -], default-features = true } +bevy_reflect_derive = { version = "^0.17.2", features = ["auto_register_inventory", "auto_register"], default-features = true} -bevy_utils = { version = "^0.16.1", features = [ - "std", -], default-features = false } +downcast-rs = { version = "^2", features = ["std"], default-features = false} -downcast-rs = { version = "^2", features = ["std"], default-features = false } +erased-serde = { version = "^0.4", features = ["std"], default-features = false} -erased-serde = { version = "^0.4", features = [ - "std", -], default-features = false } +glam = { version = "^0.30.1", features = ["std"], default-features = false} -glam = { version = "^0.29.3", features = ["std"], default-features = false } +inventory = { version = "^0.3", features = [], default-features = true} -serde = { version = "^1", features = ["std"], default-features = false } +serde = { version = "^1", features = ["std"], default-features = false} -smol_str = { version = "^0.2.0", features = ["std"], default-features = false } +smol_str = { version = "^0.2.0", features = ["std"], default-features = false} + +uuid = { version = "^1.13.1", features = ["std"], default-features = false} + +variadics_please = { version = "^1.1", features = [], default-features = true} -uuid = { version = "^1.13.1", features = ["std"], default-features = false } -variadics_please = { version = "^1.1", features = [], default-features = true } diff --git a/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs b/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs index 109a9035d3..f750820671 100644 --- a/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs @@ -14,14 +14,18 @@ use bevy_mod_scripting_derive::script_bindings; pub struct BevyReflectScriptingPlugin; pub(crate) fn register_atomic_bool_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::core::sync::atomic::AtomicBool, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool, >::new(world) .register_documented( "into_inner", - |_self: Val<::core::sync::atomic::AtomicBool>| { + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool, + >| + { let output: bool = { { - let output: bool = ::core::sync::atomic::AtomicBool::into_inner( + let output: bool = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool::into_inner( _self.into_inner(), ) .into(); @@ -36,9 +40,13 @@ pub(crate) fn register_atomic_bool_functions(world: &mut World) { .register_documented( "new", |v: bool| { - let output: Val<::core::sync::atomic::AtomicBool> = { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool, + > = { { - let output: Val<::core::sync::atomic::AtomicBool> = ::core::sync::atomic::AtomicBool::new( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool::new( v, ) .into(); @@ -54,20 +62,24 @@ pub(crate) fn register_atomic_bool_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::core::sync::atomic::AtomicBool, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_atomic_i_16_functions(world: &mut World) { +pub(crate) fn register_atomic_i_8_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::core::sync::atomic::AtomicI16, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8, >::new(world) .register_documented( "into_inner", - |_self: Val<::core::sync::atomic::AtomicI16>| { - let output: i16 = { + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8, + >| + { + let output: i8 = { { - let output: i16 = ::core::sync::atomic::AtomicI16::into_inner( + let output: i8 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8::into_inner( _self.into_inner(), ) .into(); @@ -76,15 +88,19 @@ pub(crate) fn register_atomic_i_16_functions(world: &mut World) { }; output }, - " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicI16;\nlet some_var = AtomicI16::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", + " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicI8;\nlet some_var = AtomicI8::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", &["_self"], ) .register_documented( "new", - |v: i16| { - let output: Val<::core::sync::atomic::AtomicI16> = { + |v: i8| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8, + > = { { - let output: Val<::core::sync::atomic::AtomicI16> = ::core::sync::atomic::AtomicI16::new( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8::new( v, ) .into(); @@ -93,27 +109,31 @@ pub(crate) fn register_atomic_i_16_functions(world: &mut World) { }; output }, - " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicI16;\nlet atomic_forty_two = AtomicI16::new(42);\n ```", + " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicI8;\nlet atomic_forty_two = AtomicI8::new(42);\n ```", &["v"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::core::sync::atomic::AtomicI16, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_atomic_i_32_functions(world: &mut World) { +pub(crate) fn register_atomic_i_16_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::core::sync::atomic::AtomicI32, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16, >::new(world) .register_documented( "into_inner", - |_self: Val<::core::sync::atomic::AtomicI32>| { - let output: i32 = { + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16, + >| + { + let output: i16 = { { - let output: i32 = ::core::sync::atomic::AtomicI32::into_inner( + let output: i16 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16::into_inner( _self.into_inner(), ) .into(); @@ -122,15 +142,19 @@ pub(crate) fn register_atomic_i_32_functions(world: &mut World) { }; output }, - " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicI32;\nlet some_var = AtomicI32::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", + " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicI16;\nlet some_var = AtomicI16::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", &["_self"], ) .register_documented( "new", - |v: i32| { - let output: Val<::core::sync::atomic::AtomicI32> = { + |v: i16| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16, + > = { { - let output: Val<::core::sync::atomic::AtomicI32> = ::core::sync::atomic::AtomicI32::new( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16::new( v, ) .into(); @@ -139,27 +163,31 @@ pub(crate) fn register_atomic_i_32_functions(world: &mut World) { }; output }, - " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicI32;\nlet atomic_forty_two = AtomicI32::new(42);\n ```", + " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicI16;\nlet atomic_forty_two = AtomicI16::new(42);\n ```", &["v"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::core::sync::atomic::AtomicI32, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_atomic_i_64_functions(world: &mut World) { +pub(crate) fn register_atomic_i_32_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::core::sync::atomic::AtomicI64, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32, >::new(world) .register_documented( "into_inner", - |_self: Val<::core::sync::atomic::AtomicI64>| { - let output: i64 = { + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32, + >| + { + let output: i32 = { { - let output: i64 = ::core::sync::atomic::AtomicI64::into_inner( + let output: i32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32::into_inner( _self.into_inner(), ) .into(); @@ -168,15 +196,19 @@ pub(crate) fn register_atomic_i_64_functions(world: &mut World) { }; output }, - " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicI64;\nlet some_var = AtomicI64::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", + " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicI32;\nlet some_var = AtomicI32::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", &["_self"], ) .register_documented( "new", - |v: i64| { - let output: Val<::core::sync::atomic::AtomicI64> = { + |v: i32| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32, + > = { { - let output: Val<::core::sync::atomic::AtomicI64> = ::core::sync::atomic::AtomicI64::new( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32::new( v, ) .into(); @@ -185,27 +217,31 @@ pub(crate) fn register_atomic_i_64_functions(world: &mut World) { }; output }, - " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicI64;\nlet atomic_forty_two = AtomicI64::new(42);\n ```", + " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicI32;\nlet atomic_forty_two = AtomicI32::new(42);\n ```", &["v"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::core::sync::atomic::AtomicI64, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_atomic_i_8_functions(world: &mut World) { +pub(crate) fn register_atomic_i_64_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::core::sync::atomic::AtomicI8, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64, >::new(world) .register_documented( "into_inner", - |_self: Val<::core::sync::atomic::AtomicI8>| { - let output: i8 = { + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64, + >| + { + let output: i64 = { { - let output: i8 = ::core::sync::atomic::AtomicI8::into_inner( + let output: i64 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64::into_inner( _self.into_inner(), ) .into(); @@ -214,15 +250,19 @@ pub(crate) fn register_atomic_i_8_functions(world: &mut World) { }; output }, - " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicI8;\nlet some_var = AtomicI8::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", + " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicI64;\nlet some_var = AtomicI64::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", &["_self"], ) .register_documented( "new", - |v: i8| { - let output: Val<::core::sync::atomic::AtomicI8> = { + |v: i64| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64, + > = { { - let output: Val<::core::sync::atomic::AtomicI8> = ::core::sync::atomic::AtomicI8::new( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64::new( v, ) .into(); @@ -231,27 +271,31 @@ pub(crate) fn register_atomic_i_8_functions(world: &mut World) { }; output }, - " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicI8;\nlet atomic_forty_two = AtomicI8::new(42);\n ```", + " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicI64;\nlet atomic_forty_two = AtomicI64::new(42);\n ```", &["v"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::core::sync::atomic::AtomicI8, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_atomic_isize_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::core::sync::atomic::AtomicIsize, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize, >::new(world) .register_documented( "into_inner", - |_self: Val<::core::sync::atomic::AtomicIsize>| { + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize, + >| + { let output: isize = { { - let output: isize = ::core::sync::atomic::AtomicIsize::into_inner( + let output: isize = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize::into_inner( _self.into_inner(), ) .into(); @@ -266,9 +310,13 @@ pub(crate) fn register_atomic_isize_functions(world: &mut World) { .register_documented( "new", |v: isize| { - let output: Val<::core::sync::atomic::AtomicIsize> = { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize, + > = { { - let output: Val<::core::sync::atomic::AtomicIsize> = ::core::sync::atomic::AtomicIsize::new( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize::new( v, ) .into(); @@ -284,20 +332,24 @@ pub(crate) fn register_atomic_isize_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::core::sync::atomic::AtomicIsize, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_atomic_u_16_functions(world: &mut World) { +pub(crate) fn register_atomic_u_8_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::core::sync::atomic::AtomicU16, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8, >::new(world) .register_documented( "into_inner", - |_self: Val<::core::sync::atomic::AtomicU16>| { - let output: u16 = { + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8, + >| + { + let output: u8 = { { - let output: u16 = ::core::sync::atomic::AtomicU16::into_inner( + let output: u8 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8::into_inner( _self.into_inner(), ) .into(); @@ -306,15 +358,19 @@ pub(crate) fn register_atomic_u_16_functions(world: &mut World) { }; output }, - " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicU16;\nlet some_var = AtomicU16::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", + " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicU8;\nlet some_var = AtomicU8::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", &["_self"], ) .register_documented( "new", - |v: u16| { - let output: Val<::core::sync::atomic::AtomicU16> = { + |v: u8| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8, + > = { { - let output: Val<::core::sync::atomic::AtomicU16> = ::core::sync::atomic::AtomicU16::new( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8::new( v, ) .into(); @@ -323,27 +379,31 @@ pub(crate) fn register_atomic_u_16_functions(world: &mut World) { }; output }, - " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicU16;\nlet atomic_forty_two = AtomicU16::new(42);\n ```", + " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicU8;\nlet atomic_forty_two = AtomicU8::new(42);\n ```", &["v"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::core::sync::atomic::AtomicU16, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_atomic_u_32_functions(world: &mut World) { +pub(crate) fn register_atomic_u_16_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::core::sync::atomic::AtomicU32, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16, >::new(world) .register_documented( "into_inner", - |_self: Val<::core::sync::atomic::AtomicU32>| { - let output: u32 = { + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16, + >| + { + let output: u16 = { { - let output: u32 = ::core::sync::atomic::AtomicU32::into_inner( + let output: u16 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16::into_inner( _self.into_inner(), ) .into(); @@ -352,15 +412,19 @@ pub(crate) fn register_atomic_u_32_functions(world: &mut World) { }; output }, - " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicU32;\nlet some_var = AtomicU32::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", + " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicU16;\nlet some_var = AtomicU16::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", &["_self"], ) .register_documented( "new", - |v: u32| { - let output: Val<::core::sync::atomic::AtomicU32> = { + |v: u16| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16, + > = { { - let output: Val<::core::sync::atomic::AtomicU32> = ::core::sync::atomic::AtomicU32::new( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16::new( v, ) .into(); @@ -369,27 +433,31 @@ pub(crate) fn register_atomic_u_32_functions(world: &mut World) { }; output }, - " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicU32;\nlet atomic_forty_two = AtomicU32::new(42);\n ```", + " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicU16;\nlet atomic_forty_two = AtomicU16::new(42);\n ```", &["v"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::core::sync::atomic::AtomicU32, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_atomic_u_64_functions(world: &mut World) { +pub(crate) fn register_atomic_u_32_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::core::sync::atomic::AtomicU64, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32, >::new(world) .register_documented( "into_inner", - |_self: Val<::core::sync::atomic::AtomicU64>| { - let output: u64 = { + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32, + >| + { + let output: u32 = { { - let output: u64 = ::core::sync::atomic::AtomicU64::into_inner( + let output: u32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32::into_inner( _self.into_inner(), ) .into(); @@ -398,15 +466,19 @@ pub(crate) fn register_atomic_u_64_functions(world: &mut World) { }; output }, - " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicU64;\nlet some_var = AtomicU64::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", + " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicU32;\nlet some_var = AtomicU32::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", &["_self"], ) .register_documented( "new", - |v: u64| { - let output: Val<::core::sync::atomic::AtomicU64> = { + |v: u32| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32, + > = { { - let output: Val<::core::sync::atomic::AtomicU64> = ::core::sync::atomic::AtomicU64::new( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32::new( v, ) .into(); @@ -415,27 +487,31 @@ pub(crate) fn register_atomic_u_64_functions(world: &mut World) { }; output }, - " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicU64;\nlet atomic_forty_two = AtomicU64::new(42);\n ```", + " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicU32;\nlet atomic_forty_two = AtomicU32::new(42);\n ```", &["v"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::core::sync::atomic::AtomicU64, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_atomic_u_8_functions(world: &mut World) { +pub(crate) fn register_atomic_u_64_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::core::sync::atomic::AtomicU8, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64, >::new(world) .register_documented( "into_inner", - |_self: Val<::core::sync::atomic::AtomicU8>| { - let output: u8 = { + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64, + >| + { + let output: u64 = { { - let output: u8 = ::core::sync::atomic::AtomicU8::into_inner( + let output: u64 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64::into_inner( _self.into_inner(), ) .into(); @@ -444,15 +520,19 @@ pub(crate) fn register_atomic_u_8_functions(world: &mut World) { }; output }, - " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicU8;\nlet some_var = AtomicU8::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", + " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicU64;\nlet some_var = AtomicU64::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", &["_self"], ) .register_documented( "new", - |v: u8| { - let output: Val<::core::sync::atomic::AtomicU8> = { + |v: u64| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64, + > = { { - let output: Val<::core::sync::atomic::AtomicU8> = ::core::sync::atomic::AtomicU8::new( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64::new( v, ) .into(); @@ -461,27 +541,31 @@ pub(crate) fn register_atomic_u_8_functions(world: &mut World) { }; output }, - " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicU8;\nlet atomic_forty_two = AtomicU8::new(42);\n ```", + " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicU64;\nlet atomic_forty_two = AtomicU64::new(42);\n ```", &["v"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::core::sync::atomic::AtomicU8, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_atomic_usize_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::core::sync::atomic::AtomicUsize, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize, >::new(world) .register_documented( "into_inner", - |_self: Val<::core::sync::atomic::AtomicUsize>| { + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize, + >| + { let output: usize = { { - let output: usize = ::core::sync::atomic::AtomicUsize::into_inner( + let output: usize = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize::into_inner( _self.into_inner(), ) .into(); @@ -496,9 +580,13 @@ pub(crate) fn register_atomic_usize_functions(world: &mut World) { .register_documented( "new", |v: usize| { - let output: Val<::core::sync::atomic::AtomicUsize> = { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize, + > = { { - let output: Val<::core::sync::atomic::AtomicUsize> = ::core::sync::atomic::AtomicUsize::new( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize::new( v, ) .into(); @@ -514,20 +602,31 @@ pub(crate) fn register_atomic_usize_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::core::sync::atomic::AtomicUsize, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_duration_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::core::time::Duration, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, >::new(world) .register_documented( "abs_diff", - |_self: Val<::core::time::Duration>, other: Val<::core::time::Duration>| { - let output: Val<::core::time::Duration> = { + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + other: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::abs_diff( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::abs_diff( _self.into_inner(), other.into_inner(), ) @@ -542,11 +641,22 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "add", - |_self: Val<::core::time::Duration>, rhs: Val<::core::time::Duration>| { - let output: Val<::core::time::Duration> = { - { - let output: Val<::core::time::Duration> = <::core::time::Duration as ::core::ops::Add< - ::core::time::Duration, + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + rhs: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output @@ -559,10 +669,16 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "as_micros", - |_self: Ref<::core::time::Duration>| { + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { let output: u128 = { { - let output: u128 = ::core::time::Duration::as_micros(&_self) + let output: u128 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_micros( + &_self, + ) .into(); output } @@ -574,10 +690,16 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "as_millis", - |_self: Ref<::core::time::Duration>| { + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { let output: u128 = { { - let output: u128 = ::core::time::Duration::as_millis(&_self) + let output: u128 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_millis( + &_self, + ) .into(); output } @@ -589,10 +711,16 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "as_nanos", - |_self: Ref<::core::time::Duration>| { + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { let output: u128 = { { - let output: u128 = ::core::time::Duration::as_nanos(&_self) + let output: u128 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_nanos( + &_self, + ) .into(); output } @@ -604,10 +732,17 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "as_secs", - |_self: Ref<::core::time::Duration>| { + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { let output: u64 = { { - let output: u64 = ::core::time::Duration::as_secs(&_self).into(); + let output: u64 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_secs( + &_self, + ) + .into(); output } }; @@ -618,10 +753,16 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "as_secs_f32", - |_self: Ref<::core::time::Duration>| { + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { let output: f32 = { { - let output: f32 = ::core::time::Duration::as_secs_f32(&_self) + let output: f32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_secs_f32( + &_self, + ) .into(); output } @@ -633,10 +774,16 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "as_secs_f64", - |_self: Ref<::core::time::Duration>| { + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { let output: f64 = { { - let output: f64 = ::core::time::Duration::as_secs_f64(&_self) + let output: f64 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_secs_f64( + &_self, + ) .into(); output } @@ -648,10 +795,14 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::core::time::Duration>| { + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { let output: () = { { - let output: () = <::core::time::Duration as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -665,10 +816,18 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::core::time::Duration>| { - let output: Val<::core::time::Duration> = { + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { { - let output: Val<::core::time::Duration> = <::core::time::Duration as ::core::clone::Clone>::clone( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -682,10 +841,19 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "div", - |_self: Val<::core::time::Duration>, rhs: u32| { - let output: Val<::core::time::Duration> = { + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + rhs: u32| + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { { - let output: Val<::core::time::Duration> = <::core::time::Duration as ::core::ops::Div< + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< u32, >>::div(_self.into_inner(), rhs) .into(); @@ -699,10 +867,17 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "div_duration_f32", - |_self: Val<::core::time::Duration>, rhs: Val<::core::time::Duration>| { + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + rhs: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { let output: f32 = { { - let output: f32 = ::core::time::Duration::div_duration_f32( + let output: f32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::div_duration_f32( _self.into_inner(), rhs.into_inner(), ) @@ -717,10 +892,17 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "div_duration_f64", - |_self: Val<::core::time::Duration>, rhs: Val<::core::time::Duration>| { + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + rhs: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { let output: f64 = { { - let output: f64 = ::core::time::Duration::div_duration_f64( + let output: f64 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::div_duration_f64( _self.into_inner(), rhs.into_inner(), ) @@ -735,10 +917,19 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "div_f32", - |_self: Val<::core::time::Duration>, rhs: f32| { - let output: Val<::core::time::Duration> = { + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + rhs: f32| + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::div_f32( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::div_f32( _self.into_inner(), rhs, ) @@ -753,10 +944,19 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "div_f64", - |_self: Val<::core::time::Duration>, rhs: f64| { - let output: Val<::core::time::Duration> = { + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + rhs: f64| + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::div_f64( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::div_f64( _self.into_inner(), rhs, ) @@ -771,11 +971,18 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "eq", - |_self: Ref<::core::time::Duration>, other: Ref<::core::time::Duration>| { + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + other: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { let output: bool = { { - let output: bool = <::core::time::Duration as ::core::cmp::PartialEq< - ::core::time::Duration, + let output: bool = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, >>::eq(&_self, &other) .into(); output @@ -786,12 +993,37 @@ pub(crate) fn register_duration_functions(world: &mut World) { "", &["_self", "other"], ) + .register_documented( + "from_hours", + |hours: u64| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_hours( + hours, + ) + .into(); + output + } + }; + output + }, + " Creates a new `Duration` from the specified number of hours.\n # Panics\n Panics if the given number of hours overflows the `Duration` size.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_hours(6);\n assert_eq!(6 * 60 * 60, duration.as_secs());\n assert_eq!(0, duration.subsec_nanos());\n ```", + &["hours"], + ) .register_documented( "from_micros", |micros: u64| { - let output: Val<::core::time::Duration> = { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::from_micros( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_micros( micros, ) .into(); @@ -806,9 +1038,13 @@ pub(crate) fn register_duration_functions(world: &mut World) { .register_documented( "from_millis", |millis: u64| { - let output: Val<::core::time::Duration> = { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::from_millis( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_millis( millis, ) .into(); @@ -820,12 +1056,37 @@ pub(crate) fn register_duration_functions(world: &mut World) { " Creates a new `Duration` from the specified number of milliseconds.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_millis(2_569);\n assert_eq!(2, duration.as_secs());\n assert_eq!(569_000_000, duration.subsec_nanos());\n ```", &["millis"], ) + .register_documented( + "from_mins", + |mins: u64| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_mins( + mins, + ) + .into(); + output + } + }; + output + }, + " Creates a new `Duration` from the specified number of minutes.\n # Panics\n Panics if the given number of minutes overflows the `Duration` size.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_mins(10);\n assert_eq!(10 * 60, duration.as_secs());\n assert_eq!(0, duration.subsec_nanos());\n ```", + &["mins"], + ) .register_documented( "from_nanos", |nanos: u64| { - let output: Val<::core::time::Duration> = { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::from_nanos( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_nanos( nanos, ) .into(); @@ -840,9 +1101,13 @@ pub(crate) fn register_duration_functions(world: &mut World) { .register_documented( "from_secs", |secs: u64| { - let output: Val<::core::time::Duration> = { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::from_secs( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_secs( secs, ) .into(); @@ -857,9 +1122,13 @@ pub(crate) fn register_duration_functions(world: &mut World) { .register_documented( "from_secs_f32", |secs: f32| { - let output: Val<::core::time::Duration> = { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::from_secs_f32( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_secs_f32( secs, ) .into(); @@ -874,9 +1143,13 @@ pub(crate) fn register_duration_functions(world: &mut World) { .register_documented( "from_secs_f64", |secs: f64| { - let output: Val<::core::time::Duration> = { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::from_secs_f64( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_secs_f64( secs, ) .into(); @@ -890,10 +1163,16 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "is_zero", - |_self: Ref<::core::time::Duration>| { + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { let output: bool = { { - let output: bool = ::core::time::Duration::is_zero(&_self) + let output: bool = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::is_zero( + &_self, + ) .into(); output } @@ -905,10 +1184,19 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "mul", - |_self: Val<::core::time::Duration>, rhs: u32| { - let output: Val<::core::time::Duration> = { + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + rhs: u32| + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { { - let output: Val<::core::time::Duration> = <::core::time::Duration as ::core::ops::Mul< + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< u32, >>::mul(_self.into_inner(), rhs) .into(); @@ -922,10 +1210,19 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "mul_f32", - |_self: Val<::core::time::Duration>, rhs: f32| { - let output: Val<::core::time::Duration> = { + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + rhs: f32| + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::mul_f32( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::mul_f32( _self.into_inner(), rhs, ) @@ -940,10 +1237,19 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "mul_f64", - |_self: Val<::core::time::Duration>, rhs: f64| { - let output: Val<::core::time::Duration> = { + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + rhs: f64| + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::mul_f64( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::mul_f64( _self.into_inner(), rhs, ) @@ -959,9 +1265,13 @@ pub(crate) fn register_duration_functions(world: &mut World) { .register_documented( "new", |secs: u64, nanos: u32| { - let output: Val<::core::time::Duration> = { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::new( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::new( secs, nanos, ) @@ -976,10 +1286,21 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "saturating_add", - |_self: Val<::core::time::Duration>, rhs: Val<::core::time::Duration>| { - let output: Val<::core::time::Duration> = { + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + rhs: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::saturating_add( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -994,10 +1315,19 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "saturating_mul", - |_self: Val<::core::time::Duration>, rhs: u32| { - let output: Val<::core::time::Duration> = { + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + rhs: u32| + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::saturating_mul( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::saturating_mul( _self.into_inner(), rhs, ) @@ -1012,10 +1342,21 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "saturating_sub", - |_self: Val<::core::time::Duration>, rhs: Val<::core::time::Duration>| { - let output: Val<::core::time::Duration> = { + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + rhs: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::saturating_sub( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -1030,11 +1371,22 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "sub", - |_self: Val<::core::time::Duration>, rhs: Val<::core::time::Duration>| { - let output: Val<::core::time::Duration> = { - { - let output: Val<::core::time::Duration> = <::core::time::Duration as ::core::ops::Sub< - ::core::time::Duration, + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + rhs: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output @@ -1047,10 +1399,16 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "subsec_micros", - |_self: Ref<::core::time::Duration>| { + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { let output: u32 = { { - let output: u32 = ::core::time::Duration::subsec_micros(&_self) + let output: u32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::subsec_micros( + &_self, + ) .into(); output } @@ -1062,10 +1420,16 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "subsec_millis", - |_self: Ref<::core::time::Duration>| { + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { let output: u32 = { { - let output: u32 = ::core::time::Duration::subsec_millis(&_self) + let output: u32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::subsec_millis( + &_self, + ) .into(); output } @@ -1077,10 +1441,16 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "subsec_nanos", - |_self: Ref<::core::time::Duration>| { + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { let output: u32 = { { - let output: u32 = ::core::time::Duration::subsec_nanos(&_self) + let output: u32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::subsec_nanos( + &_self, + ) .into(); output } @@ -1093,8 +1463,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::core::time::Duration, bevy_mod_scripting_bindings::MarkAsGenerated>( - ); + .register_type_data::< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_instant_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -1102,11 +1474,16 @@ pub(crate) fn register_instant_functions(world: &mut World) { >::new(world) .register_documented( "add", - |_self: Val<::std::time::Instant>, other: Val<::core::time::Duration>| { + | + _self: Val<::std::time::Instant>, + other: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { let output: Val<::std::time::Instant> = { { - let output: Val<::std::time::Instant> = <::std::time::Instant as ::core::ops::Add< - ::core::time::Duration, + let output: Val<::std::time::Instant> = <::std::time::Instant as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, >>::add(_self.into_inner(), other.into_inner()) .into(); output @@ -1122,7 +1499,7 @@ pub(crate) fn register_instant_functions(world: &mut World) { |_self: Ref<::std::time::Instant>| { let output: () = { { - let output: () = <::std::time::Instant as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::std::time::Instant as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -1139,7 +1516,7 @@ pub(crate) fn register_instant_functions(world: &mut World) { |_self: Ref<::std::time::Instant>| { let output: Val<::std::time::Instant> = { { - let output: Val<::std::time::Instant> = <::std::time::Instant as ::core::clone::Clone>::clone( + let output: Val<::std::time::Instant> = <::std::time::Instant as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -1154,9 +1531,13 @@ pub(crate) fn register_instant_functions(world: &mut World) { .register_documented( "duration_since", |_self: Ref<::std::time::Instant>, earlier: Val<::std::time::Instant>| { - let output: Val<::core::time::Duration> = { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { { - let output: Val<::core::time::Duration> = ::std::time::Instant::duration_since( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::std::time::Instant::duration_since( &_self, earlier.into_inner(), ) @@ -1172,12 +1553,13 @@ pub(crate) fn register_instant_functions(world: &mut World) { .register_documented( "elapsed", |_self: Ref<::std::time::Instant>| { - let output: Val<::core::time::Duration> = { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { { - let output: Val<::core::time::Duration> = ::std::time::Instant::elapsed( - &_self, - ) - .into(); + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::std::time::Instant::elapsed(&_self).into(); output } }; @@ -1191,7 +1573,7 @@ pub(crate) fn register_instant_functions(world: &mut World) { |_self: Ref<::std::time::Instant>, other: Ref<::std::time::Instant>| { let output: bool = { { - let output: bool = <::std::time::Instant as ::core::cmp::PartialEq< + let output: bool = <::std::time::Instant as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::std::time::Instant, >>::eq(&_self, &other) .into(); @@ -1221,9 +1603,13 @@ pub(crate) fn register_instant_functions(world: &mut World) { .register_documented( "saturating_duration_since", |_self: Ref<::std::time::Instant>, earlier: Val<::std::time::Instant>| { - let output: Val<::core::time::Duration> = { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { { - let output: Val<::core::time::Duration> = ::std::time::Instant::saturating_duration_since( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::std::time::Instant::saturating_duration_since( &_self, earlier.into_inner(), ) @@ -1238,11 +1624,16 @@ pub(crate) fn register_instant_functions(world: &mut World) { ) .register_documented( "sub", - |_self: Val<::std::time::Instant>, other: Val<::core::time::Duration>| { + | + _self: Val<::std::time::Instant>, + other: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { let output: Val<::std::time::Instant> = { { - let output: Val<::std::time::Instant> = <::std::time::Instant as ::core::ops::Sub< - ::core::time::Duration, + let output: Val<::std::time::Instant> = <::std::time::Instant as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, >>::sub(_self.into_inner(), other.into_inner()) .into(); output @@ -1256,9 +1647,13 @@ pub(crate) fn register_instant_functions(world: &mut World) { .register_documented( "sub", |_self: Val<::std::time::Instant>, other: Val<::std::time::Instant>| { - let output: Val<::core::time::Duration> = { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { { - let output: Val<::core::time::Duration> = <::std::time::Instant as ::core::ops::Sub< + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = <::std::time::Instant as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::std::time::Instant, >>::sub(_self.into_inner(), other.into_inner()) .into(); @@ -1277,14 +1672,18 @@ pub(crate) fn register_instant_functions(world: &mut World) { } pub(crate) fn register_range_full_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::core::ops::RangeFull, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::core::ops::RangeFull>| { + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull, + >| + { let output: () = { { - let output: () = <::core::ops::RangeFull as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -1298,10 +1697,18 @@ pub(crate) fn register_range_full_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::core::ops::RangeFull>| { - let output: Val<::core::ops::RangeFull> = { + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull, + >| + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull, + > = { { - let output: Val<::core::ops::RangeFull> = <::core::ops::RangeFull as ::core::clone::Clone>::clone( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull, + > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -1315,11 +1722,18 @@ pub(crate) fn register_range_full_functions(world: &mut World) { ) .register_documented( "eq", - |_self: Ref<::core::ops::RangeFull>, other: Ref<::core::ops::RangeFull>| { + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull, + >, + other: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull, + >| + { let output: bool = { { - let output: bool = <::core::ops::RangeFull as ::core::cmp::PartialEq< - ::core::ops::RangeFull, + let output: bool = <::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull, >>::eq(&_self, &other) .into(); output @@ -1333,67 +1747,92 @@ pub(crate) fn register_range_full_functions(world: &mut World) { let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::core::ops::RangeFull, bevy_mod_scripting_bindings::MarkAsGenerated>( - ); + .register_type_data::< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_type_id_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<::core::any::TypeId>::new( - world, - ) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::core::any::TypeId>| { - let output: () = { - { - let output: () = - <::core::any::TypeId as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::core::any::TypeId>| { - let output: Val<::core::any::TypeId> = { - { - let output: Val<::core::any::TypeId> = - <::core::any::TypeId as ::core::clone::Clone>::clone(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::core::any::TypeId>, other: Ref<::core::any::TypeId>| { - let output: bool = { - { - let output: bool = <::core::any::TypeId as ::core::cmp::PartialEq< - ::core::any::TypeId, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId, + >| + { + let output: () = { + { + let output: () = <::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId, + >| + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId, + > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId, + >, + other: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId, + >| + { + let output: bool = { + { + let output: bool = <::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::core::any::TypeId, bevy_mod_scripting_bindings::MarkAsGenerated>(); + .register_type_data::< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_quat_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -1418,12 +1857,29 @@ pub(crate) fn register_quat_functions(world: &mut World) { " Returns true if the absolute difference of all elements between `self` and `rhs`\n is less than or equal to `max_abs_diff`.\n This can be used to compare if two quaternions contain similar elements. It works\n best when comparing with a known value. The `max_abs_diff` that should be used used\n depends on the values being compared against.\n For more see\n [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/).", &["_self", "rhs", "max_abs_diff"], ) + .register_documented( + "add", + |_self: Val<::glam::Quat>, rhs: Ref<::glam::Quat>| { + let output: Val<::glam::Quat> = { + { + let output: Val<::glam::Quat> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + &::glam::Quat, + >>::add(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "add", |_self: Val<::glam::Quat>, rhs: Val<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Add< + let output: Val<::glam::Quat> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::Quat, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -1475,7 +1931,7 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Ref<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::core::clone::Clone>::clone( + let output: Val<::glam::Quat> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -1509,7 +1965,7 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: f32| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Div< + let output: Val<::glam::Quat> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -1544,7 +2000,7 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Ref<::glam::Quat>, rhs: Ref<::glam::Quat>| { let output: bool = { { - let output: bool = <::glam::Quat as ::core::cmp::PartialEq< + let output: bool = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::Quat, >>::eq(&_self, &rhs) .into(); @@ -1975,12 +2431,137 @@ pub(crate) fn register_quat_functions(world: &mut World) { " Performs a linear interpolation between `self` and `rhs` based on\n the value `s`.\n When `s` is `0.0`, the result will be equal to `self`. When `s`\n is `1.0`, the result will be equal to `rhs`.\n # Panics\n Will panic if `self` or `end` are not normalized when `glam_assert` is enabled.", &["_self", "end", "s"], ) + .register_documented( + "look_at_lh", + |eye: Val<::glam::Vec3>, center: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { + let output: Val<::glam::Quat> = { + { + let output: Val<::glam::Quat> = ::glam::Quat::look_at_lh( + eye.into_inner(), + center.into_inner(), + up.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a left-handed view matrix using a camera position, a focal point, and an up\n direction.\n For a left-handed view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`.\n # Panics\n Will panic if `up` is not normalized when `glam_assert` is enabled.", + &["eye", "center", "up"], + ) + .register_documented( + "look_at_rh", + |eye: Val<::glam::Vec3>, center: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { + let output: Val<::glam::Quat> = { + { + let output: Val<::glam::Quat> = ::glam::Quat::look_at_rh( + eye.into_inner(), + center.into_inner(), + up.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a right-handed view matrix using a camera position, an up direction, and a focal\n point.\n For a right-handed view coordinate system with `+X=right`, `+Y=up` and `+Z=back`.\n # Panics\n Will panic if `up` is not normalized when `glam_assert` is enabled.", + &["eye", "center", "up"], + ) + .register_documented( + "look_to_lh", + |dir: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { + let output: Val<::glam::Quat> = { + { + let output: Val<::glam::Quat> = ::glam::Quat::look_to_lh( + dir.into_inner(), + up.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a quaterion rotation from a facing direction and an up direction.\n For a left-handed view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`.\n # Panics\n Will panic if `up` is not normalized when `glam_assert` is enabled.", + &["dir", "up"], + ) + .register_documented( + "look_to_rh", + |dir: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { + let output: Val<::glam::Quat> = { + { + let output: Val<::glam::Quat> = ::glam::Quat::look_to_rh( + dir.into_inner(), + up.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a quaterion rotation from facing direction and an up direction.\n For a right-handed view coordinate system with `+X=right`, `+Y=up` and `+Z=back`.\n # Panics\n Will panic if `dir` and `up` are not normalized when `glam_assert` is enabled.", + &["dir", "up"], + ) + .register_documented( + "mul", + |_self: Val<::glam::Quat>, rhs: Ref<::glam::Quat>| { + let output: Val<::glam::Quat> = { + { + let output: Val<::glam::Quat> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::Quat, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::glam::Quat>, rhs: Ref<::glam::Vec3>| { + let output: Val<::glam::Vec3> = { + { + let output: Val<::glam::Vec3> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::Vec3, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::glam::Quat>, rhs: Ref<::glam::Vec3A>| { + let output: Val<::glam::Vec3A> = { + { + let output: Val<::glam::Vec3A> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::Vec3A, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "mul", |_self: Val<::glam::Quat>, rhs: Val<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Mul< + let output: Val<::glam::Quat> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Quat, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -1997,7 +2578,7 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Quat as ::core::ops::Mul< + let output: Val<::glam::Vec3> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -2014,7 +2595,7 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Quat as ::core::ops::Mul< + let output: Val<::glam::Vec3A> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Vec3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -2031,7 +2612,7 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: f32| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Mul< + let output: Val<::glam::Quat> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -2102,7 +2683,7 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Neg>::neg( + let output: Val<::glam::Quat> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -2169,12 +2750,29 @@ pub(crate) fn register_quat_functions(world: &mut World) { " Performs a spherical linear interpolation between `self` and `end`\n based on the value `s`.\n When `s` is `0.0`, the result will be equal to `self`. When `s`\n is `1.0`, the result will be equal to `end`.\n # Panics\n Will panic if `self` or `end` are not normalized when `glam_assert` is enabled.", &["_self", "end", "s"], ) + .register_documented( + "sub", + |_self: Val<::glam::Quat>, rhs: Ref<::glam::Quat>| { + let output: Val<::glam::Quat> = { + { + let output: Val<::glam::Quat> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + &::glam::Quat, + >>::sub(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "sub", |_self: Val<::glam::Quat>, rhs: Val<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Sub< + let output: Val<::glam::Quat> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::Quat, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -2301,7 +2899,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Add< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::Vec3, >>::add(_self.into_inner(), &rhs) .into(); @@ -2318,7 +2916,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Add< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::Vec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -2335,7 +2933,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Add< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< f32, >>::add(_self.into_inner(), rhs) .into(); @@ -2575,7 +3173,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { }; output }, - " Component-wise clamping of values, similar to [`f32::clamp`].\n Each element in `min` must be less-or-equal to the corresponding element in `max`.\n # Panics\n Will panic if `min` is greater than `max` when `glam_assert` is enabled.", + " Component-wise clamping of values, similar to [`f32::clamp`].\n Each element in `min` must be less-or-equal to the corresponding element in `max`.\n NaN propogation does not follow IEEE 754-2008 semantics and may differ on\n different SIMD architectures.\n # Panics\n Will panic if `min` is greater than `max` when `glam_assert` is enabled.", &["_self", "min", "max"], ) .register_documented( @@ -2638,7 +3236,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::clone::Clone>::clone( + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -2835,7 +3433,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Div< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::Vec3, >>::div(_self.into_inner(), &rhs) .into(); @@ -2852,7 +3450,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Div< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::Vec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -2869,7 +3467,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Div< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -2972,7 +3570,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Ref<::glam::Vec3>, other: Ref<::glam::Vec3>| { let output: bool = { { - let output: bool = <::glam::Vec3 as ::core::cmp::PartialEq< + let output: bool = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::Vec3, >>::eq(&_self, &other) .into(); @@ -3163,7 +3761,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { }; output }, - " Returns a bitmask with the lowest 3 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.", + " Returns a bitmask with the lowest 3 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.\n An element is negative if it has a negative sign, including -0.0, NaNs with negative sign\n bit and negative infinity.", &["_self"], ) .register_documented( @@ -3264,7 +3862,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.\n NaN propogation does not follow IEEE 754-2008 semantics for maxNum and may differ on\n different SIMD architectures.", &["_self", "rhs"], ) .register_documented( @@ -3279,7 +3877,24 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { }; output }, - " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", + " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.\n NaN propogation does not follow IEEE 754-2008 semantics and may differ on\n different SIMD architectures.", + &["_self"], + ) + .register_documented( + "max_position", + |_self: Val<::glam::Vec3>| { + let output: usize = { + { + let output: usize = ::glam::Vec3::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", &["_self"], ) .register_documented( @@ -3315,7 +3930,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.\n NaN propogation does not follow IEEE 754-2008 semantics for minNum and may differ on\n different SIMD architectures.", &["_self", "rhs"], ) .register_documented( @@ -3330,7 +3945,24 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { }; output }, - " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", + " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.\n NaN propogation does not follow IEEE 754-2008 semantics and may differ on\n different SIMD architectures.", + &["_self"], + ) + .register_documented( + "min_position", + |_self: Val<::glam::Vec3>| { + let output: usize = { + { + let output: usize = ::glam::Vec3::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", &["_self"], ) .register_documented( @@ -3357,7 +3989,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Mul< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::Vec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -3374,7 +4006,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Mul< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -3391,7 +4023,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Mul< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -3427,7 +4059,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Neg>::neg( + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -3468,7 +4100,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { }; output }, - " Returns `self` normalized to length 1.0.\n For valid results, `self` must be finite and _not_ of length zero, nor very close to zero.\n See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`].\n Panics\n Will panic if the resulting normalized vector is not finite when `glam_assert` is enabled.", + " Returns `self` normalized to length 1.0.\n For valid results, `self` must be finite and _not_ of length zero, nor very close to zero.\n See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`].\n # Panics\n Will panic if the resulting normalized vector is not finite when `glam_assert` is enabled.", &["_self"], ) .register_documented( @@ -3655,7 +4287,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Rem< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::Vec3, >>::rem(_self.into_inner(), &rhs) .into(); @@ -3672,7 +4304,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Rem< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::Vec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -3689,7 +4321,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Rem< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< f32, >>::rem(_self.into_inner(), rhs) .into(); @@ -3719,6 +4351,98 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { " Returns the element-wise remainder of [Euclidean division] of `self` by `rhs`.\n [Euclidean division]: f32::rem_euclid", &["_self", "rhs"], ) + .register_documented( + "rotate_axis", + |_self: Val<::glam::Vec3>, axis: Val<::glam::Vec3>, angle: f32| { + let output: Val<::glam::Vec3> = { + { + let output: Val<::glam::Vec3> = ::glam::Vec3::rotate_axis( + _self.into_inner(), + axis.into_inner(), + angle, + ) + .into(); + output + } + }; + output + }, + " Rotates around `axis` by `angle` (in radians).\n The axis must be a unit vector.\n # Panics\n Will panic if `axis` is not normalized when `glam_assert` is enabled.", + &["_self", "axis", "angle"], + ) + .register_documented( + "rotate_towards", + |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>, max_angle: f32| { + let output: Val<::glam::Vec3> = { + { + let output: Val<::glam::Vec3> = ::glam::Vec3::rotate_towards( + _self.into_inner(), + rhs.into_inner(), + max_angle, + ) + .into(); + output + } + }; + output + }, + " Rotates towards `rhs` up to `max_angle` (in radians).\n When `max_angle` is `0.0`, the result will be equal to `self`. When `max_angle` is equal to\n `self.angle_between(rhs)`, the result will be parallel to `rhs`. If `max_angle` is negative,\n rotates towards the exact opposite of `rhs`. Will not go past the target.", + &["_self", "rhs", "max_angle"], + ) + .register_documented( + "rotate_x", + |_self: Val<::glam::Vec3>, angle: f32| { + let output: Val<::glam::Vec3> = { + { + let output: Val<::glam::Vec3> = ::glam::Vec3::rotate_x( + _self.into_inner(), + angle, + ) + .into(); + output + } + }; + output + }, + " Rotates around the x axis by `angle` (in radians).", + &["_self", "angle"], + ) + .register_documented( + "rotate_y", + |_self: Val<::glam::Vec3>, angle: f32| { + let output: Val<::glam::Vec3> = { + { + let output: Val<::glam::Vec3> = ::glam::Vec3::rotate_y( + _self.into_inner(), + angle, + ) + .into(); + output + } + }; + output + }, + " Rotates around the y axis by `angle` (in radians).", + &["_self", "angle"], + ) + .register_documented( + "rotate_z", + |_self: Val<::glam::Vec3>, angle: f32| { + let output: Val<::glam::Vec3> = { + { + let output: Val<::glam::Vec3> = ::glam::Vec3::rotate_z( + _self.into_inner(), + angle, + ) + .into(); + output + } + }; + output + }, + " Rotates around the z axis by `angle` (in radians).", + &["_self", "angle"], + ) .register_documented( "round", |_self: Val<::glam::Vec3>| { @@ -3776,6 +4500,25 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { " Returns a vector with elements representing the sign of `self`.\n - `1.0` if the number is positive, `+0.0` or `INFINITY`\n - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`\n - `NAN` if the number is `NAN`", &["_self"], ) + .register_documented( + "slerp", + |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>, s: f32| { + let output: Val<::glam::Vec3> = { + { + let output: Val<::glam::Vec3> = ::glam::Vec3::slerp( + _self.into_inner(), + rhs.into_inner(), + s, + ) + .into(); + output + } + }; + output + }, + " Performs a spherical linear interpolation between `self` and `rhs` based on the value `s`.\n When `s` is `0.0`, the result will be equal to `self`. When `s` is `1.0`, the result\n will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly\n extrapolated.", + &["_self", "rhs", "s"], + ) .register_documented( "splat", |v: f32| { @@ -3795,7 +4538,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Sub< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::Vec3, >>::sub(_self.into_inner(), &rhs) .into(); @@ -3812,7 +4555,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Sub< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::Vec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -3829,7 +4572,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Sub< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< f32, >>::sub(_self.into_inner(), rhs) .into(); @@ -3852,7 +4595,24 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { }; output }, - " `[x, y, z]`", + " Converts `self` to `[x, y, z]`", + &["_self"], + ) + .register_documented( + "to_vec3a", + |_self: Val<::glam::Vec3>| { + let output: Val<::glam::Vec3A> = { + { + let output: Val<::glam::Vec3A> = ::glam::Vec3::to_vec3a( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", &["_self"], ) .register_documented( @@ -3949,14 +4709,18 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { } pub(crate) fn register_socket_addr_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::core::net::SocketAddr, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::core::net::SocketAddr>| { + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, + >| + { let output: () = { { - let output: () = <::core::net::SocketAddr as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -3970,10 +4734,18 @@ pub(crate) fn register_socket_addr_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::core::net::SocketAddr>| { - let output: Val<::core::net::SocketAddr> = { + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, + >| + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, + > = { { - let output: Val<::core::net::SocketAddr> = <::core::net::SocketAddr as ::core::clone::Clone>::clone( + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, + > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -3987,11 +4759,18 @@ pub(crate) fn register_socket_addr_functions(world: &mut World) { ) .register_documented( "eq", - |_self: Ref<::core::net::SocketAddr>, other: Ref<::core::net::SocketAddr>| { + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, + >, + other: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, + >| + { let output: bool = { { - let output: bool = <::core::net::SocketAddr as ::core::cmp::PartialEq< - ::core::net::SocketAddr, + let output: bool = <::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, >>::eq(&_self, &other) .into(); output @@ -4004,10 +4783,16 @@ pub(crate) fn register_socket_addr_functions(world: &mut World) { ) .register_documented( "is_ipv4", - |_self: Ref<::core::net::SocketAddr>| { + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, + >| + { let output: bool = { { - let output: bool = ::core::net::SocketAddr::is_ipv4(&_self) + let output: bool = ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr::is_ipv4( + &_self, + ) .into(); output } @@ -4019,10 +4804,16 @@ pub(crate) fn register_socket_addr_functions(world: &mut World) { ) .register_documented( "is_ipv6", - |_self: Ref<::core::net::SocketAddr>| { + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, + >| + { let output: bool = { { - let output: bool = ::core::net::SocketAddr::is_ipv6(&_self) + let output: bool = ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr::is_ipv6( + &_self, + ) .into(); output } @@ -4034,10 +4825,17 @@ pub(crate) fn register_socket_addr_functions(world: &mut World) { ) .register_documented( "port", - |_self: Ref<::core::net::SocketAddr>| { + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, + >| + { let output: u16 = { { - let output: u16 = ::core::net::SocketAddr::port(&_self).into(); + let output: u16 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr::port( + &_self, + ) + .into(); output } }; @@ -4048,10 +4846,15 @@ pub(crate) fn register_socket_addr_functions(world: &mut World) { ) .register_documented( "set_port", - |mut _self: Mut<::core::net::SocketAddr>, new_port: u16| { + | + mut _self: Mut< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, + >, + new_port: u16| + { let output: () = { { - let output: () = ::core::net::SocketAddr::set_port( + let output: () = ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr::set_port( &mut _self, new_port, ) @@ -4068,7 +4871,7 @@ pub(crate) fn register_socket_addr_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::core::net::SocketAddr, + ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -4098,7 +4901,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Ref<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Add< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::IVec2, >>::add(_self.into_inner(), &rhs) .into(); @@ -4115,7 +4918,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Add< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::IVec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -4132,7 +4935,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: i32| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Add< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< i32, >>::add(_self.into_inner(), rhs) .into(); @@ -4296,7 +5099,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Ref<::glam::IVec2>| { let output: () = { { - let output: () = <::glam::IVec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -4308,6 +5111,46 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { + let output: u32 = { + { + let output: u32 = ::glam::IVec2::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u32, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u32, + > = ::glam::IVec2::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u32::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -4336,7 +5179,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Ref<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::clone::Clone>::clone( + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -4479,7 +5322,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Ref<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Div< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::IVec2, >>::div(_self.into_inner(), &rhs) .into(); @@ -4496,7 +5339,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Div< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::IVec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -4513,7 +5356,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: i32| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Div< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< i32, >>::div(_self.into_inner(), rhs) .into(); @@ -4616,7 +5459,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Ref<::glam::IVec2>, other: Ref<::glam::IVec2>| { let output: bool = { { - let output: bool = <::glam::IVec2 as ::core::cmp::PartialEq< + let output: bool = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::IVec2, >>::eq(&_self, &other) .into(); @@ -4675,7 +5518,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { }; output }, - " Returns a bitmask with the lowest 2 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.", + " Returns a bitmask with the lowest 2 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.\n An element is negative if it has a negative sign, including -0.0, NaNs with negative sign\n bit and negative infinity.", &["_self"], ) .register_documented( @@ -4695,6 +5538,24 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { + let output: u32 = { + { + let output: u32 = ::glam::IVec2::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u32::MAX`].\n See also [`checked_manhattan_distance`][IVec2::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { @@ -4710,7 +5571,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -4728,6 +5589,23 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::IVec2>| { + let output: usize = { + { + let output: usize = ::glam::IVec2::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { @@ -4743,7 +5621,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -4761,12 +5639,29 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::IVec2>| { + let output: usize = { + { + let output: usize = ::glam::IVec2::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::IVec2>, rhs: Ref<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Mul< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::IVec2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -4783,7 +5678,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Mul< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::IVec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -4800,7 +5695,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: i32| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Mul< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< i32, >>::mul(_self.into_inner(), rhs) .into(); @@ -4817,7 +5712,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Neg>::neg( + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -4883,7 +5778,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Ref<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Rem< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::IVec2, >>::rem(_self.into_inner(), &rhs) .into(); @@ -4900,7 +5795,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Rem< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::IVec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -4917,7 +5812,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: i32| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Rem< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< i32, >>::rem(_self.into_inner(), rhs) .into(); @@ -4962,7 +5857,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { }; output }, - " Returns `rhs` rotated by the angle of `self`. If `self` is normalized,\n then this just rotation. This is what you usually want. Otherwise,\n it will be like a rotation with a multiplication by `self`'s length.", + " Returns `rhs` rotated by the angle of `self`. If `self` is normalized,\n then this just rotation. This is what you usually want. Otherwise,\n it will be like a rotation with a multiplication by `self`'s length.\n This can be used to rotate by 90 degree increments, e.g. `[sin(90), cos(90)` = `[1, 0]` or\n `[sin(180), cos(180)]` = `[0, -1]`.", &["_self", "rhs"], ) .register_documented( @@ -5132,7 +6027,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Ref<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Sub< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::IVec2, >>::sub(_self.into_inner(), &rhs) .into(); @@ -5149,7 +6044,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Sub< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::IVec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -5166,7 +6061,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: i32| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Sub< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< i32, >>::sub(_self.into_inner(), rhs) .into(); @@ -5189,7 +6084,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { }; output }, - " `[x, y]`", + " Converts `self` to `[x, y]`", &["_self"], ) .register_documented( @@ -5366,7 +6261,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Ref<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Add< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::IVec3, >>::add(_self.into_inner(), &rhs) .into(); @@ -5383,7 +6278,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Add< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::IVec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -5400,7 +6295,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: i32| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Add< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< i32, >>::add(_self.into_inner(), rhs) .into(); @@ -5579,7 +6474,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Ref<::glam::IVec3>| { let output: () = { { - let output: () = <::glam::IVec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -5591,6 +6486,46 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { + let output: u32 = { + { + let output: u32 = ::glam::IVec3::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u32, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u32, + > = ::glam::IVec3::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u32::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -5619,7 +6554,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Ref<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::clone::Clone>::clone( + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -5780,7 +6715,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Ref<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Div< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::IVec3, >>::div(_self.into_inner(), &rhs) .into(); @@ -5797,7 +6732,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Div< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::IVec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -5814,7 +6749,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: i32| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Div< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< i32, >>::div(_self.into_inner(), rhs) .into(); @@ -5917,7 +6852,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Ref<::glam::IVec3>, other: Ref<::glam::IVec3>| { let output: bool = { { - let output: bool = <::glam::IVec3 as ::core::cmp::PartialEq< + let output: bool = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::IVec3, >>::eq(&_self, &other) .into(); @@ -5976,7 +6911,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { }; output }, - " Returns a bitmask with the lowest 3 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.", + " Returns a bitmask with the lowest 3 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.\n An element is negative if it has a negative sign, including -0.0, NaNs with negative sign\n bit and negative infinity.", &["_self"], ) .register_documented( @@ -5996,6 +6931,24 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { + let output: u32 = { + { + let output: u32 = ::glam::IVec3::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u32::MAX`].\n See also [`checked_manhattan_distance`][IVec3::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { @@ -6011,7 +6964,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -6029,6 +6982,23 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::IVec3>| { + let output: usize = { + { + let output: usize = ::glam::IVec3::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { @@ -6044,7 +7014,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -6062,12 +7032,29 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::IVec3>| { + let output: usize = { + { + let output: usize = ::glam::IVec3::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::IVec3>, rhs: Ref<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Mul< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::IVec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -6084,7 +7071,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Mul< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::IVec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -6101,7 +7088,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: i32| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Mul< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< i32, >>::mul(_self.into_inner(), rhs) .into(); @@ -6118,7 +7105,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Neg>::neg( + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -6150,7 +7137,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Ref<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Rem< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::IVec3, >>::rem(_self.into_inner(), &rhs) .into(); @@ -6167,7 +7154,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Rem< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::IVec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -6184,7 +7171,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: i32| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Rem< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< i32, >>::rem(_self.into_inner(), rhs) .into(); @@ -6381,7 +7368,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Ref<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Sub< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::IVec3, >>::sub(_self.into_inner(), &rhs) .into(); @@ -6398,7 +7385,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Sub< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::IVec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -6415,7 +7402,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: i32| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Sub< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< i32, >>::sub(_self.into_inner(), rhs) .into(); @@ -6438,7 +7425,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { }; output }, - " `[x, y, z]`", + " Converts `self` to `[x, y, z]`", &["_self"], ) .register_documented( @@ -6650,7 +7637,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Ref<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Add< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::IVec4, >>::add(_self.into_inner(), &rhs) .into(); @@ -6667,7 +7654,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Add< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::IVec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -6684,7 +7671,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: i32| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Add< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< i32, >>::add(_self.into_inner(), rhs) .into(); @@ -6848,7 +7835,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Ref<::glam::IVec4>| { let output: () = { { - let output: () = <::glam::IVec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -6860,6 +7847,46 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { + let output: u32 = { + { + let output: u32 = ::glam::IVec4::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u32, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u32, + > = ::glam::IVec4::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u32::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -6888,7 +7915,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Ref<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::clone::Clone>::clone( + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -7031,7 +8058,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Ref<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Div< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::IVec4, >>::div(_self.into_inner(), &rhs) .into(); @@ -7048,7 +8075,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Div< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::IVec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -7065,7 +8092,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: i32| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Div< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< i32, >>::div(_self.into_inner(), rhs) .into(); @@ -7168,7 +8195,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Ref<::glam::IVec4>, other: Ref<::glam::IVec4>| { let output: bool = { { - let output: bool = <::glam::IVec4 as ::core::cmp::PartialEq< + let output: bool = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::IVec4, >>::eq(&_self, &other) .into(); @@ -7209,7 +8236,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { }; output }, - " Returns a bitmask with the lowest 4 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.", + " Returns a bitmask with the lowest 4 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.\n An element is negative if it has a negative sign, including -0.0, NaNs with negative sign\n bit and negative infinity.", &["_self"], ) .register_documented( @@ -7229,6 +8256,24 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { + let output: u32 = { + { + let output: u32 = ::glam::IVec4::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u32::MAX`].\n See also [`checked_manhattan_distance`][IVec4::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { @@ -7244,7 +8289,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -7262,6 +8307,23 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::IVec4>| { + let output: usize = { + { + let output: usize = ::glam::IVec4::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { @@ -7277,7 +8339,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -7295,12 +8357,29 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::IVec4>| { + let output: usize = { + { + let output: usize = ::glam::IVec4::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::IVec4>, rhs: Ref<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Mul< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::IVec4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -7317,7 +8396,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Mul< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::IVec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -7334,7 +8413,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: i32| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Mul< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< i32, >>::mul(_self.into_inner(), rhs) .into(); @@ -7351,7 +8430,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Neg>::neg( + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -7383,7 +8462,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Ref<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Rem< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::IVec4, >>::rem(_self.into_inner(), &rhs) .into(); @@ -7400,7 +8479,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Rem< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::IVec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -7417,7 +8496,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: i32| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Rem< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< i32, >>::rem(_self.into_inner(), rhs) .into(); @@ -7614,7 +8693,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Ref<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Sub< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::IVec4, >>::sub(_self.into_inner(), &rhs) .into(); @@ -7631,7 +8710,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Sub< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::IVec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -7648,7 +8727,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: i32| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Sub< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< i32, >>::sub(_self.into_inner(), rhs) .into(); @@ -7671,7 +8750,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { }; output }, - " `[x, y, z, w]`", + " Converts `self` to `[x, y, z, w]`", &["_self"], ) .register_documented( @@ -7901,7 +8980,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Ref<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Add< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::I8Vec2, >>::add(_self.into_inner(), &rhs) .into(); @@ -7918,7 +8997,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Add< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::I8Vec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -7935,7 +9014,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: i8| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Add< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< i8, >>::add(_self.into_inner(), rhs) .into(); @@ -8097,7 +9176,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I8Vec2>| { let output: () = { { - let output: () = <::glam::I8Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -8109,6 +9188,46 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { + let output: u8 = { + { + let output: u8 = ::glam::I8Vec2::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u8, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u8, + > = ::glam::I8Vec2::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u8::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -8137,7 +9256,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::clone::Clone>::clone( + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -8280,7 +9399,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Ref<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Div< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::I8Vec2, >>::div(_self.into_inner(), &rhs) .into(); @@ -8297,7 +9416,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Div< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::I8Vec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -8314,7 +9433,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: i8| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Div< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< i8, >>::div(_self.into_inner(), rhs) .into(); @@ -8417,7 +9536,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I8Vec2>, other: Ref<::glam::I8Vec2>| { let output: bool = { { - let output: bool = <::glam::I8Vec2 as ::core::cmp::PartialEq< + let output: bool = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::I8Vec2, >>::eq(&_self, &other) .into(); @@ -8476,7 +9595,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { }; output }, - " Returns a bitmask with the lowest 2 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.", + " Returns a bitmask with the lowest 2 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.\n An element is negative if it has a negative sign, including -0.0, NaNs with negative sign\n bit and negative infinity.", &["_self"], ) .register_documented( @@ -8496,6 +9615,24 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { + let output: u8 = { + { + let output: u8 = ::glam::I8Vec2::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u8::MAX`].\n See also [`checked_manhattan_distance`][I8Vec2::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { @@ -8511,7 +9648,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -8529,6 +9666,23 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::I8Vec2>| { + let output: usize = { + { + let output: usize = ::glam::I8Vec2::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { @@ -8544,7 +9698,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -8562,12 +9716,29 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::I8Vec2>| { + let output: usize = { + { + let output: usize = ::glam::I8Vec2::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::I8Vec2>, rhs: Ref<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Mul< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::I8Vec2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -8584,7 +9755,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Mul< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::I8Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -8601,7 +9772,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: i8| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Mul< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< i8, >>::mul(_self.into_inner(), rhs) .into(); @@ -8618,7 +9789,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Neg>::neg( + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -8685,7 +9856,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Ref<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Rem< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::I8Vec2, >>::rem(_self.into_inner(), &rhs) .into(); @@ -8702,7 +9873,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Rem< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::I8Vec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -8719,7 +9890,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: i8| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Rem< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< i8, >>::rem(_self.into_inner(), rhs) .into(); @@ -8764,7 +9935,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { }; output }, - " Returns `rhs` rotated by the angle of `self`. If `self` is normalized,\n then this just rotation. This is what you usually want. Otherwise,\n it will be like a rotation with a multiplication by `self`'s length.", + " Returns `rhs` rotated by the angle of `self`. If `self` is normalized,\n then this just rotation. This is what you usually want. Otherwise,\n it will be like a rotation with a multiplication by `self`'s length.\n This can be used to rotate by 90 degree increments, e.g. `[sin(90), cos(90)` = `[1, 0]` or\n `[sin(180), cos(180)]` = `[0, -1]`.", &["_self", "rhs"], ) .register_documented( @@ -8935,7 +10106,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Ref<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Sub< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::I8Vec2, >>::sub(_self.into_inner(), &rhs) .into(); @@ -8952,7 +10123,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Sub< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::I8Vec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -8969,7 +10140,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: i8| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Sub< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< i8, >>::sub(_self.into_inner(), rhs) .into(); @@ -8992,7 +10163,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { }; output }, - " `[x, y]`", + " Converts `self` to `[x, y]`", &["_self"], ) .register_documented( @@ -9169,7 +10340,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Ref<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Add< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::I8Vec3, >>::add(_self.into_inner(), &rhs) .into(); @@ -9186,7 +10357,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Add< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::I8Vec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -9203,7 +10374,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: i8| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Add< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< i8, >>::add(_self.into_inner(), rhs) .into(); @@ -9380,7 +10551,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I8Vec3>| { let output: () = { { - let output: () = <::glam::I8Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -9392,6 +10563,46 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { + let output: u8 = { + { + let output: u8 = ::glam::I8Vec3::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u8, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u8, + > = ::glam::I8Vec3::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u8::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -9420,7 +10631,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::clone::Clone>::clone( + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -9581,7 +10792,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Ref<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Div< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::I8Vec3, >>::div(_self.into_inner(), &rhs) .into(); @@ -9598,7 +10809,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Div< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::I8Vec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -9615,7 +10826,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: i8| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Div< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< i8, >>::div(_self.into_inner(), rhs) .into(); @@ -9718,7 +10929,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I8Vec3>, other: Ref<::glam::I8Vec3>| { let output: bool = { { - let output: bool = <::glam::I8Vec3 as ::core::cmp::PartialEq< + let output: bool = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::I8Vec3, >>::eq(&_self, &other) .into(); @@ -9777,7 +10988,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { }; output }, - " Returns a bitmask with the lowest 3 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.", + " Returns a bitmask with the lowest 3 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.\n An element is negative if it has a negative sign, including -0.0, NaNs with negative sign\n bit and negative infinity.", &["_self"], ) .register_documented( @@ -9797,6 +11008,24 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { + let output: u8 = { + { + let output: u8 = ::glam::I8Vec3::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u8::MAX`].\n See also [`checked_manhattan_distance`][I8Vec3::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { @@ -9812,7 +11041,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -9830,6 +11059,23 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::I8Vec3>| { + let output: usize = { + { + let output: usize = ::glam::I8Vec3::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { @@ -9845,7 +11091,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -9863,12 +11109,29 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::I8Vec3>| { + let output: usize = { + { + let output: usize = ::glam::I8Vec3::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::I8Vec3>, rhs: Ref<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Mul< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::I8Vec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -9885,7 +11148,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Mul< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::I8Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -9902,7 +11165,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: i8| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Mul< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< i8, >>::mul(_self.into_inner(), rhs) .into(); @@ -9919,7 +11182,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Neg>::neg( + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -9951,7 +11214,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Ref<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Rem< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::I8Vec3, >>::rem(_self.into_inner(), &rhs) .into(); @@ -9968,7 +11231,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Rem< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::I8Vec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -9985,7 +11248,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: i8| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Rem< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< i8, >>::rem(_self.into_inner(), rhs) .into(); @@ -10183,7 +11446,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Ref<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Sub< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::I8Vec3, >>::sub(_self.into_inner(), &rhs) .into(); @@ -10200,7 +11463,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Sub< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::I8Vec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -10217,7 +11480,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: i8| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Sub< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< i8, >>::sub(_self.into_inner(), rhs) .into(); @@ -10240,7 +11503,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { }; output }, - " `[x, y, z]`", + " Converts `self` to `[x, y, z]`", &["_self"], ) .register_documented( @@ -10452,7 +11715,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Ref<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Add< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::I8Vec4, >>::add(_self.into_inner(), &rhs) .into(); @@ -10469,7 +11732,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Add< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::I8Vec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -10486,7 +11749,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: i8| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Add< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< i8, >>::add(_self.into_inner(), rhs) .into(); @@ -10648,7 +11911,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I8Vec4>| { let output: () = { { - let output: () = <::glam::I8Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -10660,6 +11923,46 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { + let output: u8 = { + { + let output: u8 = ::glam::I8Vec4::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u8, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u8, + > = ::glam::I8Vec4::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u8::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -10688,7 +11991,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::clone::Clone>::clone( + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -10831,7 +12134,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Ref<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Div< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::I8Vec4, >>::div(_self.into_inner(), &rhs) .into(); @@ -10848,7 +12151,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Div< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::I8Vec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -10865,7 +12168,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: i8| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Div< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< i8, >>::div(_self.into_inner(), rhs) .into(); @@ -10968,7 +12271,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I8Vec4>, other: Ref<::glam::I8Vec4>| { let output: bool = { { - let output: bool = <::glam::I8Vec4 as ::core::cmp::PartialEq< + let output: bool = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::I8Vec4, >>::eq(&_self, &other) .into(); @@ -11009,7 +12312,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { }; output }, - " Returns a bitmask with the lowest 4 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.", + " Returns a bitmask with the lowest 4 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.\n An element is negative if it has a negative sign, including -0.0, NaNs with negative sign\n bit and negative infinity.", &["_self"], ) .register_documented( @@ -11029,6 +12332,24 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { + let output: u8 = { + { + let output: u8 = ::glam::I8Vec4::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u8::MAX`].\n See also [`checked_manhattan_distance`][I8Vec4::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { @@ -11044,7 +12365,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -11062,6 +12383,23 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::I8Vec4>| { + let output: usize = { + { + let output: usize = ::glam::I8Vec4::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { @@ -11077,7 +12415,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -11095,12 +12433,29 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::I8Vec4>| { + let output: usize = { + { + let output: usize = ::glam::I8Vec4::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::I8Vec4>, rhs: Ref<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Mul< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::I8Vec4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -11117,7 +12472,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Mul< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::I8Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -11134,7 +12489,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: i8| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Mul< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< i8, >>::mul(_self.into_inner(), rhs) .into(); @@ -11151,7 +12506,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Neg>::neg( + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -11183,7 +12538,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Ref<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Rem< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::I8Vec4, >>::rem(_self.into_inner(), &rhs) .into(); @@ -11200,7 +12555,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Rem< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::I8Vec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -11217,7 +12572,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: i8| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Rem< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< i8, >>::rem(_self.into_inner(), rhs) .into(); @@ -11415,7 +12770,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Ref<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Sub< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::I8Vec4, >>::sub(_self.into_inner(), &rhs) .into(); @@ -11432,7 +12787,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Sub< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::I8Vec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -11449,7 +12804,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: i8| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Sub< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< i8, >>::sub(_self.into_inner(), rhs) .into(); @@ -11472,7 +12827,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { }; output }, - " `[x, y, z, w]`", + " Converts `self` to `[x, y, z, w]`", &["_self"], ) .register_documented( @@ -11702,7 +13057,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Ref<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Add< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::I16Vec2, >>::add(_self.into_inner(), &rhs) .into(); @@ -11719,7 +13074,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Add< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::I16Vec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -11736,7 +13091,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: i16| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Add< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< i16, >>::add(_self.into_inner(), rhs) .into(); @@ -11904,7 +13259,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I16Vec2>| { let output: () = { { - let output: () = <::glam::I16Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -11916,6 +13271,46 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { + let output: u16 = { + { + let output: u16 = ::glam::I16Vec2::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u16, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u16, + > = ::glam::I16Vec2::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u16::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -11944,7 +13339,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::clone::Clone>::clone( + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -12087,7 +13482,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Ref<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Div< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::I16Vec2, >>::div(_self.into_inner(), &rhs) .into(); @@ -12104,7 +13499,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Div< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::I16Vec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -12121,7 +13516,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: i16| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Div< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< i16, >>::div(_self.into_inner(), rhs) .into(); @@ -12226,7 +13621,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I16Vec2>, other: Ref<::glam::I16Vec2>| { let output: bool = { { - let output: bool = <::glam::I16Vec2 as ::core::cmp::PartialEq< + let output: bool = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::I16Vec2, >>::eq(&_self, &other) .into(); @@ -12285,7 +13680,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { }; output }, - " Returns a bitmask with the lowest 2 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.", + " Returns a bitmask with the lowest 2 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.\n An element is negative if it has a negative sign, including -0.0, NaNs with negative sign\n bit and negative infinity.", &["_self"], ) .register_documented( @@ -12305,6 +13700,24 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { + let output: u16 = { + { + let output: u16 = ::glam::I16Vec2::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u16::MAX`].\n See also [`checked_manhattan_distance`][I16Vec2::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { @@ -12320,7 +13733,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -12340,6 +13753,23 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::I16Vec2>| { + let output: usize = { + { + let output: usize = ::glam::I16Vec2::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { @@ -12355,7 +13785,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -12375,12 +13805,29 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::I16Vec2>| { + let output: usize = { + { + let output: usize = ::glam::I16Vec2::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::I16Vec2>, rhs: Ref<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Mul< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::I16Vec2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -12397,7 +13844,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Mul< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::I16Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -12414,7 +13861,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: i16| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Mul< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< i16, >>::mul(_self.into_inner(), rhs) .into(); @@ -12431,7 +13878,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Neg>::neg( + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -12498,7 +13945,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Ref<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Rem< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::I16Vec2, >>::rem(_self.into_inner(), &rhs) .into(); @@ -12515,7 +13962,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Rem< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::I16Vec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -12532,7 +13979,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: i16| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Rem< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< i16, >>::rem(_self.into_inner(), rhs) .into(); @@ -12577,7 +14024,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { }; output }, - " Returns `rhs` rotated by the angle of `self`. If `self` is normalized,\n then this just rotation. This is what you usually want. Otherwise,\n it will be like a rotation with a multiplication by `self`'s length.", + " Returns `rhs` rotated by the angle of `self`. If `self` is normalized,\n then this just rotation. This is what you usually want. Otherwise,\n it will be like a rotation with a multiplication by `self`'s length.\n This can be used to rotate by 90 degree increments, e.g. `[sin(90), cos(90)` = `[1, 0]` or\n `[sin(180), cos(180)]` = `[0, -1]`.", &["_self", "rhs"], ) .register_documented( @@ -12748,7 +14195,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Ref<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Sub< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::I16Vec2, >>::sub(_self.into_inner(), &rhs) .into(); @@ -12765,7 +14212,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Sub< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::I16Vec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -12782,7 +14229,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: i16| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Sub< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< i16, >>::sub(_self.into_inner(), rhs) .into(); @@ -12805,7 +14252,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { }; output }, - " `[x, y]`", + " Converts `self` to `[x, y]`", &["_self"], ) .register_documented( @@ -12982,7 +14429,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Ref<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Add< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::I16Vec3, >>::add(_self.into_inner(), &rhs) .into(); @@ -12999,7 +14446,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Add< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::I16Vec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -13016,7 +14463,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: i16| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Add< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< i16, >>::add(_self.into_inner(), rhs) .into(); @@ -13201,7 +14648,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I16Vec3>| { let output: () = { { - let output: () = <::glam::I16Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -13213,6 +14660,46 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { + let output: u16 = { + { + let output: u16 = ::glam::I16Vec3::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u16, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u16, + > = ::glam::I16Vec3::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u16::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -13241,7 +14728,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::clone::Clone>::clone( + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -13402,7 +14889,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Ref<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Div< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::I16Vec3, >>::div(_self.into_inner(), &rhs) .into(); @@ -13419,7 +14906,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Div< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::I16Vec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -13436,7 +14923,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: i16| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Div< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< i16, >>::div(_self.into_inner(), rhs) .into(); @@ -13541,7 +15028,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I16Vec3>, other: Ref<::glam::I16Vec3>| { let output: bool = { { - let output: bool = <::glam::I16Vec3 as ::core::cmp::PartialEq< + let output: bool = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::I16Vec3, >>::eq(&_self, &other) .into(); @@ -13600,7 +15087,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { }; output }, - " Returns a bitmask with the lowest 3 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.", + " Returns a bitmask with the lowest 3 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.\n An element is negative if it has a negative sign, including -0.0, NaNs with negative sign\n bit and negative infinity.", &["_self"], ) .register_documented( @@ -13620,6 +15107,24 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { + let output: u16 = { + { + let output: u16 = ::glam::I16Vec3::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u16::MAX`].\n See also [`checked_manhattan_distance`][I16Vec3::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { @@ -13635,7 +15140,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -13655,6 +15160,23 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::I16Vec3>| { + let output: usize = { + { + let output: usize = ::glam::I16Vec3::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { @@ -13670,7 +15192,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -13690,12 +15212,29 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::I16Vec3>| { + let output: usize = { + { + let output: usize = ::glam::I16Vec3::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::I16Vec3>, rhs: Ref<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Mul< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::I16Vec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -13712,7 +15251,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Mul< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::I16Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -13729,7 +15268,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: i16| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Mul< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< i16, >>::mul(_self.into_inner(), rhs) .into(); @@ -13746,7 +15285,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Neg>::neg( + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -13778,7 +15317,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Ref<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Rem< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::I16Vec3, >>::rem(_self.into_inner(), &rhs) .into(); @@ -13795,7 +15334,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Rem< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::I16Vec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -13812,7 +15351,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: i16| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Rem< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< i16, >>::rem(_self.into_inner(), rhs) .into(); @@ -14010,7 +15549,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Ref<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Sub< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::I16Vec3, >>::sub(_self.into_inner(), &rhs) .into(); @@ -14027,7 +15566,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Sub< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::I16Vec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -14044,7 +15583,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: i16| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Sub< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< i16, >>::sub(_self.into_inner(), rhs) .into(); @@ -14067,7 +15606,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { }; output }, - " `[x, y, z]`", + " Converts `self` to `[x, y, z]`", &["_self"], ) .register_documented( @@ -14279,7 +15818,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Ref<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Add< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::I16Vec4, >>::add(_self.into_inner(), &rhs) .into(); @@ -14296,7 +15835,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Add< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::I16Vec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -14313,7 +15852,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: i16| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Add< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< i16, >>::add(_self.into_inner(), rhs) .into(); @@ -14481,7 +16020,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I16Vec4>| { let output: () = { { - let output: () = <::glam::I16Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -14493,6 +16032,46 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { + let output: u16 = { + { + let output: u16 = ::glam::I16Vec4::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u16, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u16, + > = ::glam::I16Vec4::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u16::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -14521,7 +16100,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::clone::Clone>::clone( + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -14664,7 +16243,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Ref<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Div< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::I16Vec4, >>::div(_self.into_inner(), &rhs) .into(); @@ -14681,7 +16260,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Div< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::I16Vec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -14698,7 +16277,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: i16| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Div< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< i16, >>::div(_self.into_inner(), rhs) .into(); @@ -14803,7 +16382,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I16Vec4>, other: Ref<::glam::I16Vec4>| { let output: bool = { { - let output: bool = <::glam::I16Vec4 as ::core::cmp::PartialEq< + let output: bool = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::I16Vec4, >>::eq(&_self, &other) .into(); @@ -14844,7 +16423,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { }; output }, - " Returns a bitmask with the lowest 4 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.", + " Returns a bitmask with the lowest 4 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.\n An element is negative if it has a negative sign, including -0.0, NaNs with negative sign\n bit and negative infinity.", &["_self"], ) .register_documented( @@ -14864,6 +16443,24 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { + let output: u16 = { + { + let output: u16 = ::glam::I16Vec4::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u16::MAX`].\n See also [`checked_manhattan_distance`][I16Vec4::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { @@ -14879,7 +16476,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -14899,6 +16496,23 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::I16Vec4>| { + let output: usize = { + { + let output: usize = ::glam::I16Vec4::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { @@ -14914,7 +16528,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -14934,12 +16548,29 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::I16Vec4>| { + let output: usize = { + { + let output: usize = ::glam::I16Vec4::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::I16Vec4>, rhs: Ref<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Mul< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::I16Vec4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -14956,7 +16587,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Mul< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::I16Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -14973,7 +16604,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: i16| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Mul< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< i16, >>::mul(_self.into_inner(), rhs) .into(); @@ -14990,7 +16621,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Neg>::neg( + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -15027,7 +16658,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Ref<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Rem< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::I16Vec4, >>::rem(_self.into_inner(), &rhs) .into(); @@ -15044,7 +16675,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Rem< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::I16Vec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -15061,7 +16692,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: i16| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Rem< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< i16, >>::rem(_self.into_inner(), rhs) .into(); @@ -15259,7 +16890,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Ref<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Sub< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::I16Vec4, >>::sub(_self.into_inner(), &rhs) .into(); @@ -15276,7 +16907,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Sub< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::I16Vec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -15293,7 +16924,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: i16| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Sub< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< i16, >>::sub(_self.into_inner(), rhs) .into(); @@ -15316,7 +16947,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { }; output }, - " `[x, y, z, w]`", + " Converts `self` to `[x, y, z, w]`", &["_self"], ) .register_documented( @@ -15546,7 +17177,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Ref<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Add< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::I64Vec2, >>::add(_self.into_inner(), &rhs) .into(); @@ -15563,7 +17194,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Add< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::I64Vec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -15580,7 +17211,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: i64| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Add< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< i64, >>::add(_self.into_inner(), rhs) .into(); @@ -15748,7 +17379,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I64Vec2>| { let output: () = { { - let output: () = <::glam::I64Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -15760,6 +17391,46 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { + let output: u64 = { + { + let output: u64 = ::glam::I64Vec2::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u64, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u64, + > = ::glam::I64Vec2::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u64::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -15788,7 +17459,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::clone::Clone>::clone( + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -15931,7 +17602,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Ref<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Div< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::I64Vec2, >>::div(_self.into_inner(), &rhs) .into(); @@ -15948,7 +17619,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Div< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::I64Vec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -15965,7 +17636,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: i64| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Div< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< i64, >>::div(_self.into_inner(), rhs) .into(); @@ -16070,7 +17741,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I64Vec2>, other: Ref<::glam::I64Vec2>| { let output: bool = { { - let output: bool = <::glam::I64Vec2 as ::core::cmp::PartialEq< + let output: bool = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::I64Vec2, >>::eq(&_self, &other) .into(); @@ -16129,7 +17800,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { }; output }, - " Returns a bitmask with the lowest 2 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.", + " Returns a bitmask with the lowest 2 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.\n An element is negative if it has a negative sign, including -0.0, NaNs with negative sign\n bit and negative infinity.", &["_self"], ) .register_documented( @@ -16149,6 +17820,24 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { + let output: u64 = { + { + let output: u64 = ::glam::I64Vec2::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u64::MAX`].\n See also [`checked_manhattan_distance`][I64Vec2::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { @@ -16164,7 +17853,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -16184,6 +17873,23 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::I64Vec2>| { + let output: usize = { + { + let output: usize = ::glam::I64Vec2::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { @@ -16199,7 +17905,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -16219,12 +17925,29 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::I64Vec2>| { + let output: usize = { + { + let output: usize = ::glam::I64Vec2::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::I64Vec2>, rhs: Ref<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Mul< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::I64Vec2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -16241,7 +17964,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Mul< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::I64Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -16258,7 +17981,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: i64| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Mul< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< i64, >>::mul(_self.into_inner(), rhs) .into(); @@ -16275,7 +17998,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Neg>::neg( + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -16342,7 +18065,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Ref<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Rem< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::I64Vec2, >>::rem(_self.into_inner(), &rhs) .into(); @@ -16359,7 +18082,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Rem< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::I64Vec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -16376,7 +18099,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: i64| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Rem< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< i64, >>::rem(_self.into_inner(), rhs) .into(); @@ -16421,7 +18144,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { }; output }, - " Returns `rhs` rotated by the angle of `self`. If `self` is normalized,\n then this just rotation. This is what you usually want. Otherwise,\n it will be like a rotation with a multiplication by `self`'s length.", + " Returns `rhs` rotated by the angle of `self`. If `self` is normalized,\n then this just rotation. This is what you usually want. Otherwise,\n it will be like a rotation with a multiplication by `self`'s length.\n This can be used to rotate by 90 degree increments, e.g. `[sin(90), cos(90)` = `[1, 0]` or\n `[sin(180), cos(180)]` = `[0, -1]`.", &["_self", "rhs"], ) .register_documented( @@ -16592,7 +18315,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Ref<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Sub< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::I64Vec2, >>::sub(_self.into_inner(), &rhs) .into(); @@ -16609,7 +18332,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Sub< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::I64Vec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -16626,7 +18349,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: i64| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Sub< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< i64, >>::sub(_self.into_inner(), rhs) .into(); @@ -16649,7 +18372,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { }; output }, - " `[x, y]`", + " Converts `self` to `[x, y]`", &["_self"], ) .register_documented( @@ -16826,7 +18549,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Ref<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Add< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::I64Vec3, >>::add(_self.into_inner(), &rhs) .into(); @@ -16843,7 +18566,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Add< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::I64Vec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -16860,7 +18583,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: i64| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Add< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< i64, >>::add(_self.into_inner(), rhs) .into(); @@ -17045,7 +18768,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I64Vec3>| { let output: () = { { - let output: () = <::glam::I64Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -17057,6 +18780,46 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { + let output: u64 = { + { + let output: u64 = ::glam::I64Vec3::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u64, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u64, + > = ::glam::I64Vec3::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u64::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -17085,7 +18848,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::clone::Clone>::clone( + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -17246,7 +19009,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Ref<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Div< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::I64Vec3, >>::div(_self.into_inner(), &rhs) .into(); @@ -17263,7 +19026,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Div< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::I64Vec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -17280,7 +19043,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: i64| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Div< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< i64, >>::div(_self.into_inner(), rhs) .into(); @@ -17385,7 +19148,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I64Vec3>, other: Ref<::glam::I64Vec3>| { let output: bool = { { - let output: bool = <::glam::I64Vec3 as ::core::cmp::PartialEq< + let output: bool = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::I64Vec3, >>::eq(&_self, &other) .into(); @@ -17444,7 +19207,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { }; output }, - " Returns a bitmask with the lowest 3 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.", + " Returns a bitmask with the lowest 3 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.\n An element is negative if it has a negative sign, including -0.0, NaNs with negative sign\n bit and negative infinity.", &["_self"], ) .register_documented( @@ -17464,6 +19227,24 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { + let output: u64 = { + { + let output: u64 = ::glam::I64Vec3::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u64::MAX`].\n See also [`checked_manhattan_distance`][I64Vec3::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { @@ -17479,7 +19260,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -17499,6 +19280,23 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::I64Vec3>| { + let output: usize = { + { + let output: usize = ::glam::I64Vec3::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { @@ -17514,7 +19312,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -17534,12 +19332,29 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::I64Vec3>| { + let output: usize = { + { + let output: usize = ::glam::I64Vec3::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::I64Vec3>, rhs: Ref<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Mul< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::I64Vec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -17556,7 +19371,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Mul< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::I64Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -17573,7 +19388,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: i64| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Mul< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< i64, >>::mul(_self.into_inner(), rhs) .into(); @@ -17590,7 +19405,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Neg>::neg( + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -17622,7 +19437,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Ref<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Rem< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::I64Vec3, >>::rem(_self.into_inner(), &rhs) .into(); @@ -17639,7 +19454,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Rem< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::I64Vec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -17656,7 +19471,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: i64| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Rem< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< i64, >>::rem(_self.into_inner(), rhs) .into(); @@ -17854,7 +19669,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Ref<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Sub< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::I64Vec3, >>::sub(_self.into_inner(), &rhs) .into(); @@ -17871,7 +19686,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Sub< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::I64Vec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -17888,7 +19703,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: i64| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Sub< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< i64, >>::sub(_self.into_inner(), rhs) .into(); @@ -17911,7 +19726,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { }; output }, - " `[x, y, z]`", + " Converts `self` to `[x, y, z]`", &["_self"], ) .register_documented( @@ -18123,7 +19938,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Ref<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Add< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::I64Vec4, >>::add(_self.into_inner(), &rhs) .into(); @@ -18140,7 +19955,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Add< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::I64Vec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -18157,7 +19972,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: i64| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Add< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< i64, >>::add(_self.into_inner(), rhs) .into(); @@ -18325,7 +20140,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I64Vec4>| { let output: () = { { - let output: () = <::glam::I64Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -18337,6 +20152,46 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { + let output: u64 = { + { + let output: u64 = ::glam::I64Vec4::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u64, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u64, + > = ::glam::I64Vec4::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u64::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -18365,7 +20220,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::clone::Clone>::clone( + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -18508,7 +20363,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Ref<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Div< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::I64Vec4, >>::div(_self.into_inner(), &rhs) .into(); @@ -18525,7 +20380,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Div< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::I64Vec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -18542,7 +20397,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: i64| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Div< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< i64, >>::div(_self.into_inner(), rhs) .into(); @@ -18647,7 +20502,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I64Vec4>, other: Ref<::glam::I64Vec4>| { let output: bool = { { - let output: bool = <::glam::I64Vec4 as ::core::cmp::PartialEq< + let output: bool = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::I64Vec4, >>::eq(&_self, &other) .into(); @@ -18688,7 +20543,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { }; output }, - " Returns a bitmask with the lowest 4 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.", + " Returns a bitmask with the lowest 4 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.\n An element is negative if it has a negative sign, including -0.0, NaNs with negative sign\n bit and negative infinity.", &["_self"], ) .register_documented( @@ -18708,6 +20563,24 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { + let output: u64 = { + { + let output: u64 = ::glam::I64Vec4::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u64::MAX`].\n See also [`checked_manhattan_distance`][I64Vec4::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { @@ -18723,7 +20596,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -18743,6 +20616,23 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::I64Vec4>| { + let output: usize = { + { + let output: usize = ::glam::I64Vec4::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { @@ -18758,7 +20648,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -18778,12 +20668,29 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::I64Vec4>| { + let output: usize = { + { + let output: usize = ::glam::I64Vec4::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::I64Vec4>, rhs: Ref<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Mul< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::I64Vec4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -18800,7 +20707,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Mul< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::I64Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -18817,7 +20724,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: i64| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Mul< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< i64, >>::mul(_self.into_inner(), rhs) .into(); @@ -18834,7 +20741,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Neg>::neg( + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -18871,7 +20778,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Ref<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Rem< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::I64Vec4, >>::rem(_self.into_inner(), &rhs) .into(); @@ -18888,7 +20795,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Rem< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::I64Vec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -18905,7 +20812,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: i64| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Rem< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< i64, >>::rem(_self.into_inner(), rhs) .into(); @@ -19103,7 +21010,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Ref<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Sub< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::I64Vec4, >>::sub(_self.into_inner(), &rhs) .into(); @@ -19120,7 +21027,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Sub< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::I64Vec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -19137,7 +21044,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: i64| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Sub< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< i64, >>::sub(_self.into_inner(), rhs) .into(); @@ -19160,7 +21067,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { }; output }, - " `[x, y, z, w]`", + " Converts `self` to `[x, y, z, w]`", &["_self"], ) .register_documented( @@ -19373,7 +21280,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Ref<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Add< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::UVec2, >>::add(_self.into_inner(), &rhs) .into(); @@ -19390,7 +21297,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Add< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::UVec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -19407,7 +21314,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: u32| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Add< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< u32, >>::add(_self.into_inner(), rhs) .into(); @@ -19571,7 +21478,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Ref<::glam::UVec2>| { let output: () = { { - let output: () = <::glam::UVec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -19583,6 +21490,46 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { + let output: u32 = { + { + let output: u32 = ::glam::UVec2::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u32, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u32, + > = ::glam::UVec2::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u32::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -19611,7 +21558,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Ref<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::clone::Clone>::clone( + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -19736,7 +21683,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Ref<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Div< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::UVec2, >>::div(_self.into_inner(), &rhs) .into(); @@ -19753,7 +21700,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Div< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::UVec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -19770,7 +21717,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: u32| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Div< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< u32, >>::div(_self.into_inner(), rhs) .into(); @@ -19855,7 +21802,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Ref<::glam::UVec2>, other: Ref<::glam::UVec2>| { let output: bool = { { - let output: bool = <::glam::UVec2 as ::core::cmp::PartialEq< + let output: bool = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::UVec2, >>::eq(&_self, &other) .into(); @@ -19917,6 +21864,24 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { + let output: u32 = { + { + let output: u32 = ::glam::UVec2::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u32::MAX`].\n See also [`checked_manhattan_distance`][UVec2::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { @@ -19932,7 +21897,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -19950,6 +21915,23 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::UVec2>| { + let output: usize = { + { + let output: usize = ::glam::UVec2::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { @@ -19965,7 +21947,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -19983,12 +21965,29 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::UVec2>| { + let output: usize = { + { + let output: usize = ::glam::UVec2::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::UVec2>, rhs: Ref<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Mul< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::UVec2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -20005,7 +22004,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Mul< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::UVec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -20022,7 +22021,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: u32| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Mul< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< u32, >>::mul(_self.into_inner(), rhs) .into(); @@ -20053,7 +22052,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Ref<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Rem< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::UVec2, >>::rem(_self.into_inner(), &rhs) .into(); @@ -20070,7 +22069,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Rem< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::UVec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -20087,7 +22086,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: u32| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Rem< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< u32, >>::rem(_self.into_inner(), rhs) .into(); @@ -20231,7 +22230,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Ref<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Sub< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::UVec2, >>::sub(_self.into_inner(), &rhs) .into(); @@ -20248,7 +22247,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Sub< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::UVec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -20265,7 +22264,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: u32| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Sub< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< u32, >>::sub(_self.into_inner(), rhs) .into(); @@ -20288,7 +22287,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { }; output }, - " `[x, y]`", + " Converts `self` to `[x, y]`", &["_self"], ) .register_documented( @@ -20430,7 +22429,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Ref<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Add< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::UVec3, >>::add(_self.into_inner(), &rhs) .into(); @@ -20447,7 +22446,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Add< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::UVec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -20464,7 +22463,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: u32| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Add< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< u32, >>::add(_self.into_inner(), rhs) .into(); @@ -20643,7 +22642,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Ref<::glam::UVec3>| { let output: () = { { - let output: () = <::glam::UVec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -20655,6 +22654,46 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { + let output: u32 = { + { + let output: u32 = ::glam::UVec3::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u32, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u32, + > = ::glam::UVec3::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u32::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -20683,7 +22722,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Ref<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::clone::Clone>::clone( + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -20826,7 +22865,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Ref<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Div< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::UVec3, >>::div(_self.into_inner(), &rhs) .into(); @@ -20843,7 +22882,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Div< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::UVec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -20860,7 +22899,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: u32| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Div< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< u32, >>::div(_self.into_inner(), rhs) .into(); @@ -20945,7 +22984,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Ref<::glam::UVec3>, other: Ref<::glam::UVec3>| { let output: bool = { { - let output: bool = <::glam::UVec3 as ::core::cmp::PartialEq< + let output: bool = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::UVec3, >>::eq(&_self, &other) .into(); @@ -21007,6 +23046,24 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { + let output: u32 = { + { + let output: u32 = ::glam::UVec3::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u32::MAX`].\n See also [`checked_manhattan_distance`][UVec3::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { @@ -21022,7 +23079,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -21040,6 +23097,23 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::UVec3>| { + let output: usize = { + { + let output: usize = ::glam::UVec3::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { @@ -21055,7 +23129,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -21073,12 +23147,29 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::UVec3>| { + let output: usize = { + { + let output: usize = ::glam::UVec3::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::UVec3>, rhs: Ref<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Mul< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::UVec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -21095,7 +23186,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Mul< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::UVec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -21112,7 +23203,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: u32| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Mul< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< u32, >>::mul(_self.into_inner(), rhs) .into(); @@ -21144,7 +23235,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Ref<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Rem< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::UVec3, >>::rem(_self.into_inner(), &rhs) .into(); @@ -21161,7 +23252,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Rem< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::UVec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -21178,7 +23269,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: u32| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Rem< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< u32, >>::rem(_self.into_inner(), rhs) .into(); @@ -21322,7 +23413,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Ref<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Sub< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::UVec3, >>::sub(_self.into_inner(), &rhs) .into(); @@ -21339,7 +23430,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Sub< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::UVec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -21356,7 +23447,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: u32| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Sub< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< u32, >>::sub(_self.into_inner(), rhs) .into(); @@ -21379,7 +23470,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { }; output }, - " `[x, y, z]`", + " Converts `self` to `[x, y, z]`", &["_self"], ) .register_documented( @@ -21556,7 +23647,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Ref<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Add< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::UVec4, >>::add(_self.into_inner(), &rhs) .into(); @@ -21573,7 +23664,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Add< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::UVec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -21590,7 +23681,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: u32| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Add< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< u32, >>::add(_self.into_inner(), rhs) .into(); @@ -21754,7 +23845,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Ref<::glam::UVec4>| { let output: () = { { - let output: () = <::glam::UVec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -21766,6 +23857,46 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { + let output: u32 = { + { + let output: u32 = ::glam::UVec4::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u32, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u32, + > = ::glam::UVec4::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u32::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -21794,7 +23925,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Ref<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::clone::Clone>::clone( + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -21919,7 +24050,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Ref<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Div< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::UVec4, >>::div(_self.into_inner(), &rhs) .into(); @@ -21936,7 +24067,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Div< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::UVec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -21953,7 +24084,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: u32| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Div< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< u32, >>::div(_self.into_inner(), rhs) .into(); @@ -22038,7 +24169,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Ref<::glam::UVec4>, other: Ref<::glam::UVec4>| { let output: bool = { { - let output: bool = <::glam::UVec4 as ::core::cmp::PartialEq< + let output: bool = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::UVec4, >>::eq(&_self, &other) .into(); @@ -22082,6 +24213,24 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { + let output: u32 = { + { + let output: u32 = ::glam::UVec4::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u32::MAX`].\n See also [`checked_manhattan_distance`][UVec4::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { @@ -22097,7 +24246,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -22115,6 +24264,23 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::UVec4>| { + let output: usize = { + { + let output: usize = ::glam::UVec4::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { @@ -22130,7 +24296,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -22148,12 +24314,29 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::UVec4>| { + let output: usize = { + { + let output: usize = ::glam::UVec4::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::UVec4>, rhs: Ref<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Mul< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::UVec4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -22170,7 +24353,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Mul< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::UVec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -22187,7 +24370,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: u32| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Mul< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< u32, >>::mul(_self.into_inner(), rhs) .into(); @@ -22219,7 +24402,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Ref<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Rem< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::UVec4, >>::rem(_self.into_inner(), &rhs) .into(); @@ -22236,7 +24419,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Rem< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::UVec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -22253,7 +24436,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: u32| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Rem< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< u32, >>::rem(_self.into_inner(), rhs) .into(); @@ -22397,7 +24580,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Ref<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Sub< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::UVec4, >>::sub(_self.into_inner(), &rhs) .into(); @@ -22414,7 +24597,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Sub< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::UVec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -22431,7 +24614,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: u32| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Sub< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< u32, >>::sub(_self.into_inner(), rhs) .into(); @@ -22454,7 +24637,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { }; output }, - " `[x, y, z, w]`", + " Converts `self` to `[x, y, z, w]`", &["_self"], ) .register_documented( @@ -22649,7 +24832,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Ref<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Add< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::U8Vec2, >>::add(_self.into_inner(), &rhs) .into(); @@ -22666,7 +24849,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Add< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::U8Vec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -22683,7 +24866,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: u8| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Add< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< u8, >>::add(_self.into_inner(), rhs) .into(); @@ -22845,7 +25028,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U8Vec2>| { let output: () = { { - let output: () = <::glam::U8Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -22857,6 +25040,46 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { + let output: u8 = { + { + let output: u8 = ::glam::U8Vec2::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u8, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u8, + > = ::glam::U8Vec2::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u8::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -22885,7 +25108,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::clone::Clone>::clone( + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -23010,7 +25233,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Ref<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Div< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::U8Vec2, >>::div(_self.into_inner(), &rhs) .into(); @@ -23027,7 +25250,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Div< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::U8Vec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -23044,7 +25267,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: u8| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Div< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< u8, >>::div(_self.into_inner(), rhs) .into(); @@ -23129,7 +25352,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U8Vec2>, other: Ref<::glam::U8Vec2>| { let output: bool = { { - let output: bool = <::glam::U8Vec2 as ::core::cmp::PartialEq< + let output: bool = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::U8Vec2, >>::eq(&_self, &other) .into(); @@ -23191,6 +25414,24 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { + let output: u8 = { + { + let output: u8 = ::glam::U8Vec2::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u8::MAX`].\n See also [`checked_manhattan_distance`][U8Vec2::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { @@ -23206,7 +25447,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -23224,6 +25465,23 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::U8Vec2>| { + let output: usize = { + { + let output: usize = ::glam::U8Vec2::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { @@ -23239,7 +25497,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -23257,12 +25515,29 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::U8Vec2>| { + let output: usize = { + { + let output: usize = ::glam::U8Vec2::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::U8Vec2>, rhs: Ref<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Mul< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::U8Vec2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -23279,7 +25554,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Mul< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::U8Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -23296,7 +25571,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: u8| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Mul< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< u8, >>::mul(_self.into_inner(), rhs) .into(); @@ -23328,7 +25603,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Ref<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Rem< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::U8Vec2, >>::rem(_self.into_inner(), &rhs) .into(); @@ -23345,7 +25620,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Rem< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::U8Vec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -23362,7 +25637,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: u8| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Rem< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< u8, >>::rem(_self.into_inner(), rhs) .into(); @@ -23507,7 +25782,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Ref<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Sub< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::U8Vec2, >>::sub(_self.into_inner(), &rhs) .into(); @@ -23524,7 +25799,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Sub< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::U8Vec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -23541,7 +25816,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: u8| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Sub< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< u8, >>::sub(_self.into_inner(), rhs) .into(); @@ -23564,7 +25839,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { }; output }, - " `[x, y]`", + " Converts `self` to `[x, y]`", &["_self"], ) .register_documented( @@ -23706,7 +25981,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Ref<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Add< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::U8Vec3, >>::add(_self.into_inner(), &rhs) .into(); @@ -23723,7 +25998,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Add< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::U8Vec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -23740,7 +26015,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: u8| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Add< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< u8, >>::add(_self.into_inner(), rhs) .into(); @@ -23917,7 +26192,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U8Vec3>| { let output: () = { { - let output: () = <::glam::U8Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -23929,6 +26204,46 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { + let output: u8 = { + { + let output: u8 = ::glam::U8Vec3::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u8, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u8, + > = ::glam::U8Vec3::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u8::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -23957,7 +26272,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::clone::Clone>::clone( + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -24100,7 +26415,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Ref<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Div< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::U8Vec3, >>::div(_self.into_inner(), &rhs) .into(); @@ -24117,7 +26432,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Div< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::U8Vec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -24134,7 +26449,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: u8| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Div< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< u8, >>::div(_self.into_inner(), rhs) .into(); @@ -24219,7 +26534,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U8Vec3>, other: Ref<::glam::U8Vec3>| { let output: bool = { { - let output: bool = <::glam::U8Vec3 as ::core::cmp::PartialEq< + let output: bool = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::U8Vec3, >>::eq(&_self, &other) .into(); @@ -24281,6 +26596,24 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { + let output: u8 = { + { + let output: u8 = ::glam::U8Vec3::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u8::MAX`].\n See also [`checked_manhattan_distance`][U8Vec3::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { @@ -24296,7 +26629,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -24314,6 +26647,23 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::U8Vec3>| { + let output: usize = { + { + let output: usize = ::glam::U8Vec3::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { @@ -24329,7 +26679,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -24347,12 +26697,29 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::U8Vec3>| { + let output: usize = { + { + let output: usize = ::glam::U8Vec3::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::U8Vec3>, rhs: Ref<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Mul< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::U8Vec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -24369,7 +26736,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Mul< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::U8Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -24386,7 +26753,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: u8| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Mul< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< u8, >>::mul(_self.into_inner(), rhs) .into(); @@ -24418,7 +26785,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Ref<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Rem< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::U8Vec3, >>::rem(_self.into_inner(), &rhs) .into(); @@ -24435,7 +26802,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Rem< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::U8Vec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -24452,7 +26819,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: u8| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Rem< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< u8, >>::rem(_self.into_inner(), rhs) .into(); @@ -24597,7 +26964,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Ref<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Sub< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::U8Vec3, >>::sub(_self.into_inner(), &rhs) .into(); @@ -24614,7 +26981,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Sub< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::U8Vec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -24631,7 +26998,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: u8| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Sub< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< u8, >>::sub(_self.into_inner(), rhs) .into(); @@ -24654,7 +27021,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { }; output }, - " `[x, y, z]`", + " Converts `self` to `[x, y, z]`", &["_self"], ) .register_documented( @@ -24831,7 +27198,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Ref<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Add< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::U8Vec4, >>::add(_self.into_inner(), &rhs) .into(); @@ -24848,7 +27215,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Add< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::U8Vec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -24865,7 +27232,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: u8| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Add< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< u8, >>::add(_self.into_inner(), rhs) .into(); @@ -25027,7 +27394,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U8Vec4>| { let output: () = { { - let output: () = <::glam::U8Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -25039,6 +27406,46 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { + let output: u8 = { + { + let output: u8 = ::glam::U8Vec4::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u8, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u8, + > = ::glam::U8Vec4::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u8::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -25067,7 +27474,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::clone::Clone>::clone( + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -25192,7 +27599,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Ref<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Div< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::U8Vec4, >>::div(_self.into_inner(), &rhs) .into(); @@ -25209,7 +27616,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Div< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::U8Vec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -25226,7 +27633,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: u8| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Div< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< u8, >>::div(_self.into_inner(), rhs) .into(); @@ -25311,7 +27718,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U8Vec4>, other: Ref<::glam::U8Vec4>| { let output: bool = { { - let output: bool = <::glam::U8Vec4 as ::core::cmp::PartialEq< + let output: bool = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::U8Vec4, >>::eq(&_self, &other) .into(); @@ -25355,6 +27762,24 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { + let output: u8 = { + { + let output: u8 = ::glam::U8Vec4::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u8::MAX`].\n See also [`checked_manhattan_distance`][U8Vec4::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { @@ -25370,7 +27795,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -25388,6 +27813,23 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::U8Vec4>| { + let output: usize = { + { + let output: usize = ::glam::U8Vec4::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { @@ -25403,7 +27845,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -25421,12 +27863,29 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::U8Vec4>| { + let output: usize = { + { + let output: usize = ::glam::U8Vec4::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::U8Vec4>, rhs: Ref<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Mul< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::U8Vec4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -25443,7 +27902,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Mul< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::U8Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -25460,7 +27919,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: u8| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Mul< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< u8, >>::mul(_self.into_inner(), rhs) .into(); @@ -25492,7 +27951,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Ref<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Rem< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::U8Vec4, >>::rem(_self.into_inner(), &rhs) .into(); @@ -25509,7 +27968,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Rem< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::U8Vec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -25526,7 +27985,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: u8| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Rem< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< u8, >>::rem(_self.into_inner(), rhs) .into(); @@ -25671,7 +28130,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Ref<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Sub< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::U8Vec4, >>::sub(_self.into_inner(), &rhs) .into(); @@ -25688,7 +28147,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Sub< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::U8Vec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -25705,7 +28164,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: u8| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Sub< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< u8, >>::sub(_self.into_inner(), rhs) .into(); @@ -25728,7 +28187,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { }; output }, - " `[x, y, z, w]`", + " Converts `self` to `[x, y, z, w]`", &["_self"], ) .register_documented( @@ -25923,7 +28382,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Ref<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Add< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::U16Vec2, >>::add(_self.into_inner(), &rhs) .into(); @@ -25940,7 +28399,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Add< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::U16Vec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -25957,7 +28416,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: u16| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Add< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< u16, >>::add(_self.into_inner(), rhs) .into(); @@ -26125,7 +28584,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U16Vec2>| { let output: () = { { - let output: () = <::glam::U16Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -26137,6 +28596,46 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { + let output: u16 = { + { + let output: u16 = ::glam::U16Vec2::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u16, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u16, + > = ::glam::U16Vec2::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u16::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -26165,7 +28664,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::clone::Clone>::clone( + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -26290,7 +28789,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Ref<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Div< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::U16Vec2, >>::div(_self.into_inner(), &rhs) .into(); @@ -26307,7 +28806,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Div< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::U16Vec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -26324,7 +28823,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: u16| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Div< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< u16, >>::div(_self.into_inner(), rhs) .into(); @@ -26411,7 +28910,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U16Vec2>, other: Ref<::glam::U16Vec2>| { let output: bool = { { - let output: bool = <::glam::U16Vec2 as ::core::cmp::PartialEq< + let output: bool = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::U16Vec2, >>::eq(&_self, &other) .into(); @@ -26473,6 +28972,24 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { + let output: u16 = { + { + let output: u16 = ::glam::U16Vec2::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u16::MAX`].\n See also [`checked_manhattan_distance`][U16Vec2::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { @@ -26488,7 +29005,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -26508,6 +29025,23 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::U16Vec2>| { + let output: usize = { + { + let output: usize = ::glam::U16Vec2::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { @@ -26523,7 +29057,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -26543,12 +29077,29 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::U16Vec2>| { + let output: usize = { + { + let output: usize = ::glam::U16Vec2::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::U16Vec2>, rhs: Ref<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Mul< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::U16Vec2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -26565,7 +29116,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Mul< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::U16Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -26582,7 +29133,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: u16| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Mul< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< u16, >>::mul(_self.into_inner(), rhs) .into(); @@ -26614,7 +29165,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Ref<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Rem< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::U16Vec2, >>::rem(_self.into_inner(), &rhs) .into(); @@ -26631,7 +29182,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Rem< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::U16Vec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -26648,7 +29199,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: u16| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Rem< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< u16, >>::rem(_self.into_inner(), rhs) .into(); @@ -26793,7 +29344,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Ref<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Sub< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::U16Vec2, >>::sub(_self.into_inner(), &rhs) .into(); @@ -26810,7 +29361,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Sub< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::U16Vec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -26827,7 +29378,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: u16| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Sub< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< u16, >>::sub(_self.into_inner(), rhs) .into(); @@ -26850,7 +29401,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { }; output }, - " `[x, y]`", + " Converts `self` to `[x, y]`", &["_self"], ) .register_documented( @@ -26992,7 +29543,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Ref<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Add< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::U16Vec3, >>::add(_self.into_inner(), &rhs) .into(); @@ -27009,7 +29560,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Add< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::U16Vec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -27026,7 +29577,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: u16| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Add< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< u16, >>::add(_self.into_inner(), rhs) .into(); @@ -27211,7 +29762,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U16Vec3>| { let output: () = { { - let output: () = <::glam::U16Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -27223,6 +29774,46 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { + let output: u16 = { + { + let output: u16 = ::glam::U16Vec3::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u16, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u16, + > = ::glam::U16Vec3::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u16::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -27251,7 +29842,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::clone::Clone>::clone( + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -27394,7 +29985,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Ref<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Div< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::U16Vec3, >>::div(_self.into_inner(), &rhs) .into(); @@ -27411,7 +30002,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Div< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::U16Vec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -27428,7 +30019,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: u16| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Div< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< u16, >>::div(_self.into_inner(), rhs) .into(); @@ -27515,7 +30106,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U16Vec3>, other: Ref<::glam::U16Vec3>| { let output: bool = { { - let output: bool = <::glam::U16Vec3 as ::core::cmp::PartialEq< + let output: bool = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::U16Vec3, >>::eq(&_self, &other) .into(); @@ -27577,6 +30168,24 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { + let output: u16 = { + { + let output: u16 = ::glam::U16Vec3::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u16::MAX`].\n See also [`checked_manhattan_distance`][U16Vec3::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { @@ -27592,7 +30201,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -27612,6 +30221,23 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::U16Vec3>| { + let output: usize = { + { + let output: usize = ::glam::U16Vec3::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { @@ -27627,7 +30253,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -27647,12 +30273,29 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::U16Vec3>| { + let output: usize = { + { + let output: usize = ::glam::U16Vec3::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::U16Vec3>, rhs: Ref<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Mul< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::U16Vec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -27669,7 +30312,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Mul< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::U16Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -27686,7 +30329,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: u16| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Mul< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< u16, >>::mul(_self.into_inner(), rhs) .into(); @@ -27718,7 +30361,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Ref<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Rem< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::U16Vec3, >>::rem(_self.into_inner(), &rhs) .into(); @@ -27735,7 +30378,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Rem< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::U16Vec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -27752,7 +30395,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: u16| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Rem< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< u16, >>::rem(_self.into_inner(), rhs) .into(); @@ -27897,7 +30540,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Ref<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Sub< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::U16Vec3, >>::sub(_self.into_inner(), &rhs) .into(); @@ -27914,7 +30557,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Sub< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::U16Vec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -27931,7 +30574,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: u16| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Sub< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< u16, >>::sub(_self.into_inner(), rhs) .into(); @@ -27954,7 +30597,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { }; output }, - " `[x, y, z]`", + " Converts `self` to `[x, y, z]`", &["_self"], ) .register_documented( @@ -28131,7 +30774,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Ref<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Add< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::U16Vec4, >>::add(_self.into_inner(), &rhs) .into(); @@ -28148,7 +30791,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Add< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::U16Vec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -28165,7 +30808,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: u16| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Add< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< u16, >>::add(_self.into_inner(), rhs) .into(); @@ -28333,7 +30976,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U16Vec4>| { let output: () = { { - let output: () = <::glam::U16Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -28345,6 +30988,46 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { + let output: u16 = { + { + let output: u16 = ::glam::U16Vec4::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u16, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u16, + > = ::glam::U16Vec4::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u16::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -28373,7 +31056,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::clone::Clone>::clone( + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -28498,7 +31181,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Ref<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Div< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::U16Vec4, >>::div(_self.into_inner(), &rhs) .into(); @@ -28515,7 +31198,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Div< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::U16Vec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -28532,7 +31215,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: u16| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Div< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< u16, >>::div(_self.into_inner(), rhs) .into(); @@ -28619,7 +31302,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U16Vec4>, other: Ref<::glam::U16Vec4>| { let output: bool = { { - let output: bool = <::glam::U16Vec4 as ::core::cmp::PartialEq< + let output: bool = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::U16Vec4, >>::eq(&_self, &other) .into(); @@ -28663,6 +31346,24 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { + let output: u16 = { + { + let output: u16 = ::glam::U16Vec4::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u16::MAX`].\n See also [`checked_manhattan_distance`][U16Vec4::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { @@ -28678,7 +31379,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -28698,6 +31399,23 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::U16Vec4>| { + let output: usize = { + { + let output: usize = ::glam::U16Vec4::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { @@ -28713,7 +31431,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -28733,12 +31451,29 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::U16Vec4>| { + let output: usize = { + { + let output: usize = ::glam::U16Vec4::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::U16Vec4>, rhs: Ref<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Mul< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::U16Vec4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -28755,7 +31490,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Mul< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::U16Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -28772,7 +31507,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: u16| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Mul< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< u16, >>::mul(_self.into_inner(), rhs) .into(); @@ -28809,7 +31544,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Ref<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Rem< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::U16Vec4, >>::rem(_self.into_inner(), &rhs) .into(); @@ -28826,7 +31561,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Rem< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::U16Vec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -28843,7 +31578,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: u16| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Rem< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< u16, >>::rem(_self.into_inner(), rhs) .into(); @@ -28988,7 +31723,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Ref<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Sub< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::U16Vec4, >>::sub(_self.into_inner(), &rhs) .into(); @@ -29005,7 +31740,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Sub< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::U16Vec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -29022,7 +31757,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: u16| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Sub< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< u16, >>::sub(_self.into_inner(), rhs) .into(); @@ -29045,7 +31780,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { }; output }, - " `[x, y, z, w]`", + " Converts `self` to `[x, y, z, w]`", &["_self"], ) .register_documented( @@ -29240,7 +31975,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Ref<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Add< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::U64Vec2, >>::add(_self.into_inner(), &rhs) .into(); @@ -29257,7 +31992,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Add< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::U64Vec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -29274,7 +32009,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: u64| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Add< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< u64, >>::add(_self.into_inner(), rhs) .into(); @@ -29442,7 +32177,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U64Vec2>| { let output: () = { { - let output: () = <::glam::U64Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -29454,6 +32189,46 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { + let output: u64 = { + { + let output: u64 = ::glam::U64Vec2::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u64, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u64, + > = ::glam::U64Vec2::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u64::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -29482,7 +32257,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::clone::Clone>::clone( + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -29607,7 +32382,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Ref<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Div< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::U64Vec2, >>::div(_self.into_inner(), &rhs) .into(); @@ -29624,7 +32399,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Div< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::U64Vec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -29641,7 +32416,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: u64| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Div< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< u64, >>::div(_self.into_inner(), rhs) .into(); @@ -29728,7 +32503,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U64Vec2>, other: Ref<::glam::U64Vec2>| { let output: bool = { { - let output: bool = <::glam::U64Vec2 as ::core::cmp::PartialEq< + let output: bool = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::U64Vec2, >>::eq(&_self, &other) .into(); @@ -29790,6 +32565,24 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { + let output: u64 = { + { + let output: u64 = ::glam::U64Vec2::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u64::MAX`].\n See also [`checked_manhattan_distance`][U64Vec2::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { @@ -29805,7 +32598,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -29825,6 +32618,23 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::U64Vec2>| { + let output: usize = { + { + let output: usize = ::glam::U64Vec2::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { @@ -29840,7 +32650,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -29860,12 +32670,29 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::U64Vec2>| { + let output: usize = { + { + let output: usize = ::glam::U64Vec2::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::U64Vec2>, rhs: Ref<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Mul< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::U64Vec2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -29882,7 +32709,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Mul< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::U64Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -29899,7 +32726,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: u64| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Mul< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< u64, >>::mul(_self.into_inner(), rhs) .into(); @@ -29931,7 +32758,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Ref<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Rem< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::U64Vec2, >>::rem(_self.into_inner(), &rhs) .into(); @@ -29948,7 +32775,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Rem< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::U64Vec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -29965,7 +32792,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: u64| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Rem< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< u64, >>::rem(_self.into_inner(), rhs) .into(); @@ -30110,7 +32937,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Ref<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Sub< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::U64Vec2, >>::sub(_self.into_inner(), &rhs) .into(); @@ -30127,7 +32954,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Sub< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::U64Vec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -30144,7 +32971,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: u64| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Sub< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< u64, >>::sub(_self.into_inner(), rhs) .into(); @@ -30167,7 +32994,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { }; output }, - " `[x, y]`", + " Converts `self` to `[x, y]`", &["_self"], ) .register_documented( @@ -30309,7 +33136,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Ref<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Add< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::U64Vec3, >>::add(_self.into_inner(), &rhs) .into(); @@ -30326,7 +33153,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Add< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::U64Vec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -30343,7 +33170,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: u64| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Add< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< u64, >>::add(_self.into_inner(), rhs) .into(); @@ -30528,7 +33355,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U64Vec3>| { let output: () = { { - let output: () = <::glam::U64Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -30540,6 +33367,46 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { + let output: u64 = { + { + let output: u64 = ::glam::U64Vec3::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u64, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u64, + > = ::glam::U64Vec3::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u64::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -30568,7 +33435,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::clone::Clone>::clone( + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -30711,7 +33578,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Ref<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Div< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::U64Vec3, >>::div(_self.into_inner(), &rhs) .into(); @@ -30728,7 +33595,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Div< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::U64Vec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -30745,7 +33612,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: u64| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Div< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< u64, >>::div(_self.into_inner(), rhs) .into(); @@ -30832,7 +33699,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U64Vec3>, other: Ref<::glam::U64Vec3>| { let output: bool = { { - let output: bool = <::glam::U64Vec3 as ::core::cmp::PartialEq< + let output: bool = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::U64Vec3, >>::eq(&_self, &other) .into(); @@ -30894,6 +33761,24 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { + let output: u64 = { + { + let output: u64 = ::glam::U64Vec3::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u64::MAX`].\n See also [`checked_manhattan_distance`][U64Vec3::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { @@ -30909,7 +33794,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -30929,6 +33814,23 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::U64Vec3>| { + let output: usize = { + { + let output: usize = ::glam::U64Vec3::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { @@ -30944,7 +33846,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -30964,12 +33866,29 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::U64Vec3>| { + let output: usize = { + { + let output: usize = ::glam::U64Vec3::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::U64Vec3>, rhs: Ref<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Mul< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::U64Vec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -30986,7 +33905,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Mul< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::U64Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -31003,7 +33922,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: u64| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Mul< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< u64, >>::mul(_self.into_inner(), rhs) .into(); @@ -31035,7 +33954,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Ref<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Rem< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::U64Vec3, >>::rem(_self.into_inner(), &rhs) .into(); @@ -31052,7 +33971,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Rem< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::U64Vec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -31069,7 +33988,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: u64| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Rem< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< u64, >>::rem(_self.into_inner(), rhs) .into(); @@ -31214,7 +34133,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Ref<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Sub< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::U64Vec3, >>::sub(_self.into_inner(), &rhs) .into(); @@ -31231,7 +34150,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Sub< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::U64Vec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -31248,7 +34167,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: u64| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Sub< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< u64, >>::sub(_self.into_inner(), rhs) .into(); @@ -31271,7 +34190,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { }; output }, - " `[x, y, z]`", + " Converts `self` to `[x, y, z]`", &["_self"], ) .register_documented( @@ -31448,7 +34367,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Ref<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Add< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::U64Vec4, >>::add(_self.into_inner(), &rhs) .into(); @@ -31465,7 +34384,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Add< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::U64Vec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -31482,7 +34401,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: u64| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Add< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< u64, >>::add(_self.into_inner(), rhs) .into(); @@ -31650,7 +34569,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U64Vec4>| { let output: () = { { - let output: () = <::glam::U64Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -31662,6 +34581,46 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "chebyshev_distance", + |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { + let output: u64 = { + { + let output: u64 = ::glam::U64Vec4::chebyshev_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [chebyshev distance] between two points.\n [chebyshev distance]: https://en.wikipedia.org/wiki/Chebyshev_distance", + &["_self", "rhs"], + ) + .register_documented( + "checked_manhattan_distance", + |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u64, + > = { + { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + u64, + > = ::glam::U64Vec4::checked_manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n This will returns [`None`] if the result is greater than [`u64::MAX`].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "clamp", | @@ -31690,7 +34649,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::clone::Clone>::clone( + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -31815,7 +34774,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Ref<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Div< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::U64Vec4, >>::div(_self.into_inner(), &rhs) .into(); @@ -31832,7 +34791,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Div< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::U64Vec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -31849,7 +34808,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: u64| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Div< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< u64, >>::div(_self.into_inner(), rhs) .into(); @@ -31936,7 +34895,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U64Vec4>, other: Ref<::glam::U64Vec4>| { let output: bool = { { - let output: bool = <::glam::U64Vec4 as ::core::cmp::PartialEq< + let output: bool = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::U64Vec4, >>::eq(&_self, &other) .into(); @@ -31980,6 +34939,24 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { " Computes the squared length of `self`.", &["_self"], ) + .register_documented( + "manhattan_distance", + |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { + let output: u64 = { + { + let output: u64 = ::glam::U64Vec4::manhattan_distance( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the [manhattan distance] between two points.\n # Overflow\n This method may overflow if the result is greater than [`u64::MAX`].\n See also [`checked_manhattan_distance`][U64Vec4::checked_manhattan_distance].\n [manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry", + &["_self", "rhs"], + ) .register_documented( "max", |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { @@ -31995,7 +34972,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -32015,6 +34992,23 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", &["_self"], ) + .register_documented( + "max_position", + |_self: Val<::glam::U64Vec4>| { + let output: usize = { + { + let output: usize = ::glam::U64Vec4::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", + &["_self"], + ) .register_documented( "min", |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { @@ -32030,7 +35024,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.", &["_self", "rhs"], ) .register_documented( @@ -32050,12 +35044,29 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", &["_self"], ) + .register_documented( + "min_position", + |_self: Val<::glam::U64Vec4>| { + let output: usize = { + { + let output: usize = ::glam::U64Vec4::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", + &["_self"], + ) .register_documented( "mul", |_self: Val<::glam::U64Vec4>, rhs: Ref<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Mul< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::U64Vec4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -32072,7 +35083,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Mul< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::U64Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -32089,7 +35100,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: u64| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Mul< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< u64, >>::mul(_self.into_inner(), rhs) .into(); @@ -32126,7 +35137,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Ref<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Rem< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::U64Vec4, >>::rem(_self.into_inner(), &rhs) .into(); @@ -32143,7 +35154,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Rem< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::U64Vec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -32160,7 +35171,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: u64| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Rem< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< u64, >>::rem(_self.into_inner(), rhs) .into(); @@ -32305,7 +35316,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Ref<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Sub< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::U64Vec4, >>::sub(_self.into_inner(), &rhs) .into(); @@ -32322,7 +35333,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Sub< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::U64Vec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -32339,7 +35350,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: u64| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Sub< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< u64, >>::sub(_self.into_inner(), rhs) .into(); @@ -32362,7 +35373,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { }; output }, - " `[x, y, z, w]`", + " Converts `self` to `[x, y, z, w]`", &["_self"], ) .register_documented( @@ -32593,7 +35604,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Ref<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Add< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::Vec2, >>::add(_self.into_inner(), &rhs) .into(); @@ -32610,7 +35621,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Add< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::Vec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -32627,7 +35638,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Add< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< f32, >>::add(_self.into_inner(), rhs) .into(); @@ -32851,7 +35862,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { }; output }, - " Component-wise clamping of values, similar to [`f32::clamp`].\n Each element in `min` must be less-or-equal to the corresponding element in `max`.\n # Panics\n Will panic if `min` is greater than `max` when `glam_assert` is enabled.", + " Component-wise clamping of values, similar to [`f32::clamp`].\n Each element in `min` must be less-or-equal to the corresponding element in `max`.\n NaN propogation does not follow IEEE 754-2008 semantics and may differ on\n different SIMD architectures.\n # Panics\n Will panic if `min` is greater than `max` when `glam_assert` is enabled.", &["_self", "min", "max"], ) .register_documented( @@ -32914,7 +35925,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Ref<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::clone::Clone>::clone( + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -33093,7 +36104,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Ref<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Div< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::Vec2, >>::div(_self.into_inner(), &rhs) .into(); @@ -33110,7 +36121,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Div< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::Vec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -33127,7 +36138,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Div< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -33230,7 +36241,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Ref<::glam::Vec2>, other: Ref<::glam::Vec2>| { let output: bool = { { - let output: bool = <::glam::Vec2 as ::core::cmp::PartialEq< + let output: bool = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::Vec2, >>::eq(&_self, &other) .into(); @@ -33436,7 +36447,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { }; output }, - " Returns a bitmask with the lowest 2 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.", + " Returns a bitmask with the lowest 2 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.\n An element is negative if it has a negative sign, including -0.0, NaNs with negative sign\n bit and negative infinity.", &["_self"], ) .register_documented( @@ -33537,7 +36548,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.\n NaN propogation does not follow IEEE 754-2008 semantics for maxNum and may differ on\n different SIMD architectures.", &["_self", "rhs"], ) .register_documented( @@ -33552,7 +36563,24 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { }; output }, - " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", + " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.\n NaN propogation does not follow IEEE 754-2008 semantics and may differ on\n different SIMD architectures.", + &["_self"], + ) + .register_documented( + "max_position", + |_self: Val<::glam::Vec2>| { + let output: usize = { + { + let output: usize = ::glam::Vec2::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", &["_self"], ) .register_documented( @@ -33588,7 +36616,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.\n NaN propogation does not follow IEEE 754-2008 semantics for minNum and may differ on\n different SIMD architectures.", &["_self", "rhs"], ) .register_documented( @@ -33603,7 +36631,24 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { }; output }, - " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", + " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.\n NaN propogation does not follow IEEE 754-2008 semantics and may differ on\n different SIMD architectures.", + &["_self"], + ) + .register_documented( + "min_position", + |_self: Val<::glam::Vec2>| { + let output: usize = { + { + let output: usize = ::glam::Vec2::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", &["_self"], ) .register_documented( @@ -33630,7 +36675,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Ref<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Mul< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::Vec2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -33647,7 +36692,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Mul< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -33664,7 +36709,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Mul< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -33700,7 +36745,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Neg>::neg( + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -33740,7 +36785,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { }; output }, - " Returns `self` normalized to length 1.0.\n For valid results, `self` must be finite and _not_ of length zero, nor very close to zero.\n See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`].\n Panics\n Will panic if the resulting normalized vector is not finite when `glam_assert` is enabled.", + " Returns `self` normalized to length 1.0.\n For valid results, `self` must be finite and _not_ of length zero, nor very close to zero.\n See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`].\n # Panics\n Will panic if the resulting normalized vector is not finite when `glam_assert` is enabled.", &["_self"], ) .register_documented( @@ -33962,7 +37007,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Ref<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Rem< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::Vec2, >>::rem(_self.into_inner(), &rhs) .into(); @@ -33979,7 +37024,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Rem< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::Vec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -33996,7 +37041,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Rem< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< f32, >>::rem(_self.into_inner(), rhs) .into(); @@ -34041,7 +37086,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { }; output }, - " Returns `rhs` rotated by the angle of `self`. If `self` is normalized,\n then this just rotation. This is what you usually want. Otherwise,\n it will be like a rotation with a multiplication by `self`'s length.", + " Returns `rhs` rotated by the angle of `self`. If `self` is normalized,\n then this just rotation. This is what you usually want. Otherwise,\n it will be like a rotation with a multiplication by `self`'s length.\n This can be used in conjunction with the [`from_angle()`][Self::from_angle()] method, e.g.\n `Vec2::from_angle(PI).rotate(Vec2::Y)` will create the vector `[-1, 0]`\n and rotate [`Vec2::Y`] around it returning `-Vec2::Y`.", &["_self", "rhs"], ) .register_documented( @@ -34060,7 +37105,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { }; output }, - " Rotates towards `rhs` up to `max_angle` (in radians).\n When `max_angle` is `0.0`, the result will be equal to `self`. When `max_angle` is equal to\n `self.angle_between(rhs)`, the result will be equal to `rhs`. If `max_angle` is negative,\n rotates towards the exact opposite of `rhs`. Will not go past the target.", + " Rotates towards `rhs` up to `max_angle` (in radians).\n When `max_angle` is `0.0`, the result will be equal to `self`. When `max_angle` is equal to\n `self.angle_between(rhs)`, the result will be parallel to `rhs`. If `max_angle` is negative,\n rotates towards the exact opposite of `rhs`. Will not go past the target.", &["_self", "rhs", "max_angle"], ) .register_documented( @@ -34139,7 +37184,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Ref<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Sub< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::Vec2, >>::sub(_self.into_inner(), &rhs) .into(); @@ -34156,7 +37201,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Sub< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::Vec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -34173,7 +37218,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Sub< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< f32, >>::sub(_self.into_inner(), rhs) .into(); @@ -34211,7 +37256,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { }; output }, - " `[x, y]`", + " Converts `self` to `[x, y]`", &["_self"], ) .register_documented( @@ -34316,7 +37361,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Add< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::Vec3A, >>::add(_self.into_inner(), &rhs) .into(); @@ -34333,7 +37378,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Add< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::Vec3A, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -34350,7 +37395,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Add< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< f32, >>::add(_self.into_inner(), rhs) .into(); @@ -34598,7 +37643,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { }; output }, - " Component-wise clamping of values, similar to [`f32::clamp`].\n Each element in `min` must be less-or-equal to the corresponding element in `max`.\n # Panics\n Will panic if `min` is greater than `max` when `glam_assert` is enabled.", + " Component-wise clamping of values, similar to [`f32::clamp`].\n Each element in `min` must be less-or-equal to the corresponding element in `max`.\n NaN propogation does not follow IEEE 754-2008 semantics and may differ on\n different SIMD architectures.\n # Panics\n Will panic if `min` is greater than `max` when `glam_assert` is enabled.", &["_self", "min", "max"], ) .register_documented( @@ -34661,7 +37706,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::clone::Clone>::clone( + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -34858,7 +37903,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Div< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::Vec3A, >>::div(_self.into_inner(), &rhs) .into(); @@ -34875,7 +37920,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Div< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::Vec3A, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -34892,7 +37937,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Div< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -34995,7 +38040,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::Vec3A>, rhs: Ref<::glam::Vec3A>| { let output: bool = { { - let output: bool = <::glam::Vec3A as ::core::cmp::PartialEq< + let output: bool = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::Vec3A, >>::eq(&_self, &rhs) .into(); @@ -35203,7 +38248,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { }; output }, - " Returns a bitmask with the lowest 3 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.", + " Returns a bitmask with the lowest 3 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.\n An element is negative if it has a negative sign, including -0.0, NaNs with negative sign\n bit and negative infinity.", &["_self"], ) .register_documented( @@ -35304,7 +38349,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.\n NaN propogation does not follow IEEE 754-2008 semantics for maxNum and may differ on\n different SIMD architectures.", &["_self", "rhs"], ) .register_documented( @@ -35319,7 +38364,24 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { }; output }, - " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", + " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.\n NaN propogation does not follow IEEE 754-2008 semantics and may differ on\n different SIMD architectures.", + &["_self"], + ) + .register_documented( + "max_position", + |_self: Val<::glam::Vec3A>| { + let output: usize = { + { + let output: usize = ::glam::Vec3A::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", &["_self"], ) .register_documented( @@ -35355,7 +38417,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.\n NaN propogation does not follow IEEE 754-2008 semantics for minNum and may differ on\n different SIMD architectures.", &["_self", "rhs"], ) .register_documented( @@ -35370,7 +38432,24 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { }; output }, - " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", + " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.\n NaN propogation does not follow IEEE 754-2008 semantics and may differ on\n different SIMD architectures.", + &["_self"], + ) + .register_documented( + "min_position", + |_self: Val<::glam::Vec3A>| { + let output: usize = { + { + let output: usize = ::glam::Vec3A::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", &["_self"], ) .register_documented( @@ -35397,7 +38476,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Mul< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::Vec3A, >>::mul(_self.into_inner(), &rhs) .into(); @@ -35414,7 +38493,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Mul< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Vec3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -35431,7 +38510,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Mul< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -35467,7 +38546,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Neg>::neg( + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -35508,7 +38587,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { }; output }, - " Returns `self` normalized to length 1.0.\n For valid results, `self` must be finite and _not_ of length zero, nor very close to zero.\n See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`].\n Panics\n Will panic if the resulting normalized vector is not finite when `glam_assert` is enabled.", + " Returns `self` normalized to length 1.0.\n For valid results, `self` must be finite and _not_ of length zero, nor very close to zero.\n See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`].\n # Panics\n Will panic if the resulting normalized vector is not finite when `glam_assert` is enabled.", &["_self"], ) .register_documented( @@ -35695,7 +38774,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Rem< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::Vec3A, >>::rem(_self.into_inner(), &rhs) .into(); @@ -35712,7 +38791,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Rem< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::Vec3A, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -35729,7 +38808,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Rem< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< f32, >>::rem(_self.into_inner(), rhs) .into(); @@ -35759,6 +38838,98 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { " Returns the element-wise remainder of [Euclidean division] of `self` by `rhs`.\n [Euclidean division]: f32::rem_euclid", &["_self", "rhs"], ) + .register_documented( + "rotate_axis", + |_self: Val<::glam::Vec3A>, axis: Val<::glam::Vec3A>, angle: f32| { + let output: Val<::glam::Vec3A> = { + { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::rotate_axis( + _self.into_inner(), + axis.into_inner(), + angle, + ) + .into(); + output + } + }; + output + }, + " Rotates around `axis` by `angle` (in radians).\n The axis must be a unit vector.\n # Panics\n Will panic if `axis` is not normalized when `glam_assert` is enabled.", + &["_self", "axis", "angle"], + ) + .register_documented( + "rotate_towards", + |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>, max_angle: f32| { + let output: Val<::glam::Vec3A> = { + { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::rotate_towards( + _self.into_inner(), + rhs.into_inner(), + max_angle, + ) + .into(); + output + } + }; + output + }, + " Rotates towards `rhs` up to `max_angle` (in radians).\n When `max_angle` is `0.0`, the result will be equal to `self`. When `max_angle` is equal to\n `self.angle_between(rhs)`, the result will be parallel to `rhs`. If `max_angle` is negative,\n rotates towards the exact opposite of `rhs`. Will not go past the target.", + &["_self", "rhs", "max_angle"], + ) + .register_documented( + "rotate_x", + |_self: Val<::glam::Vec3A>, angle: f32| { + let output: Val<::glam::Vec3A> = { + { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::rotate_x( + _self.into_inner(), + angle, + ) + .into(); + output + } + }; + output + }, + " Rotates around the x axis by `angle` (in radians).", + &["_self", "angle"], + ) + .register_documented( + "rotate_y", + |_self: Val<::glam::Vec3A>, angle: f32| { + let output: Val<::glam::Vec3A> = { + { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::rotate_y( + _self.into_inner(), + angle, + ) + .into(); + output + } + }; + output + }, + " Rotates around the y axis by `angle` (in radians).", + &["_self", "angle"], + ) + .register_documented( + "rotate_z", + |_self: Val<::glam::Vec3A>, angle: f32| { + let output: Val<::glam::Vec3A> = { + { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::rotate_z( + _self.into_inner(), + angle, + ) + .into(); + output + } + }; + output + }, + " Rotates around the z axis by `angle` (in radians).", + &["_self", "angle"], + ) .register_documented( "round", |_self: Val<::glam::Vec3A>| { @@ -35816,6 +38987,25 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { " Returns a vector with elements representing the sign of `self`.\n - `1.0` if the number is positive, `+0.0` or `INFINITY`\n - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`\n - `NAN` if the number is `NAN`", &["_self"], ) + .register_documented( + "slerp", + |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>, s: f32| { + let output: Val<::glam::Vec3A> = { + { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::slerp( + _self.into_inner(), + rhs.into_inner(), + s, + ) + .into(); + output + } + }; + output + }, + " Performs a spherical linear interpolation between `self` and `rhs` based on the value `s`.\n When `s` is `0.0`, the result will be equal to `self`. When `s` is `1.0`, the result\n will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly\n extrapolated.", + &["_self", "rhs", "s"], + ) .register_documented( "splat", |v: f32| { @@ -35835,7 +39025,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Sub< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::Vec3A, >>::sub(_self.into_inner(), &rhs) .into(); @@ -35852,7 +39042,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Sub< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::Vec3A, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -35869,7 +39059,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Sub< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< f32, >>::sub(_self.into_inner(), rhs) .into(); @@ -35892,7 +39082,24 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { }; output }, - " `[x, y, z]`", + " Converts `self` to `[x, y, z]`", + &["_self"], + ) + .register_documented( + "to_vec3", + |_self: Val<::glam::Vec3A>| { + let output: Val<::glam::Vec3> = { + { + let output: Val<::glam::Vec3> = ::glam::Vec3A::to_vec3( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", &["_self"], ) .register_documented( @@ -36032,7 +39239,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Ref<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Add< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::Vec4, >>::add(_self.into_inner(), &rhs) .into(); @@ -36049,7 +39256,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Add< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::Vec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -36066,7 +39273,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Add< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< f32, >>::add(_self.into_inner(), rhs) .into(); @@ -36254,7 +39461,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { }; output }, - " Component-wise clamping of values, similar to [`f32::clamp`].\n Each element in `min` must be less-or-equal to the corresponding element in `max`.\n # Panics\n Will panic if `min` is greater than `max` when `glam_assert` is enabled.", + " Component-wise clamping of values, similar to [`f32::clamp`].\n Each element in `min` must be less-or-equal to the corresponding element in `max`.\n NaN propogation does not follow IEEE 754-2008 semantics and may differ on\n different SIMD architectures.\n # Panics\n Will panic if `min` is greater than `max` when `glam_assert` is enabled.", &["_self", "min", "max"], ) .register_documented( @@ -36317,7 +39524,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Ref<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::clone::Clone>::clone( + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -36496,7 +39703,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Ref<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Div< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::Vec4, >>::div(_self.into_inner(), &rhs) .into(); @@ -36513,7 +39720,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Div< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::Vec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -36530,7 +39737,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Div< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -36633,7 +39840,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Ref<::glam::Vec4>, rhs: Ref<::glam::Vec4>| { let output: bool = { { - let output: bool = <::glam::Vec4 as ::core::cmp::PartialEq< + let output: bool = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::Vec4, >>::eq(&_self, &rhs) .into(); @@ -36806,7 +40013,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { }; output }, - " Returns a bitmask with the lowest 4 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.", + " Returns a bitmask with the lowest 4 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.\n An element is negative if it has a negative sign, including -0.0, NaNs with negative sign\n bit and negative infinity.", &["_self"], ) .register_documented( @@ -36907,7 +40114,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.\n NaN propogation does not follow IEEE 754-2008 semantics for maxNum and may differ on\n different SIMD architectures.", &["_self", "rhs"], ) .register_documented( @@ -36922,7 +40129,24 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { }; output }, - " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", + " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.\n NaN propogation does not follow IEEE 754-2008 semantics and may differ on\n different SIMD architectures.", + &["_self"], + ) + .register_documented( + "max_position", + |_self: Val<::glam::Vec4>| { + let output: usize = { + { + let output: usize = ::glam::Vec4::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", &["_self"], ) .register_documented( @@ -36958,7 +40182,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.\n NaN propogation does not follow IEEE 754-2008 semantics for minNum and may differ on\n different SIMD architectures.", &["_self", "rhs"], ) .register_documented( @@ -36973,7 +40197,24 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { }; output }, - " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", + " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.\n NaN propogation does not follow IEEE 754-2008 semantics and may differ on\n different SIMD architectures.", + &["_self"], + ) + .register_documented( + "min_position", + |_self: Val<::glam::Vec4>| { + let output: usize = { + { + let output: usize = ::glam::Vec4::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", &["_self"], ) .register_documented( @@ -37000,7 +40241,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Ref<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Mul< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::Vec4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -37017,7 +40258,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Mul< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -37034,7 +40275,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Mul< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -37070,7 +40311,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Neg>::neg( + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -37111,7 +40352,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { }; output }, - " Returns `self` normalized to length 1.0.\n For valid results, `self` must be finite and _not_ of length zero, nor very close to zero.\n See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`].\n Panics\n Will panic if the resulting normalized vector is not finite when `glam_assert` is enabled.", + " Returns `self` normalized to length 1.0.\n For valid results, `self` must be finite and _not_ of length zero, nor very close to zero.\n See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`].\n # Panics\n Will panic if the resulting normalized vector is not finite when `glam_assert` is enabled.", &["_self"], ) .register_documented( @@ -37298,7 +40539,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Ref<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Rem< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::Vec4, >>::rem(_self.into_inner(), &rhs) .into(); @@ -37315,7 +40556,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Rem< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::Vec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -37332,7 +40573,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Rem< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< f32, >>::rem(_self.into_inner(), rhs) .into(); @@ -37438,7 +40679,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Ref<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Sub< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::Vec4, >>::sub(_self.into_inner(), &rhs) .into(); @@ -37455,7 +40696,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Sub< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::Vec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -37472,7 +40713,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Sub< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< f32, >>::sub(_self.into_inner(), rhs) .into(); @@ -37495,7 +40736,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { }; output }, - " `[x, y, z, w]`", + " Converts `self` to `[x, y, z, w]`", &["_self"], ) .register_documented( @@ -37529,7 +40770,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { }; output }, - " Creates a 3D vector from the `x`, `y` and `z` elements of `self`, discarding `w`.\n Truncation to [`Vec3`] may also be performed by using [`self.xyz()`][crate::swizzles::Vec4Swizzles::xyz()].\n To truncate to [`Vec3A`] use [`Vec3A::from()`].", + " Creates a 3D vector from the `x`, `y` and `z` elements of `self`, discarding `w`.\n Truncation to [`Vec3`] may also be performed by using [`self.xyz()`][crate::swizzles::Vec4Swizzles::xyz()].\n To truncate to [`Vec3A`] use [`Vec3A::from_vec4()`].", &["_self"], ) .register_documented( @@ -37645,7 +40886,7 @@ pub(crate) fn register_b_vec_2_functions(world: &mut World) { |_self: Ref<::glam::BVec2>| { let output: () = { { - let output: () = <::glam::BVec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::BVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -37677,7 +40918,7 @@ pub(crate) fn register_b_vec_2_functions(world: &mut World) { |_self: Ref<::glam::BVec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = <::glam::BVec2 as ::core::clone::Clone>::clone( + let output: Val<::glam::BVec2> = <::glam::BVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -37694,7 +40935,7 @@ pub(crate) fn register_b_vec_2_functions(world: &mut World) { |_self: Ref<::glam::BVec2>, other: Ref<::glam::BVec2>| { let output: bool = { { - let output: bool = <::glam::BVec2 as ::core::cmp::PartialEq< + let output: bool = <::glam::BVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::BVec2, >>::eq(&_self, &other) .into(); @@ -37819,7 +41060,7 @@ pub(crate) fn register_b_vec_3_functions(world: &mut World) { |_self: Ref<::glam::BVec3>| { let output: () = { { - let output: () = <::glam::BVec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::BVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -37851,7 +41092,7 @@ pub(crate) fn register_b_vec_3_functions(world: &mut World) { |_self: Ref<::glam::BVec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = <::glam::BVec3 as ::core::clone::Clone>::clone( + let output: Val<::glam::BVec3> = <::glam::BVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -37868,7 +41109,7 @@ pub(crate) fn register_b_vec_3_functions(world: &mut World) { |_self: Ref<::glam::BVec3>, other: Ref<::glam::BVec3>| { let output: bool = { { - let output: bool = <::glam::BVec3 as ::core::cmp::PartialEq< + let output: bool = <::glam::BVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::BVec3, >>::eq(&_self, &other) .into(); @@ -37994,7 +41235,7 @@ pub(crate) fn register_b_vec_4_functions(world: &mut World) { |_self: Ref<::glam::BVec4>| { let output: () = { { - let output: () = <::glam::BVec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::BVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -38026,7 +41267,7 @@ pub(crate) fn register_b_vec_4_functions(world: &mut World) { |_self: Ref<::glam::BVec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = <::glam::BVec4 as ::core::clone::Clone>::clone( + let output: Val<::glam::BVec4> = <::glam::BVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -38043,7 +41284,7 @@ pub(crate) fn register_b_vec_4_functions(world: &mut World) { |_self: Ref<::glam::BVec4>, other: Ref<::glam::BVec4>| { let output: bool = { { - let output: bool = <::glam::BVec4 as ::core::cmp::PartialEq< + let output: bool = <::glam::BVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::BVec4, >>::eq(&_self, &other) .into(); @@ -38177,7 +41418,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Ref<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Add< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::DVec2, >>::add(_self.into_inner(), &rhs) .into(); @@ -38194,7 +41435,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Add< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::DVec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -38211,7 +41452,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Add< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< f64, >>::add(_self.into_inner(), rhs) .into(); @@ -38443,7 +41684,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { }; output }, - " Component-wise clamping of values, similar to [`f64::clamp`].\n Each element in `min` must be less-or-equal to the corresponding element in `max`.\n # Panics\n Will panic if `min` is greater than `max` when `glam_assert` is enabled.", + " Component-wise clamping of values, similar to [`f64::clamp`].\n Each element in `min` must be less-or-equal to the corresponding element in `max`.\n NaN propogation does not follow IEEE 754-2008 semantics and may differ on\n different SIMD architectures.\n # Panics\n Will panic if `min` is greater than `max` when `glam_assert` is enabled.", &["_self", "min", "max"], ) .register_documented( @@ -38506,7 +41747,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Ref<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::clone::Clone>::clone( + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -38685,7 +41926,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Ref<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Div< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::DVec2, >>::div(_self.into_inner(), &rhs) .into(); @@ -38702,7 +41943,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Div< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::DVec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -38719,7 +41960,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Div< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< f64, >>::div(_self.into_inner(), rhs) .into(); @@ -38822,7 +42063,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Ref<::glam::DVec2>, other: Ref<::glam::DVec2>| { let output: bool = { { - let output: bool = <::glam::DVec2 as ::core::cmp::PartialEq< + let output: bool = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::DVec2, >>::eq(&_self, &other) .into(); @@ -39028,7 +42269,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { }; output }, - " Returns a bitmask with the lowest 2 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.", + " Returns a bitmask with the lowest 2 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.\n An element is negative if it has a negative sign, including -0.0, NaNs with negative sign\n bit and negative infinity.", &["_self"], ) .register_documented( @@ -39129,7 +42370,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.\n NaN propogation does not follow IEEE 754-2008 semantics for maxNum and may differ on\n different SIMD architectures.", &["_self", "rhs"], ) .register_documented( @@ -39144,7 +42385,24 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { }; output }, - " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", + " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.\n NaN propogation does not follow IEEE 754-2008 semantics and may differ on\n different SIMD architectures.", + &["_self"], + ) + .register_documented( + "max_position", + |_self: Val<::glam::DVec2>| { + let output: usize = { + { + let output: usize = ::glam::DVec2::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", &["_self"], ) .register_documented( @@ -39180,7 +42438,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.\n NaN propogation does not follow IEEE 754-2008 semantics for minNum and may differ on\n different SIMD architectures.", &["_self", "rhs"], ) .register_documented( @@ -39195,7 +42453,24 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { }; output }, - " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", + " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.\n NaN propogation does not follow IEEE 754-2008 semantics and may differ on\n different SIMD architectures.", + &["_self"], + ) + .register_documented( + "min_position", + |_self: Val<::glam::DVec2>| { + let output: usize = { + { + let output: usize = ::glam::DVec2::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", &["_self"], ) .register_documented( @@ -39222,7 +42497,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Ref<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Mul< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::DVec2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -39239,7 +42514,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Mul< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::DVec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -39256,7 +42531,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Mul< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< f64, >>::mul(_self.into_inner(), rhs) .into(); @@ -39292,7 +42567,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Neg>::neg( + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -39332,7 +42607,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { }; output }, - " Returns `self` normalized to length 1.0.\n For valid results, `self` must be finite and _not_ of length zero, nor very close to zero.\n See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`].\n Panics\n Will panic if the resulting normalized vector is not finite when `glam_assert` is enabled.", + " Returns `self` normalized to length 1.0.\n For valid results, `self` must be finite and _not_ of length zero, nor very close to zero.\n See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`].\n # Panics\n Will panic if the resulting normalized vector is not finite when `glam_assert` is enabled.", &["_self"], ) .register_documented( @@ -39554,7 +42829,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Ref<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Rem< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::DVec2, >>::rem(_self.into_inner(), &rhs) .into(); @@ -39571,7 +42846,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Rem< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::DVec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -39588,7 +42863,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Rem< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< f64, >>::rem(_self.into_inner(), rhs) .into(); @@ -39633,7 +42908,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { }; output }, - " Returns `rhs` rotated by the angle of `self`. If `self` is normalized,\n then this just rotation. This is what you usually want. Otherwise,\n it will be like a rotation with a multiplication by `self`'s length.", + " Returns `rhs` rotated by the angle of `self`. If `self` is normalized,\n then this just rotation. This is what you usually want. Otherwise,\n it will be like a rotation with a multiplication by `self`'s length.\n This can be used in conjunction with the [`from_angle()`][Self::from_angle()] method, e.g.\n `DVec2::from_angle(PI).rotate(DVec2::Y)` will create the vector `[-1, 0]`\n and rotate [`DVec2::Y`] around it returning `-DVec2::Y`.", &["_self", "rhs"], ) .register_documented( @@ -39652,7 +42927,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { }; output }, - " Rotates towards `rhs` up to `max_angle` (in radians).\n When `max_angle` is `0.0`, the result will be equal to `self`. When `max_angle` is equal to\n `self.angle_between(rhs)`, the result will be equal to `rhs`. If `max_angle` is negative,\n rotates towards the exact opposite of `rhs`. Will not go past the target.", + " Rotates towards `rhs` up to `max_angle` (in radians).\n When `max_angle` is `0.0`, the result will be equal to `self`. When `max_angle` is equal to\n `self.angle_between(rhs)`, the result will be parallel to `rhs`. If `max_angle` is negative,\n rotates towards the exact opposite of `rhs`. Will not go past the target.", &["_self", "rhs", "max_angle"], ) .register_documented( @@ -39731,7 +43006,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Ref<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Sub< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::DVec2, >>::sub(_self.into_inner(), &rhs) .into(); @@ -39748,7 +43023,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Sub< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::DVec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -39765,7 +43040,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Sub< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< f64, >>::sub(_self.into_inner(), rhs) .into(); @@ -39803,7 +43078,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { }; output }, - " `[x, y]`", + " Converts `self` to `[x, y]`", &["_self"], ) .register_documented( @@ -39908,7 +43183,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Add< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::DVec3, >>::add(_self.into_inner(), &rhs) .into(); @@ -39925,7 +43200,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Add< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::DVec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -39942,7 +43217,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Add< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< f64, >>::add(_self.into_inner(), rhs) .into(); @@ -40205,7 +43480,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { }; output }, - " Component-wise clamping of values, similar to [`f64::clamp`].\n Each element in `min` must be less-or-equal to the corresponding element in `max`.\n # Panics\n Will panic if `min` is greater than `max` when `glam_assert` is enabled.", + " Component-wise clamping of values, similar to [`f64::clamp`].\n Each element in `min` must be less-or-equal to the corresponding element in `max`.\n NaN propogation does not follow IEEE 754-2008 semantics and may differ on\n different SIMD architectures.\n # Panics\n Will panic if `min` is greater than `max` when `glam_assert` is enabled.", &["_self", "min", "max"], ) .register_documented( @@ -40268,7 +43543,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::clone::Clone>::clone( + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -40465,7 +43740,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Div< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::DVec3, >>::div(_self.into_inner(), &rhs) .into(); @@ -40482,7 +43757,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Div< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::DVec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -40499,7 +43774,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Div< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< f64, >>::div(_self.into_inner(), rhs) .into(); @@ -40602,7 +43877,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Ref<::glam::DVec3>, other: Ref<::glam::DVec3>| { let output: bool = { { - let output: bool = <::glam::DVec3 as ::core::cmp::PartialEq< + let output: bool = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::DVec3, >>::eq(&_self, &other) .into(); @@ -40793,7 +44068,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { }; output }, - " Returns a bitmask with the lowest 3 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.", + " Returns a bitmask with the lowest 3 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.\n An element is negative if it has a negative sign, including -0.0, NaNs with negative sign\n bit and negative infinity.", &["_self"], ) .register_documented( @@ -40894,7 +44169,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.\n NaN propogation does not follow IEEE 754-2008 semantics for maxNum and may differ on\n different SIMD architectures.", &["_self", "rhs"], ) .register_documented( @@ -40909,7 +44184,24 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { }; output }, - " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", + " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.\n NaN propogation does not follow IEEE 754-2008 semantics and may differ on\n different SIMD architectures.", + &["_self"], + ) + .register_documented( + "max_position", + |_self: Val<::glam::DVec3>| { + let output: usize = { + { + let output: usize = ::glam::DVec3::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", &["_self"], ) .register_documented( @@ -40945,7 +44237,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.\n NaN propogation does not follow IEEE 754-2008 semantics for minNum and may differ on\n different SIMD architectures.", &["_self", "rhs"], ) .register_documented( @@ -40960,7 +44252,24 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { }; output }, - " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", + " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.\n NaN propogation does not follow IEEE 754-2008 semantics and may differ on\n different SIMD architectures.", + &["_self"], + ) + .register_documented( + "min_position", + |_self: Val<::glam::DVec3>| { + let output: usize = { + { + let output: usize = ::glam::DVec3::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", &["_self"], ) .register_documented( @@ -40987,7 +44296,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Mul< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::DVec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -41004,7 +44313,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Mul< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::DVec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -41021,7 +44330,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Mul< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< f64, >>::mul(_self.into_inner(), rhs) .into(); @@ -41057,7 +44366,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Neg>::neg( + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -41098,7 +44407,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { }; output }, - " Returns `self` normalized to length 1.0.\n For valid results, `self` must be finite and _not_ of length zero, nor very close to zero.\n See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`].\n Panics\n Will panic if the resulting normalized vector is not finite when `glam_assert` is enabled.", + " Returns `self` normalized to length 1.0.\n For valid results, `self` must be finite and _not_ of length zero, nor very close to zero.\n See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`].\n # Panics\n Will panic if the resulting normalized vector is not finite when `glam_assert` is enabled.", &["_self"], ) .register_documented( @@ -41285,7 +44594,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Rem< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::DVec3, >>::rem(_self.into_inner(), &rhs) .into(); @@ -41302,7 +44611,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Rem< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::DVec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -41319,7 +44628,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Rem< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< f64, >>::rem(_self.into_inner(), rhs) .into(); @@ -41349,6 +44658,98 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { " Returns the element-wise remainder of [Euclidean division] of `self` by `rhs`.\n [Euclidean division]: f64::rem_euclid", &["_self", "rhs"], ) + .register_documented( + "rotate_axis", + |_self: Val<::glam::DVec3>, axis: Val<::glam::DVec3>, angle: f64| { + let output: Val<::glam::DVec3> = { + { + let output: Val<::glam::DVec3> = ::glam::DVec3::rotate_axis( + _self.into_inner(), + axis.into_inner(), + angle, + ) + .into(); + output + } + }; + output + }, + " Rotates around `axis` by `angle` (in radians).\n The axis must be a unit vector.\n # Panics\n Will panic if `axis` is not normalized when `glam_assert` is enabled.", + &["_self", "axis", "angle"], + ) + .register_documented( + "rotate_towards", + |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>, max_angle: f64| { + let output: Val<::glam::DVec3> = { + { + let output: Val<::glam::DVec3> = ::glam::DVec3::rotate_towards( + _self.into_inner(), + rhs.into_inner(), + max_angle, + ) + .into(); + output + } + }; + output + }, + " Rotates towards `rhs` up to `max_angle` (in radians).\n When `max_angle` is `0.0`, the result will be equal to `self`. When `max_angle` is equal to\n `self.angle_between(rhs)`, the result will be parallel to `rhs`. If `max_angle` is negative,\n rotates towards the exact opposite of `rhs`. Will not go past the target.", + &["_self", "rhs", "max_angle"], + ) + .register_documented( + "rotate_x", + |_self: Val<::glam::DVec3>, angle: f64| { + let output: Val<::glam::DVec3> = { + { + let output: Val<::glam::DVec3> = ::glam::DVec3::rotate_x( + _self.into_inner(), + angle, + ) + .into(); + output + } + }; + output + }, + " Rotates around the x axis by `angle` (in radians).", + &["_self", "angle"], + ) + .register_documented( + "rotate_y", + |_self: Val<::glam::DVec3>, angle: f64| { + let output: Val<::glam::DVec3> = { + { + let output: Val<::glam::DVec3> = ::glam::DVec3::rotate_y( + _self.into_inner(), + angle, + ) + .into(); + output + } + }; + output + }, + " Rotates around the y axis by `angle` (in radians).", + &["_self", "angle"], + ) + .register_documented( + "rotate_z", + |_self: Val<::glam::DVec3>, angle: f64| { + let output: Val<::glam::DVec3> = { + { + let output: Val<::glam::DVec3> = ::glam::DVec3::rotate_z( + _self.into_inner(), + angle, + ) + .into(); + output + } + }; + output + }, + " Rotates around the z axis by `angle` (in radians).", + &["_self", "angle"], + ) .register_documented( "round", |_self: Val<::glam::DVec3>| { @@ -41406,6 +44807,25 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { " Returns a vector with elements representing the sign of `self`.\n - `1.0` if the number is positive, `+0.0` or `INFINITY`\n - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`\n - `NAN` if the number is `NAN`", &["_self"], ) + .register_documented( + "slerp", + |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>, s: f64| { + let output: Val<::glam::DVec3> = { + { + let output: Val<::glam::DVec3> = ::glam::DVec3::slerp( + _self.into_inner(), + rhs.into_inner(), + s, + ) + .into(); + output + } + }; + output + }, + " Performs a spherical linear interpolation between `self` and `rhs` based on the value `s`.\n When `s` is `0.0`, the result will be equal to `self`. When `s` is `1.0`, the result\n will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly\n extrapolated.", + &["_self", "rhs", "s"], + ) .register_documented( "splat", |v: f64| { @@ -41425,7 +44845,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Sub< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::DVec3, >>::sub(_self.into_inner(), &rhs) .into(); @@ -41442,7 +44862,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Sub< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::DVec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -41459,7 +44879,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Sub< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< f64, >>::sub(_self.into_inner(), rhs) .into(); @@ -41482,7 +44902,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { }; output }, - " `[x, y, z]`", + " Converts `self` to `[x, y, z]`", &["_self"], ) .register_documented( @@ -41622,7 +45042,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Ref<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Add< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< &::glam::DVec4, >>::add(_self.into_inner(), &rhs) .into(); @@ -41639,7 +45059,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Add< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::DVec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -41656,7 +45076,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Add< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< f64, >>::add(_self.into_inner(), rhs) .into(); @@ -41852,7 +45272,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { }; output }, - " Component-wise clamping of values, similar to [`f64::clamp`].\n Each element in `min` must be less-or-equal to the corresponding element in `max`.\n # Panics\n Will panic if `min` is greater than `max` when `glam_assert` is enabled.", + " Component-wise clamping of values, similar to [`f64::clamp`].\n Each element in `min` must be less-or-equal to the corresponding element in `max`.\n NaN propogation does not follow IEEE 754-2008 semantics and may differ on\n different SIMD architectures.\n # Panics\n Will panic if `min` is greater than `max` when `glam_assert` is enabled.", &["_self", "min", "max"], ) .register_documented( @@ -41915,7 +45335,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Ref<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::clone::Clone>::clone( + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -42094,7 +45514,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Ref<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Div< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< &::glam::DVec4, >>::div(_self.into_inner(), &rhs) .into(); @@ -42111,7 +45531,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Div< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< ::glam::DVec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -42128,7 +45548,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Div< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< f64, >>::div(_self.into_inner(), rhs) .into(); @@ -42231,7 +45651,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Ref<::glam::DVec4>, other: Ref<::glam::DVec4>| { let output: bool = { { - let output: bool = <::glam::DVec4 as ::core::cmp::PartialEq< + let output: bool = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::DVec4, >>::eq(&_self, &other) .into(); @@ -42404,7 +45824,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { }; output }, - " Returns a bitmask with the lowest 4 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.", + " Returns a bitmask with the lowest 4 bits set to the sign bits from the elements of `self`.\n A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes\n into the first lowest bit, element `y` into the second, etc.\n An element is negative if it has a negative sign, including -0.0, NaNs with negative sign\n bit and negative infinity.", &["_self"], ) .register_documented( @@ -42505,7 +45925,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { }; output }, - " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`.", + " Returns a vector containing the maximum values for each element of `self` and `rhs`.\n In other words this computes `[max(self.x, rhs.x), max(self.y, rhs.y), ..]`.\n NaN propogation does not follow IEEE 754-2008 semantics for maxNum and may differ on\n different SIMD architectures.", &["_self", "rhs"], ) .register_documented( @@ -42520,7 +45940,24 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { }; output }, - " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.", + " Returns the horizontal maximum of `self`.\n In other words this computes `max(x, y, ..)`.\n NaN propogation does not follow IEEE 754-2008 semantics and may differ on\n different SIMD architectures.", + &["_self"], + ) + .register_documented( + "max_position", + |_self: Val<::glam::DVec4>| { + let output: usize = { + { + let output: usize = ::glam::DVec4::max_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first maximum element of `self`.", &["_self"], ) .register_documented( @@ -42556,7 +45993,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { }; output }, - " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`.", + " Returns a vector containing the minimum values for each element of `self` and `rhs`.\n In other words this computes `[min(x, rhs.x), min(self.y, rhs.y), ..]`.\n NaN propogation does not follow IEEE 754-2008 semantics for minNum and may differ on\n different SIMD architectures.", &["_self", "rhs"], ) .register_documented( @@ -42571,7 +46008,24 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { }; output }, - " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.", + " Returns the horizontal minimum of `self`.\n In other words this computes `min(x, y, ..)`.\n NaN propogation does not follow IEEE 754-2008 semantics and may differ on\n different SIMD architectures.", + &["_self"], + ) + .register_documented( + "min_position", + |_self: Val<::glam::DVec4>| { + let output: usize = { + { + let output: usize = ::glam::DVec4::min_position( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the index of the first minimum element of `self`.", &["_self"], ) .register_documented( @@ -42598,7 +46052,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Ref<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Mul< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< &::glam::DVec4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -42615,7 +46069,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Mul< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::DVec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -42632,7 +46086,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Mul< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< f64, >>::mul(_self.into_inner(), rhs) .into(); @@ -42668,7 +46122,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Neg>::neg( + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -42709,7 +46163,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { }; output }, - " Returns `self` normalized to length 1.0.\n For valid results, `self` must be finite and _not_ of length zero, nor very close to zero.\n See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`].\n Panics\n Will panic if the resulting normalized vector is not finite when `glam_assert` is enabled.", + " Returns `self` normalized to length 1.0.\n For valid results, `self` must be finite and _not_ of length zero, nor very close to zero.\n See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`].\n # Panics\n Will panic if the resulting normalized vector is not finite when `glam_assert` is enabled.", &["_self"], ) .register_documented( @@ -42896,7 +46350,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Ref<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Rem< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< &::glam::DVec4, >>::rem(_self.into_inner(), &rhs) .into(); @@ -42913,7 +46367,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Rem< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< ::glam::DVec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -42930,7 +46384,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Rem< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< f64, >>::rem(_self.into_inner(), rhs) .into(); @@ -43036,7 +46490,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Ref<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Sub< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< &::glam::DVec4, >>::sub(_self.into_inner(), &rhs) .into(); @@ -43053,7 +46507,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Sub< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::DVec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -43070,7 +46524,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Sub< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< f64, >>::sub(_self.into_inner(), rhs) .into(); @@ -43093,7 +46547,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { }; output }, - " `[x, y, z, w]`", + " Converts `self` to `[x, y, z, w]`", &["_self"], ) .register_documented( @@ -43243,12 +46697,29 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { " Returns true if the absolute difference of all elements between `self` and `rhs`\n is less than or equal to `max_abs_diff`.\n This can be used to compare if two matrices contain similar elements. It works best\n when comparing with a known value. The `max_abs_diff` that should be used used\n depends on the values being compared against.\n For more see\n [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/).", &["_self", "rhs", "max_abs_diff"], ) + .register_documented( + "add", + |_self: Val<::glam::Mat2>, rhs: Ref<::glam::Mat2>| { + let output: Val<::glam::Mat2> = { + { + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + &::glam::Mat2, + >>::add(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "add", |_self: Val<::glam::Mat2>, rhs: Val<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Add< + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::Mat2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -43298,7 +46769,7 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Ref<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::clone::Clone>::clone( + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -43344,7 +46815,7 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>, rhs: f32| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Div< + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -43379,7 +46850,7 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Ref<::glam::Mat2>, rhs: Ref<::glam::Mat2>| { let output: bool = { { - let output: bool = <::glam::Mat2 as ::core::cmp::PartialEq< + let output: bool = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::Mat2, >>::eq(&_self, &rhs) .into(); @@ -43574,12 +47045,46 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { " Returns `true` if any elements are `NaN`.", &["_self"], ) + .register_documented( + "mul", + |_self: Val<::glam::Mat2>, rhs: Ref<::glam::Mat2>| { + let output: Val<::glam::Mat2> = { + { + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::Mat2, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::glam::Mat2>, rhs: Ref<::glam::Vec2>| { + let output: Val<::glam::Vec2> = { + { + let output: Val<::glam::Vec2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::Vec2, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "mul", |_self: Val<::glam::Mat2>, rhs: Val<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Mul< + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Mat2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -43596,7 +47101,7 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Mat2 as ::core::ops::Mul< + let output: Val<::glam::Vec2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -43613,7 +47118,7 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>, rhs: f32| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Mul< + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -43684,7 +47189,7 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Neg>::neg( + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -43711,12 +47216,29 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { " Returns the matrix row for the given `index`.\n # Panics\n Panics if `index` is greater than 1.", &["_self", "index"], ) + .register_documented( + "sub", + |_self: Val<::glam::Mat2>, rhs: Ref<::glam::Mat2>| { + let output: Val<::glam::Mat2> = { + { + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + &::glam::Mat2, + >>::sub(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "sub", |_self: Val<::glam::Mat2>, rhs: Val<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Sub< + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::Mat2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -43834,12 +47356,29 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { " Returns true if the absolute difference of all elements between `self` and `rhs`\n is less than or equal to `max_abs_diff`.\n This can be used to compare if two matrices contain similar elements. It works best\n when comparing with a known value. The `max_abs_diff` that should be used used\n depends on the values being compared against.\n For more see\n [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/).", &["_self", "rhs", "max_abs_diff"], ) + .register_documented( + "add", + |_self: Val<::glam::Mat3>, rhs: Ref<::glam::Mat3>| { + let output: Val<::glam::Mat3> = { + { + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + &::glam::Mat3, + >>::add(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "add", |_self: Val<::glam::Mat3>, rhs: Val<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Add< + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::Mat3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -43889,7 +47428,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::clone::Clone>::clone( + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -43935,7 +47474,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: f32| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Div< + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -43970,7 +47509,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>, rhs: Ref<::glam::Mat3>| { let output: bool = { { - let output: bool = <::glam::Mat3 as ::core::cmp::PartialEq< + let output: bool = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::Mat3, >>::eq(&_self, &rhs) .into(); @@ -44292,12 +47831,154 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { " Returns `true` if any elements are `NaN`.", &["_self"], ) + .register_documented( + "look_at_lh", + |eye: Val<::glam::Vec3>, center: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { + let output: Val<::glam::Mat3> = { + { + let output: Val<::glam::Mat3> = ::glam::Mat3::look_at_lh( + eye.into_inner(), + center.into_inner(), + up.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a left-handed view matrix using a camera position, a focal point and an up\n direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`.\n # Panics\n Will panic if `up` is not normalized when `glam_assert` is enabled.", + &["eye", "center", "up"], + ) + .register_documented( + "look_at_rh", + |eye: Val<::glam::Vec3>, center: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { + let output: Val<::glam::Mat3> = { + { + let output: Val<::glam::Mat3> = ::glam::Mat3::look_at_rh( + eye.into_inner(), + center.into_inner(), + up.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a right-handed view matrix using a camera position, a focal point and an up\n direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=back`.\n # Panics\n Will panic if `up` is not normalized when `glam_assert` is enabled.", + &["eye", "center", "up"], + ) + .register_documented( + "look_to_lh", + |dir: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { + let output: Val<::glam::Mat3> = { + { + let output: Val<::glam::Mat3> = ::glam::Mat3::look_to_lh( + dir.into_inner(), + up.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a left-handed view matrix using a facing direction and an up direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`.\n # Panics\n Will panic if `dir` or `up` are not normalized when `glam_assert` is enabled.", + &["dir", "up"], + ) + .register_documented( + "look_to_rh", + |dir: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { + let output: Val<::glam::Mat3> = { + { + let output: Val<::glam::Mat3> = ::glam::Mat3::look_to_rh( + dir.into_inner(), + up.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a right-handed view matrix using a facing direction and an up direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=back`.\n # Panics\n Will panic if `dir` or `up` are not normalized when `glam_assert` is enabled.", + &["dir", "up"], + ) + .register_documented( + "mul", + |_self: Val<::glam::Mat3>, rhs: Ref<::glam::Affine2>| { + let output: Val<::glam::Mat3> = { + { + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::Affine2, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::glam::Mat3>, rhs: Ref<::glam::Mat3>| { + let output: Val<::glam::Mat3> = { + { + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::Mat3, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::glam::Mat3>, rhs: Ref<::glam::Vec3>| { + let output: Val<::glam::Vec3> = { + { + let output: Val<::glam::Vec3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::Vec3, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::glam::Mat3>, rhs: Ref<::glam::Vec3A>| { + let output: Val<::glam::Vec3A> = { + { + let output: Val<::glam::Vec3A> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::Vec3A, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "mul", |_self: Val<::glam::Mat3>, rhs: Val<::glam::Affine2>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Mul< + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Affine2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -44314,7 +47995,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Val<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Mul< + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Mat3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -44331,7 +48012,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Mat3 as ::core::ops::Mul< + let output: Val<::glam::Vec3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -44348,7 +48029,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Mat3 as ::core::ops::Mul< + let output: Val<::glam::Vec3A> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Vec3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -44365,7 +48046,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: f32| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Mul< + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -44454,7 +48135,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Neg>::neg( + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -44481,12 +48162,29 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { " Returns the matrix row for the given `index`.\n # Panics\n Panics if `index` is greater than 2.", &["_self", "index"], ) + .register_documented( + "sub", + |_self: Val<::glam::Mat3>, rhs: Ref<::glam::Mat3>| { + let output: Val<::glam::Mat3> = { + { + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + &::glam::Mat3, + >>::sub(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "sub", |_self: Val<::glam::Mat3>, rhs: Val<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Sub< + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::Mat3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -44659,12 +48357,29 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { " Returns true if the absolute difference of all elements between `self` and `rhs`\n is less than or equal to `max_abs_diff`.\n This can be used to compare if two matrices contain similar elements. It works best\n when comparing with a known value. The `max_abs_diff` that should be used used\n depends on the values being compared against.\n For more see\n [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/).", &["_self", "rhs", "max_abs_diff"], ) + .register_documented( + "add", + |_self: Val<::glam::Mat3A>, rhs: Ref<::glam::Mat3A>| { + let output: Val<::glam::Mat3A> = { + { + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + &::glam::Mat3A, + >>::add(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "add", |_self: Val<::glam::Mat3A>, rhs: Val<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Add< + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::Mat3A, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -44714,7 +48429,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::clone::Clone>::clone( + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -44763,7 +48478,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: f32| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Div< + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -44798,7 +48513,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>, rhs: Ref<::glam::Mat3A>| { let output: bool = { { - let output: bool = <::glam::Mat3A as ::core::cmp::PartialEq< + let output: bool = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::Mat3A, >>::eq(&_self, &rhs) .into(); @@ -45120,12 +48835,154 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { " Returns `true` if any elements are `NaN`.", &["_self"], ) + .register_documented( + "look_at_lh", + |eye: Val<::glam::Vec3>, center: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { + let output: Val<::glam::Mat3A> = { + { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::look_at_lh( + eye.into_inner(), + center.into_inner(), + up.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a left-handed view matrix using a camera position, a focal point and an up\n direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`.\n # Panics\n Will panic if `up` is not normalized when `glam_assert` is enabled.", + &["eye", "center", "up"], + ) + .register_documented( + "look_at_rh", + |eye: Val<::glam::Vec3>, center: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { + let output: Val<::glam::Mat3A> = { + { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::look_at_rh( + eye.into_inner(), + center.into_inner(), + up.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a right-handed view matrix using a camera position, a focal point and an up\n direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=back`.\n # Panics\n Will panic if `up` is not normalized when `glam_assert` is enabled.", + &["eye", "center", "up"], + ) + .register_documented( + "look_to_lh", + |dir: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { + let output: Val<::glam::Mat3A> = { + { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::look_to_lh( + dir.into_inner(), + up.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a left-handed view matrix using a facing direction and an up direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`.\n # Panics\n Will panic if `dir` or `up` are not normalized when `glam_assert` is enabled.", + &["dir", "up"], + ) + .register_documented( + "look_to_rh", + |dir: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { + let output: Val<::glam::Mat3A> = { + { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::look_to_rh( + dir.into_inner(), + up.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a right-handed view matrix using a facing direction and an up direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=back`.\n # Panics\n Will panic if `dir` or `up` are not normalized when `glam_assert` is enabled.", + &["dir", "up"], + ) + .register_documented( + "mul", + |_self: Val<::glam::Mat3A>, rhs: Ref<::glam::Affine2>| { + let output: Val<::glam::Mat3A> = { + { + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::Affine2, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::glam::Mat3A>, rhs: Ref<::glam::Mat3A>| { + let output: Val<::glam::Mat3A> = { + { + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::Mat3A, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::glam::Mat3A>, rhs: Ref<::glam::Vec3>| { + let output: Val<::glam::Vec3> = { + { + let output: Val<::glam::Vec3> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::Vec3, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::glam::Mat3A>, rhs: Ref<::glam::Vec3A>| { + let output: Val<::glam::Vec3A> = { + { + let output: Val<::glam::Vec3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::Vec3A, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "mul", |_self: Val<::glam::Mat3A>, rhs: Val<::glam::Affine2>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Mul< + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Affine2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -45142,7 +48999,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Val<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Mul< + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Mat3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -45159,7 +49016,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Mat3A as ::core::ops::Mul< + let output: Val<::glam::Vec3> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -45176,7 +49033,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Mat3A as ::core::ops::Mul< + let output: Val<::glam::Vec3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Vec3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -45193,7 +49050,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: f32| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Mul< + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -45282,7 +49139,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Neg>::neg( + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -45312,12 +49169,29 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { " Returns the matrix row for the given `index`.\n # Panics\n Panics if `index` is greater than 2.", &["_self", "index"], ) + .register_documented( + "sub", + |_self: Val<::glam::Mat3A>, rhs: Ref<::glam::Mat3A>| { + let output: Val<::glam::Mat3A> = { + { + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + &::glam::Mat3A, + >>::sub(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "sub", |_self: Val<::glam::Mat3A>, rhs: Val<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Sub< + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::Mat3A, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -45489,12 +49363,29 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { " Returns true if the absolute difference of all elements between `self` and `rhs`\n is less than or equal to `max_abs_diff`.\n This can be used to compare if two matrices contain similar elements. It works best\n when comparing with a known value. The `max_abs_diff` that should be used used\n depends on the values being compared against.\n For more see\n [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/).", &["_self", "rhs", "max_abs_diff"], ) + .register_documented( + "add", + |_self: Val<::glam::Mat4>, rhs: Ref<::glam::Mat4>| { + let output: Val<::glam::Mat4> = { + { + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + &::glam::Mat4, + >>::add(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "add", |_self: Val<::glam::Mat4>, rhs: Val<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Add< + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::Mat4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -45544,7 +49435,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::clone::Clone>::clone( + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -45590,7 +49481,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Div< + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -45625,7 +49516,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>, rhs: Ref<::glam::Mat4>| { let output: bool = { { - let output: bool = <::glam::Mat4 as ::core::cmp::PartialEq< + let output: bool = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::Mat4, >>::eq(&_self, &rhs) .into(); @@ -45734,6 +49625,24 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { " Creates an affine transformation matrix from the given 3x3 linear transformation\n matrix.\n The resulting matrix can be used to transform 3D points and vectors. See\n [`Self::transform_point3()`] and [`Self::transform_vector3()`].", &["m"], ) + .register_documented( + "from_mat3_translation", + |mat3: Val<::glam::Mat3>, translation: Val<::glam::Vec3>| { + let output: Val<::glam::Mat4> = { + { + let output: Val<::glam::Mat4> = ::glam::Mat4::from_mat3_translation( + mat3.into_inner(), + translation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates an affine transformation matrics from a 3x3 matrix (expressing scale, shear and\n rotation) and a translation vector.\n Equivalent to `Mat4::from_translation(translation) * Mat4::from_mat3(mat3)`", + &["mat3", "translation"], + ) .register_documented( "from_mat3a", |m: Val<::glam::Mat3A>| { @@ -45894,6 +49803,72 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { " Creates an affine transformation matrix from the given 3D `translation`.\n The resulting matrix can be used to transform 3D points and vectors. See\n [`Self::transform_point3()`] and [`Self::transform_vector3()`].", &["translation"], ) + .register_documented( + "frustum_lh", + |left: f32, right: f32, bottom: f32, top: f32, z_near: f32, z_far: f32| { + let output: Val<::glam::Mat4> = { + { + let output: Val<::glam::Mat4> = ::glam::Mat4::frustum_lh( + left, + right, + bottom, + top, + z_near, + z_far, + ) + .into(); + output + } + }; + output + }, + " Creates a left-handed perspective projection matrix with `[0,1]` depth range.\n # Panics\n Will panic if `z_near` or `z_far` are less than or equal to zero when `glam_assert` is\n enabled.", + &["left", "right", "bottom", "top", "z_near", "z_far"], + ) + .register_documented( + "frustum_rh", + |left: f32, right: f32, bottom: f32, top: f32, z_near: f32, z_far: f32| { + let output: Val<::glam::Mat4> = { + { + let output: Val<::glam::Mat4> = ::glam::Mat4::frustum_rh( + left, + right, + bottom, + top, + z_near, + z_far, + ) + .into(); + output + } + }; + output + }, + " Creates a right-handed perspective projection matrix with `[0,1]` depth range.\n # Panics\n Will panic if `z_near` or `z_far` are less than or equal to zero when `glam_assert` is\n enabled.", + &["left", "right", "bottom", "top", "z_near", "z_far"], + ) + .register_documented( + "frustum_rh_gl", + |left: f32, right: f32, bottom: f32, top: f32, z_near: f32, z_far: f32| { + let output: Val<::glam::Mat4> = { + { + let output: Val<::glam::Mat4> = ::glam::Mat4::frustum_rh_gl( + left, + right, + bottom, + top, + z_near, + z_far, + ) + .into(); + output + } + }; + output + }, + " Creates a right-handed perspective projection matrix with [-1,1] depth range.\n This is the same as the OpenGL `glFrustum` function.\n See ", + &["left", "right", "bottom", "top", "z_near", "z_far"], + ) .register_documented( "inverse", |_self: Ref<::glam::Mat4>| { @@ -45953,7 +49928,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { }; output }, - " Creates a left-handed view matrix using a camera position, an up direction, and a focal\n point.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`.\n # Panics\n Will panic if `up` is not normalized when `glam_assert` is enabled.", + " Creates a left-handed view matrix using a camera position, a focal points and an up\n direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`.\n # Panics\n Will panic if `up` is not normalized when `glam_assert` is enabled.", &["eye", "center", "up"], ) .register_documented( @@ -45972,7 +49947,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { }; output }, - " Creates a right-handed view matrix using a camera position, an up direction, and a focal\n point.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=back`.\n # Panics\n Will panic if `up` is not normalized when `glam_assert` is enabled.", + " Creates a right-handed view matrix using a camera position, a focal point, and an up\n direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=back`.\n # Panics\n Will panic if `up` is not normalized when `glam_assert` is enabled.", &["eye", "center", "up"], ) .register_documented( @@ -45991,7 +49966,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { }; output }, - " Creates a left-handed view matrix using a camera position, an up direction, and a facing\n direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`.", + " Creates a left-handed view matrix using a camera position, a facing direction and an up\n direction\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`.\n # Panics\n Will panic if `dir` or `up` are not normalized when `glam_assert` is enabled.", &["eye", "dir", "up"], ) .register_documented( @@ -46010,15 +49985,66 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { }; output }, - " Creates a right-handed view matrix using a camera position, an up direction, and a facing\n direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=back`.", + " Creates a right-handed view matrix using a camera position, a facing direction, and an up\n direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=back`.\n # Panics\n Will panic if `dir` or `up` are not normalized when `glam_assert` is enabled.", &["eye", "dir", "up"], ) + .register_documented( + "mul", + |_self: Val<::glam::Mat4>, rhs: Ref<::glam::Affine3A>| { + let output: Val<::glam::Mat4> = { + { + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::Affine3A, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::glam::Mat4>, rhs: Ref<::glam::Mat4>| { + let output: Val<::glam::Mat4> = { + { + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::Mat4, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::glam::Mat4>, rhs: Ref<::glam::Vec4>| { + let output: Val<::glam::Vec4> = { + { + let output: Val<::glam::Vec4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::Vec4, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "mul", |_self: Val<::glam::Mat4>, rhs: Val<::glam::Affine3A>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Mul< + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Affine3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -46035,7 +50061,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: Val<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Mul< + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Mat4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -46052,7 +50078,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Mat4 as ::core::ops::Mul< + let output: Val<::glam::Vec4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -46069,7 +50095,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Mul< + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -46140,7 +50166,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Neg>::neg( + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -46405,12 +50431,29 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { " Returns the matrix row for the given `index`.\n # Panics\n Panics if `index` is greater than 3.", &["_self", "index"], ) + .register_documented( + "sub", + |_self: Val<::glam::Mat4>, rhs: Ref<::glam::Mat4>| { + let output: Val<::glam::Mat4> = { + { + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + &::glam::Mat4, + >>::sub(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "sub", |_self: Val<::glam::Mat4>, rhs: Val<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Sub< + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::Mat4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -46619,12 +50662,29 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { " Returns true if the absolute difference of all elements between `self` and `rhs`\n is less than or equal to `max_abs_diff`.\n This can be used to compare if two matrices contain similar elements. It works best\n when comparing with a known value. The `max_abs_diff` that should be used used\n depends on the values being compared against.\n For more see\n [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/).", &["_self", "rhs", "max_abs_diff"], ) + .register_documented( + "add", + |_self: Val<::glam::DMat2>, rhs: Ref<::glam::DMat2>| { + let output: Val<::glam::DMat2> = { + { + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + &::glam::DMat2, + >>::add(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "add", |_self: Val<::glam::DMat2>, rhs: Val<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Add< + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::DMat2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -46674,7 +50734,7 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Ref<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::clone::Clone>::clone( + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -46723,7 +50783,7 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>, rhs: f64| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Div< + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< f64, >>::div(_self.into_inner(), rhs) .into(); @@ -46758,7 +50818,7 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Ref<::glam::DMat2>, rhs: Ref<::glam::DMat2>| { let output: bool = { { - let output: bool = <::glam::DMat2 as ::core::cmp::PartialEq< + let output: bool = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::DMat2, >>::eq(&_self, &rhs) .into(); @@ -46917,12 +50977,46 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { " Returns `true` if any elements are `NaN`.", &["_self"], ) + .register_documented( + "mul", + |_self: Val<::glam::DMat2>, rhs: Ref<::glam::DMat2>| { + let output: Val<::glam::DMat2> = { + { + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::DMat2, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::glam::DMat2>, rhs: Ref<::glam::DVec2>| { + let output: Val<::glam::DVec2> = { + { + let output: Val<::glam::DVec2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::DVec2, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "mul", |_self: Val<::glam::DMat2>, rhs: Val<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Mul< + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::DMat2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -46939,7 +51033,7 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DMat2 as ::core::ops::Mul< + let output: Val<::glam::DVec2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::DVec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -46956,7 +51050,7 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>, rhs: f64| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Mul< + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< f64, >>::mul(_self.into_inner(), rhs) .into(); @@ -47027,7 +51121,7 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Neg>::neg( + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -47057,12 +51151,29 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { " Returns the matrix row for the given `index`.\n # Panics\n Panics if `index` is greater than 1.", &["_self", "index"], ) + .register_documented( + "sub", + |_self: Val<::glam::DMat2>, rhs: Ref<::glam::DMat2>| { + let output: Val<::glam::DMat2> = { + { + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + &::glam::DMat2, + >>::sub(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "sub", |_self: Val<::glam::DMat2>, rhs: Val<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Sub< + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::DMat2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -47181,12 +51292,29 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { " Returns true if the absolute difference of all elements between `self` and `rhs`\n is less than or equal to `max_abs_diff`.\n This can be used to compare if two matrices contain similar elements. It works best\n when comparing with a known value. The `max_abs_diff` that should be used used\n depends on the values being compared against.\n For more see\n [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/).", &["_self", "rhs", "max_abs_diff"], ) + .register_documented( + "add", + |_self: Val<::glam::DMat3>, rhs: Ref<::glam::DMat3>| { + let output: Val<::glam::DMat3> = { + { + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + &::glam::DMat3, + >>::add(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "add", |_self: Val<::glam::DMat3>, rhs: Val<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Add< + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::DMat3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -47236,7 +51364,7 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Ref<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::clone::Clone>::clone( + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -47285,7 +51413,7 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: f64| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Div< + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< f64, >>::div(_self.into_inner(), rhs) .into(); @@ -47320,7 +51448,7 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Ref<::glam::DMat3>, rhs: Ref<::glam::DMat3>| { let output: bool = { { - let output: bool = <::glam::DMat3 as ::core::cmp::PartialEq< + let output: bool = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::DMat3, >>::eq(&_self, &rhs) .into(); @@ -47642,12 +51770,145 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { " Returns `true` if any elements are `NaN`.", &["_self"], ) + .register_documented( + "look_at_lh", + | + eye: Val<::glam::DVec3>, + center: Val<::glam::DVec3>, + up: Val<::glam::DVec3>| + { + let output: Val<::glam::DMat3> = { + { + let output: Val<::glam::DMat3> = ::glam::DMat3::look_at_lh( + eye.into_inner(), + center.into_inner(), + up.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a left-handed view matrix using a camera position, a focal point and an up\n direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`.\n # Panics\n Will panic if `up` is not normalized when `glam_assert` is enabled.", + &["eye", "center", "up"], + ) + .register_documented( + "look_at_rh", + | + eye: Val<::glam::DVec3>, + center: Val<::glam::DVec3>, + up: Val<::glam::DVec3>| + { + let output: Val<::glam::DMat3> = { + { + let output: Val<::glam::DMat3> = ::glam::DMat3::look_at_rh( + eye.into_inner(), + center.into_inner(), + up.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a right-handed view matrix using a camera position, a focal point and an up\n direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=back`.\n # Panics\n Will panic if `up` is not normalized when `glam_assert` is enabled.", + &["eye", "center", "up"], + ) + .register_documented( + "look_to_lh", + |dir: Val<::glam::DVec3>, up: Val<::glam::DVec3>| { + let output: Val<::glam::DMat3> = { + { + let output: Val<::glam::DMat3> = ::glam::DMat3::look_to_lh( + dir.into_inner(), + up.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a left-handed view matrix using a facing direction and an up direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`.\n # Panics\n Will panic if `dir` or `up` are not normalized when `glam_assert` is enabled.", + &["dir", "up"], + ) + .register_documented( + "look_to_rh", + |dir: Val<::glam::DVec3>, up: Val<::glam::DVec3>| { + let output: Val<::glam::DMat3> = { + { + let output: Val<::glam::DMat3> = ::glam::DMat3::look_to_rh( + dir.into_inner(), + up.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a right-handed view matrix using a facing direction and an up direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=back`.\n # Panics\n Will panic if `dir` or `up` are not normalized when `glam_assert` is enabled.", + &["dir", "up"], + ) + .register_documented( + "mul", + |_self: Val<::glam::DMat3>, rhs: Ref<::glam::DAffine2>| { + let output: Val<::glam::DMat3> = { + { + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::DAffine2, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::glam::DMat3>, rhs: Ref<::glam::DMat3>| { + let output: Val<::glam::DMat3> = { + { + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::DMat3, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::glam::DMat3>, rhs: Ref<::glam::DVec3>| { + let output: Val<::glam::DVec3> = { + { + let output: Val<::glam::DVec3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::DVec3, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "mul", |_self: Val<::glam::DMat3>, rhs: Val<::glam::DAffine2>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Mul< + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::DAffine2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -47664,7 +51925,7 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: Val<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Mul< + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::DMat3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -47681,7 +51942,7 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DMat3 as ::core::ops::Mul< + let output: Val<::glam::DVec3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::DVec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -47698,7 +51959,7 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: f64| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Mul< + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< f64, >>::mul(_self.into_inner(), rhs) .into(); @@ -47769,7 +52030,7 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Neg>::neg( + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -47799,12 +52060,29 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { " Returns the matrix row for the given `index`.\n # Panics\n Panics if `index` is greater than 2.", &["_self", "index"], ) + .register_documented( + "sub", + |_self: Val<::glam::DMat3>, rhs: Ref<::glam::DMat3>| { + let output: Val<::glam::DMat3> = { + { + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + &::glam::DMat3, + >>::sub(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "sub", |_self: Val<::glam::DMat3>, rhs: Val<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Sub< + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::DMat3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -47977,12 +52255,29 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { " Returns true if the absolute difference of all elements between `self` and `rhs`\n is less than or equal to `max_abs_diff`.\n This can be used to compare if two matrices contain similar elements. It works best\n when comparing with a known value. The `max_abs_diff` that should be used used\n depends on the values being compared against.\n For more see\n [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/).", &["_self", "rhs", "max_abs_diff"], ) + .register_documented( + "add", + |_self: Val<::glam::DMat4>, rhs: Ref<::glam::DMat4>| { + let output: Val<::glam::DMat4> = { + { + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + &::glam::DMat4, + >>::add(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "add", |_self: Val<::glam::DMat4>, rhs: Val<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Add< + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::DMat4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -48032,7 +52327,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::clone::Clone>::clone( + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -48081,7 +52376,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Div< + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< f64, >>::div(_self.into_inner(), rhs) .into(); @@ -48116,7 +52411,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>, rhs: Ref<::glam::DMat4>| { let output: bool = { { - let output: bool = <::glam::DMat4 as ::core::cmp::PartialEq< + let output: bool = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::DMat4, >>::eq(&_self, &rhs) .into(); @@ -48225,6 +52520,24 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { " Creates an affine transformation matrix from the given 3x3 linear transformation\n matrix.\n The resulting matrix can be used to transform 3D points and vectors. See\n [`Self::transform_point3()`] and [`Self::transform_vector3()`].", &["m"], ) + .register_documented( + "from_mat3_translation", + |mat3: Val<::glam::DMat3>, translation: Val<::glam::DVec3>| { + let output: Val<::glam::DMat4> = { + { + let output: Val<::glam::DMat4> = ::glam::DMat4::from_mat3_translation( + mat3.into_inner(), + translation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates an affine transformation matrics from a 3x3 matrix (expressing scale, shear and\n rotation) and a translation vector.\n Equivalent to `DMat4::from_translation(translation) * DMat4::from_mat3(mat3)`", + &["mat3", "translation"], + ) .register_documented( "from_quat", |rotation: Val<::glam::DQuat>| { @@ -48368,6 +52681,72 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { " Creates an affine transformation matrix from the given 3D `translation`.\n The resulting matrix can be used to transform 3D points and vectors. See\n [`Self::transform_point3()`] and [`Self::transform_vector3()`].", &["translation"], ) + .register_documented( + "frustum_lh", + |left: f64, right: f64, bottom: f64, top: f64, z_near: f64, z_far: f64| { + let output: Val<::glam::DMat4> = { + { + let output: Val<::glam::DMat4> = ::glam::DMat4::frustum_lh( + left, + right, + bottom, + top, + z_near, + z_far, + ) + .into(); + output + } + }; + output + }, + " Creates a left-handed perspective projection matrix with `[0,1]` depth range.\n # Panics\n Will panic if `z_near` or `z_far` are less than or equal to zero when `glam_assert` is\n enabled.", + &["left", "right", "bottom", "top", "z_near", "z_far"], + ) + .register_documented( + "frustum_rh", + |left: f64, right: f64, bottom: f64, top: f64, z_near: f64, z_far: f64| { + let output: Val<::glam::DMat4> = { + { + let output: Val<::glam::DMat4> = ::glam::DMat4::frustum_rh( + left, + right, + bottom, + top, + z_near, + z_far, + ) + .into(); + output + } + }; + output + }, + " Creates a right-handed perspective projection matrix with `[0,1]` depth range.\n # Panics\n Will panic if `z_near` or `z_far` are less than or equal to zero when `glam_assert` is\n enabled.", + &["left", "right", "bottom", "top", "z_near", "z_far"], + ) + .register_documented( + "frustum_rh_gl", + |left: f64, right: f64, bottom: f64, top: f64, z_near: f64, z_far: f64| { + let output: Val<::glam::DMat4> = { + { + let output: Val<::glam::DMat4> = ::glam::DMat4::frustum_rh_gl( + left, + right, + bottom, + top, + z_near, + z_far, + ) + .into(); + output + } + }; + output + }, + " Creates a right-handed perspective projection matrix with [-1,1] depth range.\n This is the same as the OpenGL `glFrustum` function.\n See ", + &["left", "right", "bottom", "top", "z_near", "z_far"], + ) .register_documented( "inverse", |_self: Ref<::glam::DMat4>| { @@ -48431,7 +52810,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { }; output }, - " Creates a left-handed view matrix using a camera position, an up direction, and a focal\n point.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`.\n # Panics\n Will panic if `up` is not normalized when `glam_assert` is enabled.", + " Creates a left-handed view matrix using a camera position, a focal points and an up\n direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`.\n # Panics\n Will panic if `up` is not normalized when `glam_assert` is enabled.", &["eye", "center", "up"], ) .register_documented( @@ -48454,7 +52833,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { }; output }, - " Creates a right-handed view matrix using a camera position, an up direction, and a focal\n point.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=back`.\n # Panics\n Will panic if `up` is not normalized when `glam_assert` is enabled.", + " Creates a right-handed view matrix using a camera position, a focal point, and an up\n direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=back`.\n # Panics\n Will panic if `up` is not normalized when `glam_assert` is enabled.", &["eye", "center", "up"], ) .register_documented( @@ -48473,7 +52852,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { }; output }, - " Creates a left-handed view matrix using a camera position, an up direction, and a facing\n direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`.", + " Creates a left-handed view matrix using a camera position, a facing direction and an up\n direction\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`.\n # Panics\n Will panic if `dir` or `up` are not normalized when `glam_assert` is enabled.", &["eye", "dir", "up"], ) .register_documented( @@ -48492,15 +52871,66 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { }; output }, - " Creates a right-handed view matrix using a camera position, an up direction, and a facing\n direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=back`.", + " Creates a right-handed view matrix using a camera position, a facing direction, and an up\n direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=back`.\n # Panics\n Will panic if `dir` or `up` are not normalized when `glam_assert` is enabled.", &["eye", "dir", "up"], ) + .register_documented( + "mul", + |_self: Val<::glam::DMat4>, rhs: Ref<::glam::DAffine3>| { + let output: Val<::glam::DMat4> = { + { + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::DAffine3, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::glam::DMat4>, rhs: Ref<::glam::DMat4>| { + let output: Val<::glam::DMat4> = { + { + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::DMat4, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::glam::DMat4>, rhs: Ref<::glam::DVec4>| { + let output: Val<::glam::DVec4> = { + { + let output: Val<::glam::DVec4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::DVec4, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "mul", |_self: Val<::glam::DMat4>, rhs: Val<::glam::DAffine3>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Mul< + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::DAffine3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -48517,7 +52947,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: Val<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Mul< + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::DMat4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -48534,7 +52964,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DMat4 as ::core::ops::Mul< + let output: Val<::glam::DVec4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::DVec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -48551,7 +52981,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Mul< + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< f64, >>::mul(_self.into_inner(), rhs) .into(); @@ -48622,7 +53052,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Neg>::neg( + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -48872,12 +53302,29 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { " Returns the matrix row for the given `index`.\n # Panics\n Panics if `index` is greater than 3.", &["_self", "index"], ) + .register_documented( + "sub", + |_self: Val<::glam::DMat4>, rhs: Ref<::glam::DMat4>| { + let output: Val<::glam::DMat4> = { + { + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + &::glam::DMat4, + >>::sub(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "sub", |_self: Val<::glam::DMat4>, rhs: Val<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Sub< + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::DMat4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -49035,12 +53482,29 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { " Returns true if the absolute difference of all elements between `self` and `rhs`\n is less than or equal to `max_abs_diff`.\n This can be used to compare if two 3x4 matrices contain similar elements. It works\n best when comparing with a known value. The `max_abs_diff` that should be used used\n depends on the values being compared against.\n For more see\n [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/).", &["_self", "rhs", "max_abs_diff"], ) + .register_documented( + "as_daffine2", + |_self: Ref<::glam::Affine2>| { + let output: Val<::glam::DAffine2> = { + { + let output: Val<::glam::DAffine2> = ::glam::Affine2::as_daffine2( + &_self, + ) + .into(); + output + } + }; + output + }, + " Casts all elements of `self` to `f64`.", + &["_self"], + ) .register_documented( "clone", |_self: Ref<::glam::Affine2>| { let output: Val<::glam::Affine2> = { { - let output: Val<::glam::Affine2> = <::glam::Affine2 as ::core::clone::Clone>::clone( + let output: Val<::glam::Affine2> = <::glam::Affine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -49057,7 +53521,7 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Ref<::glam::Affine2>, rhs: Ref<::glam::Affine2>| { let output: bool = { { - let output: bool = <::glam::Affine2 as ::core::cmp::PartialEq< + let output: bool = <::glam::Affine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::Affine2, >>::eq(&_self, &rhs) .into(); @@ -49294,12 +53758,63 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { " Returns `true` if any elements are `NaN`.", &["_self"], ) + .register_documented( + "mul", + |_self: Val<::glam::Affine2>, rhs: Ref<::glam::Affine2>| { + let output: Val<::glam::Affine2> = { + { + let output: Val<::glam::Affine2> = <::glam::Affine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::Affine2, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::glam::Affine2>, rhs: Ref<::glam::Mat3>| { + let output: Val<::glam::Mat3> = { + { + let output: Val<::glam::Mat3> = <::glam::Affine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::Mat3, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::glam::Affine2>, rhs: Ref<::glam::Mat3A>| { + let output: Val<::glam::Mat3A> = { + { + let output: Val<::glam::Mat3A> = <::glam::Affine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::Mat3A, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "mul", |_self: Val<::glam::Affine2>, rhs: Val<::glam::Affine2>| { let output: Val<::glam::Affine2> = { { - let output: Val<::glam::Affine2> = <::glam::Affine2 as ::core::ops::Mul< + let output: Val<::glam::Affine2> = <::glam::Affine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Affine2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -49316,7 +53831,7 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Val<::glam::Affine2>, rhs: Val<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Affine2 as ::core::ops::Mul< + let output: Val<::glam::Mat3> = <::glam::Affine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Mat3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -49333,7 +53848,7 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Val<::glam::Affine2>, rhs: Val<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Affine2 as ::core::ops::Mul< + let output: Val<::glam::Mat3A> = <::glam::Affine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Mat3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -49444,12 +53959,29 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { " Returns true if the absolute difference of all elements between `self` and `rhs`\n is less than or equal to `max_abs_diff`.\n This can be used to compare if two 3x4 matrices contain similar elements. It works\n best when comparing with a known value. The `max_abs_diff` that should be used used\n depends on the values being compared against.\n For more see\n [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/).", &["_self", "rhs", "max_abs_diff"], ) + .register_documented( + "as_daffine3", + |_self: Ref<::glam::Affine3A>| { + let output: Val<::glam::DAffine3> = { + { + let output: Val<::glam::DAffine3> = ::glam::Affine3A::as_daffine3( + &_self, + ) + .into(); + output + } + }; + output + }, + " Casts all elements of `self` to `f64`.", + &["_self"], + ) .register_documented( "clone", |_self: Ref<::glam::Affine3A>| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = <::glam::Affine3A as ::core::clone::Clone>::clone( + let output: Val<::glam::Affine3A> = <::glam::Affine3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -49466,7 +53998,7 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |_self: Ref<::glam::Affine3A>, rhs: Ref<::glam::Affine3A>| { let output: bool = { { - let output: bool = <::glam::Affine3A as ::core::cmp::PartialEq< + let output: bool = <::glam::Affine3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::Affine3A, >>::eq(&_self, &rhs) .into(); @@ -49837,12 +54369,46 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { " Creates a right-handed view transform using a camera position, an up direction, and a facing\n direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=back`.", &["eye", "dir", "up"], ) + .register_documented( + "mul", + |_self: Val<::glam::Affine3A>, rhs: Ref<::glam::Affine3A>| { + let output: Val<::glam::Affine3A> = { + { + let output: Val<::glam::Affine3A> = <::glam::Affine3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::Affine3A, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::glam::Affine3A>, rhs: Ref<::glam::Mat4>| { + let output: Val<::glam::Mat4> = { + { + let output: Val<::glam::Mat4> = <::glam::Affine3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::Mat4, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "mul", |_self: Val<::glam::Affine3A>, rhs: Val<::glam::Affine3A>| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = <::glam::Affine3A as ::core::ops::Mul< + let output: Val<::glam::Affine3A> = <::glam::Affine3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Affine3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -49859,7 +54425,7 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |_self: Val<::glam::Affine3A>, rhs: Val<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Affine3A as ::core::ops::Mul< + let output: Val<::glam::Mat4> = <::glam::Affine3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::Mat4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -50006,12 +54572,29 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { " Returns true if the absolute difference of all elements between `self` and `rhs`\n is less than or equal to `max_abs_diff`.\n This can be used to compare if two 3x4 matrices contain similar elements. It works\n best when comparing with a known value. The `max_abs_diff` that should be used used\n depends on the values being compared against.\n For more see\n [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/).", &["_self", "rhs", "max_abs_diff"], ) + .register_documented( + "as_affine2", + |_self: Ref<::glam::DAffine2>| { + let output: Val<::glam::Affine2> = { + { + let output: Val<::glam::Affine2> = ::glam::DAffine2::as_affine2( + &_self, + ) + .into(); + output + } + }; + output + }, + " Casts all elements of `self` to `f32`.", + &["_self"], + ) .register_documented( "clone", |_self: Ref<::glam::DAffine2>| { let output: Val<::glam::DAffine2> = { { - let output: Val<::glam::DAffine2> = <::glam::DAffine2 as ::core::clone::Clone>::clone( + let output: Val<::glam::DAffine2> = <::glam::DAffine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -50028,7 +54611,7 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |_self: Ref<::glam::DAffine2>, rhs: Ref<::glam::DAffine2>| { let output: bool = { { - let output: bool = <::glam::DAffine2 as ::core::cmp::PartialEq< + let output: bool = <::glam::DAffine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::DAffine2, >>::eq(&_self, &rhs) .into(); @@ -50248,12 +54831,46 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { " Returns `true` if any elements are `NaN`.", &["_self"], ) + .register_documented( + "mul", + |_self: Val<::glam::DAffine2>, rhs: Ref<::glam::DAffine2>| { + let output: Val<::glam::DAffine2> = { + { + let output: Val<::glam::DAffine2> = <::glam::DAffine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::DAffine2, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::glam::DAffine2>, rhs: Ref<::glam::DMat3>| { + let output: Val<::glam::DMat3> = { + { + let output: Val<::glam::DMat3> = <::glam::DAffine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::DMat3, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "mul", |_self: Val<::glam::DAffine2>, rhs: Val<::glam::DAffine2>| { let output: Val<::glam::DAffine2> = { { - let output: Val<::glam::DAffine2> = <::glam::DAffine2 as ::core::ops::Mul< + let output: Val<::glam::DAffine2> = <::glam::DAffine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::DAffine2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -50270,7 +54887,7 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |_self: Val<::glam::DAffine2>, rhs: Val<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DAffine2 as ::core::ops::Mul< + let output: Val<::glam::DMat3> = <::glam::DAffine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::DMat3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -50381,12 +54998,29 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { " Returns true if the absolute difference of all elements between `self` and `rhs`\n is less than or equal to `max_abs_diff`.\n This can be used to compare if two 3x4 matrices contain similar elements. It works\n best when comparing with a known value. The `max_abs_diff` that should be used used\n depends on the values being compared against.\n For more see\n [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/).", &["_self", "rhs", "max_abs_diff"], ) + .register_documented( + "as_affine3a", + |_self: Ref<::glam::DAffine3>| { + let output: Val<::glam::Affine3A> = { + { + let output: Val<::glam::Affine3A> = ::glam::DAffine3::as_affine3a( + &_self, + ) + .into(); + output + } + }; + output + }, + " Casts all elements of `self` to `f32`.", + &["_self"], + ) .register_documented( "clone", |_self: Ref<::glam::DAffine3>| { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = <::glam::DAffine3 as ::core::clone::Clone>::clone( + let output: Val<::glam::DAffine3> = <::glam::DAffine3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -50403,7 +55037,7 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |_self: Ref<::glam::DAffine3>, rhs: Ref<::glam::DAffine3>| { let output: bool = { { - let output: bool = <::glam::DAffine3 as ::core::cmp::PartialEq< + let output: bool = <::glam::DAffine3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::DAffine3, >>::eq(&_self, &rhs) .into(); @@ -50782,12 +55416,46 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { " Creates a right-handed view transform using a camera position, an up direction, and a facing\n direction.\n For a view coordinate system with `+X=right`, `+Y=up` and `+Z=back`.", &["eye", "dir", "up"], ) + .register_documented( + "mul", + |_self: Val<::glam::DAffine3>, rhs: Ref<::glam::DAffine3>| { + let output: Val<::glam::DAffine3> = { + { + let output: Val<::glam::DAffine3> = <::glam::DAffine3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::DAffine3, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::glam::DAffine3>, rhs: Ref<::glam::DMat4>| { + let output: Val<::glam::DMat4> = { + { + let output: Val<::glam::DMat4> = <::glam::DAffine3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::DMat4, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "mul", |_self: Val<::glam::DAffine3>, rhs: Val<::glam::DAffine3>| { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = <::glam::DAffine3 as ::core::ops::Mul< + let output: Val<::glam::DAffine3> = <::glam::DAffine3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::DAffine3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -50804,7 +55472,7 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |_self: Val<::glam::DAffine3>, rhs: Val<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DAffine3 as ::core::ops::Mul< + let output: Val<::glam::DMat4> = <::glam::DAffine3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::DMat4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -50911,12 +55579,29 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { " Returns true if the absolute difference of all elements between `self` and `rhs`\n is less than or equal to `max_abs_diff`.\n This can be used to compare if two quaternions contain similar elements. It works\n best when comparing with a known value. The `max_abs_diff` that should be used used\n depends on the values being compared against.\n For more see\n [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/).", &["_self", "rhs", "max_abs_diff"], ) + .register_documented( + "add", + |_self: Val<::glam::DQuat>, rhs: Ref<::glam::DQuat>| { + let output: Val<::glam::DQuat> = { + { + let output: Val<::glam::DQuat> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + &::glam::DQuat, + >>::add(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "add", |_self: Val<::glam::DQuat>, rhs: Val<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Add< + let output: Val<::glam::DQuat> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< ::glam::DQuat, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -50968,7 +55653,7 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Ref<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::clone::Clone>::clone( + let output: Val<::glam::DQuat> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -51002,7 +55687,7 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: f64| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Div< + let output: Val<::glam::DQuat> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< f64, >>::div(_self.into_inner(), rhs) .into(); @@ -51037,7 +55722,7 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Ref<::glam::DQuat>, rhs: Ref<::glam::DQuat>| { let output: bool = { { - let output: bool = <::glam::DQuat as ::core::cmp::PartialEq< + let output: bool = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::DQuat, >>::eq(&_self, &rhs) .into(); @@ -51453,12 +56138,128 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { " Performs a linear interpolation between `self` and `rhs` based on\n the value `s`.\n When `s` is `0.0`, the result will be equal to `self`. When `s`\n is `1.0`, the result will be equal to `rhs`.\n # Panics\n Will panic if `self` or `end` are not normalized when `glam_assert` is enabled.", &["_self", "end", "s"], ) + .register_documented( + "look_at_lh", + | + eye: Val<::glam::DVec3>, + center: Val<::glam::DVec3>, + up: Val<::glam::DVec3>| + { + let output: Val<::glam::DQuat> = { + { + let output: Val<::glam::DQuat> = ::glam::DQuat::look_at_lh( + eye.into_inner(), + center.into_inner(), + up.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a left-handed view matrix using a camera position, a focal point, and an up\n direction.\n For a left-handed view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`.\n # Panics\n Will panic if `up` is not normalized when `glam_assert` is enabled.", + &["eye", "center", "up"], + ) + .register_documented( + "look_at_rh", + | + eye: Val<::glam::DVec3>, + center: Val<::glam::DVec3>, + up: Val<::glam::DVec3>| + { + let output: Val<::glam::DQuat> = { + { + let output: Val<::glam::DQuat> = ::glam::DQuat::look_at_rh( + eye.into_inner(), + center.into_inner(), + up.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a right-handed view matrix using a camera position, an up direction, and a focal\n point.\n For a right-handed view coordinate system with `+X=right`, `+Y=up` and `+Z=back`.\n # Panics\n Will panic if `up` is not normalized when `glam_assert` is enabled.", + &["eye", "center", "up"], + ) + .register_documented( + "look_to_lh", + |dir: Val<::glam::DVec3>, up: Val<::glam::DVec3>| { + let output: Val<::glam::DQuat> = { + { + let output: Val<::glam::DQuat> = ::glam::DQuat::look_to_lh( + dir.into_inner(), + up.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a quaterion rotation from a facing direction and an up direction.\n For a left-handed view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`.\n # Panics\n Will panic if `up` is not normalized when `glam_assert` is enabled.", + &["dir", "up"], + ) + .register_documented( + "look_to_rh", + |dir: Val<::glam::DVec3>, up: Val<::glam::DVec3>| { + let output: Val<::glam::DQuat> = { + { + let output: Val<::glam::DQuat> = ::glam::DQuat::look_to_rh( + dir.into_inner(), + up.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a quaterion rotation from facing direction and an up direction.\n For a right-handed view coordinate system with `+X=right`, `+Y=up` and `+Z=back`.\n # Panics\n Will panic if `dir` and `up` are not normalized when `glam_assert` is enabled.", + &["dir", "up"], + ) + .register_documented( + "mul", + |_self: Val<::glam::DQuat>, rhs: Ref<::glam::DQuat>| { + let output: Val<::glam::DQuat> = { + { + let output: Val<::glam::DQuat> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::DQuat, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::glam::DQuat>, rhs: Ref<::glam::DVec3>| { + let output: Val<::glam::DVec3> = { + { + let output: Val<::glam::DVec3> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + &::glam::DVec3, + >>::mul(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "mul", |_self: Val<::glam::DQuat>, rhs: Val<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Mul< + let output: Val<::glam::DQuat> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::DQuat, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -51475,7 +56276,7 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DQuat as ::core::ops::Mul< + let output: Val<::glam::DVec3> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< ::glam::DVec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -51492,7 +56293,7 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: f64| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Mul< + let output: Val<::glam::DQuat> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< f64, >>::mul(_self.into_inner(), rhs) .into(); @@ -51545,7 +56346,7 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Neg>::neg( + let output: Val<::glam::DQuat> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -51612,12 +56413,29 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { " Performs a spherical linear interpolation between `self` and `end`\n based on the value `s`.\n When `s` is `0.0`, the result will be equal to `self`. When `s`\n is `1.0`, the result will be equal to `end`.\n # Panics\n Will panic if `self` or `end` are not normalized when `glam_assert` is enabled.", &["_self", "end", "s"], ) + .register_documented( + "sub", + |_self: Val<::glam::DQuat>, rhs: Ref<::glam::DQuat>| { + let output: Val<::glam::DQuat> = { + { + let output: Val<::glam::DQuat> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + &::glam::DQuat, + >>::sub(_self.into_inner(), &rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "sub", |_self: Val<::glam::DQuat>, rhs: Val<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Sub< + let output: Val<::glam::DQuat> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< ::glam::DQuat, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -51700,57 +56518,60 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { registry.register_type_data::<::glam::DQuat, bevy_mod_scripting_bindings::MarkAsGenerated>(); } pub(crate) fn register_euler_rot_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<::glam::EulerRot>::new( - world, - ) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::glam::EulerRot>| { - let output: () = { - { - let output: () = - <::glam::EulerRot as ::core::cmp::Eq>::assert_receiver_is_total_eq(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::glam::EulerRot>| { - let output: Val<::glam::EulerRot> = { - { - let output: Val<::glam::EulerRot> = - <::glam::EulerRot as ::core::clone::Clone>::clone(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::glam::EulerRot>, other: Ref<::glam::EulerRot>| { - let output: bool = { - { - let output: bool = <::glam::EulerRot as ::core::cmp::PartialEq< - ::glam::EulerRot, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::glam::EulerRot, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::glam::EulerRot>| { + let output: () = { + { + let output: () = <::glam::EulerRot as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::glam::EulerRot>| { + let output: Val<::glam::EulerRot> = { + { + let output: Val<::glam::EulerRot> = <::glam::EulerRot as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::glam::EulerRot>, other: Ref<::glam::EulerRot>| { + let output: bool = { + { + let output: bool = <::glam::EulerRot as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + ::glam::EulerRot, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry.register_type_data::<::glam::EulerRot, bevy_mod_scripting_bindings::MarkAsGenerated>(); @@ -51809,7 +56630,7 @@ pub(crate) fn register_b_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::BVec3A>| { let output: Val<::glam::BVec3A> = { { - let output: Val<::glam::BVec3A> = <::glam::BVec3A as ::core::clone::Clone>::clone( + let output: Val<::glam::BVec3A> = <::glam::BVec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -51826,7 +56647,7 @@ pub(crate) fn register_b_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::BVec3A>, rhs: Ref<::glam::BVec3A>| { let output: bool = { { - let output: bool = <::glam::BVec3A as ::core::cmp::PartialEq< + let output: bool = <::glam::BVec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::BVec3A, >>::eq(&_self, &rhs) .into(); @@ -51970,7 +56791,7 @@ pub(crate) fn register_b_vec_4_a_functions(world: &mut World) { |_self: Ref<::glam::BVec4A>| { let output: Val<::glam::BVec4A> = { { - let output: Val<::glam::BVec4A> = <::glam::BVec4A as ::core::clone::Clone>::clone( + let output: Val<::glam::BVec4A> = <::glam::BVec4A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -51987,7 +56808,7 @@ pub(crate) fn register_b_vec_4_a_functions(world: &mut World) { |_self: Ref<::glam::BVec4A>, rhs: Ref<::glam::BVec4A>| { let output: bool = { { - let output: bool = <::glam::BVec4A as ::core::cmp::PartialEq< + let output: bool = <::glam::BVec4A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::glam::BVec4A, >>::eq(&_self, &rhs) .into(); @@ -52078,98 +56899,103 @@ pub(crate) fn register_b_vec_4_a_functions(world: &mut World) { registry.register_type_data::<::glam::BVec4A, bevy_mod_scripting_bindings::MarkAsGenerated>(); } pub(crate) fn register_smol_str_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<::smol_str::SmolStr>::new( - world, - ) - .register_documented( - "clone", - |_self: Ref<::smol_str::SmolStr>| { - let output: Val<::smol_str::SmolStr> = { - { - let output: Val<::smol_str::SmolStr> = - <::smol_str::SmolStr as ::core::clone::Clone>::clone(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::smol_str::SmolStr>, other: Ref<::smol_str::SmolStr>| { - let output: bool = { - { - let output: bool = <::smol_str::SmolStr as ::core::cmp::PartialEq< - ::smol_str::SmolStr, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "is_empty", - |_self: Ref<::smol_str::SmolStr>| { - let output: bool = { - { - let output: bool = ::smol_str::SmolStr::is_empty(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "is_heap_allocated", - |_self: Ref<::smol_str::SmolStr>| { - let output: bool = { - { - let output: bool = ::smol_str::SmolStr::is_heap_allocated(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "len", - |_self: Ref<::smol_str::SmolStr>| { - let output: usize = { - { - let output: usize = ::smol_str::SmolStr::len(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "to_string", - |_self: Ref<::smol_str::SmolStr>| { - let output: ::std::string::String = { - { - let output: ::std::string::String = - ::smol_str::SmolStr::to_string(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ); + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::smol_str::SmolStr, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::smol_str::SmolStr>| { + let output: Val<::smol_str::SmolStr> = { + { + let output: Val<::smol_str::SmolStr> = <::smol_str::SmolStr as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::smol_str::SmolStr>, other: Ref<::smol_str::SmolStr>| { + let output: bool = { + { + let output: bool = <::smol_str::SmolStr as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + ::smol_str::SmolStr, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "is_empty", + |_self: Ref<::smol_str::SmolStr>| { + let output: bool = { + { + let output: bool = ::smol_str::SmolStr::is_empty(&_self).into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "is_heap_allocated", + |_self: Ref<::smol_str::SmolStr>| { + let output: bool = { + { + let output: bool = ::smol_str::SmolStr::is_heap_allocated(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "len", + |_self: Ref<::smol_str::SmolStr>| { + let output: usize = { + { + let output: usize = ::smol_str::SmolStr::len(&_self).into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "to_string", + |_self: Ref<::smol_str::SmolStr>| { + let output: ::std::string::String = { + { + let output: ::std::string::String = ::smol_str::SmolStr::to_string( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -52213,7 +57039,7 @@ pub(crate) fn register_uuid_functions(world: &mut World) { |_self: Ref<::uuid::Uuid>| { let output: () = { { - let output: () = <::uuid::Uuid as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::uuid::Uuid as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -52230,7 +57056,7 @@ pub(crate) fn register_uuid_functions(world: &mut World) { |_self: Ref<::uuid::Uuid>| { let output: Val<::uuid::Uuid> = { { - let output: Val<::uuid::Uuid> = <::uuid::Uuid as ::core::clone::Clone>::clone( + let output: Val<::uuid::Uuid> = <::uuid::Uuid as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( &_self, ) .into(); @@ -52256,12 +57082,29 @@ pub(crate) fn register_uuid_functions(world: &mut World) { " A buffer that can be used for `encode_...` calls, that is\n guaranteed to be long enough for any of the format adapters.\n # Examples\n ```\n # use uuid::Uuid;\n let uuid = Uuid::nil();\n assert_eq!(\n uuid.simple().encode_lower(&mut Uuid::encode_buffer()),\n \"00000000000000000000000000000000\"\n );\n assert_eq!(\n uuid.hyphenated()\n .encode_lower(&mut Uuid::encode_buffer()),\n \"00000000-0000-0000-0000-000000000000\"\n );\n assert_eq!(\n uuid.urn().encode_lower(&mut Uuid::encode_buffer()),\n \"urn:uuid:00000000-0000-0000-0000-000000000000\"\n );\n ```", &[], ) + .register_documented( + "eq", + |_self: Ref<::uuid::Uuid>, other: Ref<::uuid::NonNilUuid>| { + let output: bool = { + { + let output: bool = <::uuid::Uuid as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + ::uuid::NonNilUuid, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) .register_documented( "eq", |_self: Ref<::uuid::Uuid>, other: Ref<::uuid::Uuid>| { let output: bool = { { - let output: bool = <::uuid::Uuid as ::core::cmp::PartialEq< + let output: bool = <::uuid::Uuid as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::uuid::Uuid, >>::eq(&_self, &other) .into(); @@ -52354,12 +57197,13 @@ pub(crate) fn register_uuid_functions(world: &mut World) { .register_documented( "get_node_id", |_self: Ref<::uuid::Uuid>| { - let output: ::core::option::Option<[u8; 6]> = { + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + [u8; 6], + > = { { - let output: ::core::option::Option<[u8; 6]> = ::uuid::Uuid::get_node_id( - &_self, - ) - .into(); + let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< + [u8; 6], + > = ::uuid::Uuid::get_node_id(&_self).into(); output } }; @@ -52501,19 +57345,130 @@ pub(crate) fn register_uuid_functions(world: &mut World) { let mut registry = registry.write(); registry.register_type_data::<::uuid::Uuid, bevy_mod_scripting_bindings::MarkAsGenerated>(); } +pub(crate) fn register_non_nil_uuid_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::uuid::NonNilUuid, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::uuid::NonNilUuid>| { + let output: () = { + { + let output: () = <::uuid::NonNilUuid as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::uuid::NonNilUuid>| { + let output: Val<::uuid::NonNilUuid> = { + { + let output: Val<::uuid::NonNilUuid> = <::uuid::NonNilUuid as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::uuid::NonNilUuid>, other: Ref<::uuid::NonNilUuid>| { + let output: bool = { + { + let output: bool = <::uuid::NonNilUuid as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + ::uuid::NonNilUuid, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "eq", + |_self: Ref<::uuid::NonNilUuid>, other: Ref<::uuid::Uuid>| { + let output: bool = { + { + let output: bool = <::uuid::NonNilUuid as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + ::uuid::Uuid, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "get", + |_self: Val<::uuid::NonNilUuid>| { + let output: Val<::uuid::Uuid> = { + { + let output: Val<::uuid::Uuid> = ::uuid::NonNilUuid::get( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Get the underlying [`Uuid`] value.", + &["_self"], + ) + .register_documented( + "new_unchecked", + |uuid: Val<::uuid::Uuid>| { + let output: Val<::uuid::NonNilUuid> = { + { + let output: Val<::uuid::NonNilUuid> = ::uuid::NonNilUuid::new_unchecked( + uuid.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a non-nil without checking whether the value is non-nil. This results in undefined behavior if the value is nil.\n # Safety\n The value must not be nil.", + &["uuid"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::<::uuid::NonNilUuid, bevy_mod_scripting_bindings::MarkAsGenerated>(); +} impl Plugin for BevyReflectScriptingPlugin { fn build(&self, app: &mut App) { let mut world = app.world_mut(); register_atomic_bool_functions(&mut world); + register_atomic_i_8_functions(&mut world); register_atomic_i_16_functions(&mut world); register_atomic_i_32_functions(&mut world); register_atomic_i_64_functions(&mut world); - register_atomic_i_8_functions(&mut world); register_atomic_isize_functions(&mut world); + register_atomic_u_8_functions(&mut world); register_atomic_u_16_functions(&mut world); register_atomic_u_32_functions(&mut world); register_atomic_u_64_functions(&mut world); - register_atomic_u_8_functions(&mut world); register_atomic_usize_functions(&mut world); register_duration_functions(&mut world); register_instant_functions(&mut world); @@ -52572,5 +57527,6 @@ impl Plugin for BevyReflectScriptingPlugin { register_b_vec_4_a_functions(&mut world); register_smol_str_functions(&mut world); register_uuid_functions(&mut world); + register_non_nil_uuid_functions(&mut world); } } diff --git a/crates/bindings/bevy_render_bms_bindings/Cargo.toml b/crates/bindings/bevy_render_bms_bindings/Cargo.toml index 30a4d8186f..00a707b93a 100644 --- a/crates/bindings/bevy_render_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_render_bms_bindings/Cargo.toml @@ -17,96 +17,75 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_render = { version = "0.16.1", features = [ - "hdr", - "ktx2", - "multi_threaded", - "webgl", -], default-features = true } +bevy_render = { version = "0.17.2", features = ["multi_threaded", "webgl"], default-features = true} -async-channel = { version = "^2.3.0", features = [], default-features = true } +async-channel = { version = "^2.3.0", features = [], default-features = true} -bevy_app = { version = "^0.16.1", features = [], default-features = true } +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} -bevy_asset = { version = "^0.16.1", features = [], default-features = true } +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} -bevy_color = { version = "^0.16.2", features = [], default-features = true } +bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_derive = { version = "^0.16.1", features = [], default-features = true } +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} -bevy_diagnostic = { version = "^0.16.1", features = [ -], default-features = true } +bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.16.1", features = [], default-features = true } +bevy_diagnostic = { version = "^0.17.2", features = ["std", "sysinfo", "sysinfo_plugin"], default-features = true} -bevy_encase_derive = { version = "^0.16.1", features = [ -], default-features = true } +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_image = { version = "^0.16.1", features = [ - "hdr", - "ktx2", -], default-features = false } +bevy_encase_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_math = { version = "^0.16.1", features = [], default-features = true } +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} -bevy_mesh = { version = "^0.16.1", features = [], default-features = true } +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} -bevy_reflect = { version = "^0.16.1", features = [], default-features = true } +bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_render_macros = { version = "^0.16.1", features = [ -], default-features = true } +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_tasks = { version = "^0.16.1", features = [ - "multi_threaded", - "multi_threaded", -], default-features = false } +bevy_render_macros = { version = "^0.17.2", features = [], default-features = true} -bevy_time = { version = "^0.16.1", features = [], default-features = true } +bevy_shader = { version = "^0.17.2", features = [], default-features = true} -bevy_transform = { version = "^0.16.1", features = [], default-features = true } +bevy_tasks = { version = "^0.17.2", features = ["multi_threaded", "async_executor", "futures-lite"], default-features = true} -bevy_utils = { version = "^0.16.1", features = [], default-features = true } +bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_window = { version = "^0.16.1", features = [], default-features = true } +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bitflags = { version = "^2", features = [], default-features = true } +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} -bytemuck = { version = "^1.5", features = [], default-features = true } +bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} -codespan-reporting = { version = "^0.11.0", features = [ -], default-features = true } +bitflags = { version = "^2", features = [], default-features = true} -encase = { version = "^0.10", features = [], default-features = true } +bytemuck = { version = "^1.5", features = [], default-features = true} -fixedbitset = { version = "^0.5", features = [], default-features = true } +encase = { version = "^0.11", features = [], default-features = true} -futures-lite = { version = "^2.0.1", features = [], default-features = true } +fixedbitset = { version = "^0.5", features = [], default-features = true} -indexmap = { version = "^2", features = [], default-features = true } +indexmap = { version = "^2", features = [], default-features = true} -js-sys = { version = "^0.3", features = [], default-features = true } +js-sys = { version = "^0.3", features = [], default-features = true} -ktx2 = { version = "^0.3.0", features = [], default-features = true } +naga = { version = "^26", features = [], default-features = true} -naga = { version = "^24", features = [], default-features = true } +nonmax = { version = "^0.5", features = [], default-features = true} -naga_oil = { version = "^0.17", features = [], default-features = true } +offset-allocator = { version = "^0.2", features = [], default-features = true} -nonmax = { version = "^0.5", features = [], default-features = true } +send_wrapper = { version = "^0.6.0", features = [], default-features = true} -offset-allocator = { version = "^0.2", features = [], default-features = true } +variadics_please = { version = "^1.1", features = [], default-features = true} -send_wrapper = { version = "^0.6.0", features = [], default-features = true } +wasm-bindgen = { version = "^0.2", features = [], default-features = true} -serde = { version = "^1", features = [], default-features = true } +web-sys = { version = "^0.3.67", features = [], default-features = true} -smallvec = { version = "^1.11", features = [], default-features = true } +wgpu = { version = "^26", features = ["webgl"], default-features = false} -variadics_please = { version = "^1.1", features = [], default-features = true } -wasm-bindgen = { version = "^0.2", features = [], default-features = true } - -web-sys = { version = "^0.3.67", features = [], default-features = true } - -wgpu = { version = "^24", features = ["webgl"], default-features = false } diff --git a/crates/bindings/bevy_render_bms_bindings/src/lib.rs b/crates/bindings/bevy_render_bms_bindings/src/lib.rs index 497e919fb5..050655fe7a 100644 --- a/crates/bindings/bevy_render_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_render_bms_bindings/src/lib.rs @@ -58,16 +58,16 @@ pub(crate) fn register_alpha_mode_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_camera_functions(world: &mut World) { +pub(crate) fn register_msaa_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::camera::Camera, + ::bevy_render::view::Msaa, >::new(world) .register_documented( - "clip_from_view", - |_self: Ref<::bevy_render::camera::Camera>| { - let output: Val<::bevy_math::Mat4> = { + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_render::view::Msaa>| { + let output: () = { { - let output: Val<::bevy_math::Mat4> = ::bevy_render::camera::Camera::clip_from_view( + let output: () = <::bevy_render::view::Msaa as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -76,15 +76,15 @@ pub(crate) fn register_camera_functions(world: &mut World) { }; output }, - " The projection matrix computed using this camera's [`CameraProjection`].", + "", &["_self"], ) .register_documented( "clone", - |_self: Ref<::bevy_render::camera::Camera>| { - let output: Val<::bevy_render::camera::Camera> = { + |_self: Ref<::bevy_render::view::Msaa>| { + let output: Val<::bevy_render::view::Msaa> = { { - let output: Val<::bevy_render::camera::Camera> = <::bevy_render::camera::Camera as ::std::clone::Clone>::clone( + let output: Val<::bevy_render::view::Msaa> = <::bevy_render::view::Msaa as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -97,31 +97,32 @@ pub(crate) fn register_camera_functions(world: &mut World) { &["_self"], ) .register_documented( - "depth_ndc_to_view_z", - |_self: Ref<::bevy_render::camera::Camera>, ndc_depth: f32| { - let output: f32 = { + "eq", + | + _self: Ref<::bevy_render::view::Msaa>, + other: Ref<::bevy_render::view::Msaa>| + { + let output: bool = { { - let output: f32 = ::bevy_render::camera::Camera::depth_ndc_to_view_z( - &_self, - ndc_depth, - ) + let output: bool = <::bevy_render::view::Msaa as ::std::cmp::PartialEq< + ::bevy_render::view::Msaa, + >>::eq(&_self, &other) .into(); output } }; output }, - " Converts the depth in Normalized Device Coordinates\n to linear view z for perspective projections.\n Note: Depth values in front of the camera will be negative as -z is forward", - &["_self", "ndc_depth"], + "", + &["_self", "other"], ) .register_documented( - "depth_ndc_to_view_z_2d", - |_self: Ref<::bevy_render::camera::Camera>, ndc_depth: f32| { - let output: f32 = { + "from_samples", + |samples: u32| { + let output: Val<::bevy_render::view::Msaa> = { { - let output: f32 = ::bevy_render::camera::Camera::depth_ndc_to_view_z_2d( - &_self, - ndc_depth, + let output: Val<::bevy_render::view::Msaa> = ::bevy_render::view::Msaa::from_samples( + samples, ) .into(); output @@ -129,17 +130,15 @@ pub(crate) fn register_camera_functions(world: &mut World) { }; output }, - " Converts the depth in Normalized Device Coordinates\n to linear view z for orthographic projections.\n Note: Depth values in front of the camera will be negative as -z is forward", - &["_self", "ndc_depth"], + "", + &["samples"], ) .register_documented( - "target_scaling_factor", - |_self: Ref<::bevy_render::camera::Camera>| { - let output: ::std::option::Option = { + "samples", + |_self: Ref<::bevy_render::view::Msaa>| { + let output: u32 = { { - let output: ::std::option::Option = ::bevy_render::camera::Camera::target_scaling_factor( - &_self, - ) + let output: u32 = ::bevy_render::view::Msaa::samples(&_self) .into(); output } @@ -153,78 +152,37 @@ pub(crate) fn register_camera_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_render::camera::Camera, + ::bevy_render::view::Msaa, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_clear_color_functions(world: &mut World) { +pub(crate) fn register_main_entity_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::camera::ClearColor, + ::bevy_render::sync_world::MainEntity, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::camera::ClearColor>| { - let output: Val<::bevy_render::camera::ClearColor> = { - { - let output: Val<::bevy_render::camera::ClearColor> = - <::bevy_render::camera::ClearColor as ::std::clone::Clone>::clone(&_self) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_render::sync_world::MainEntity>| { + let output: () = { + { + let output: () = <::bevy_render::sync_world::MainEntity as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::camera::ClearColor, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_clear_color_config_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::camera::ClearColorConfig, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::camera::ClearColorConfig>| { - let output: Val<::bevy_render::camera::ClearColorConfig> = { - { - let output: Val<::bevy_render::camera::ClearColorConfig> = - <::bevy_render::camera::ClearColorConfig as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::camera::ClearColorConfig, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_orthographic_projection_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::camera::OrthographicProjection, - >::new(world) + output + } + }; + output + }, + "", + &["_self"], + ) .register_documented( "clone", - |_self: Ref<::bevy_render::camera::OrthographicProjection>| { - let output: Val<::bevy_render::camera::OrthographicProjection> = { + |_self: Ref<::bevy_render::sync_world::MainEntity>| { + let output: Val<::bevy_render::sync_world::MainEntity> = { { - let output: Val<::bevy_render::camera::OrthographicProjection> = <::bevy_render::camera::OrthographicProjection as ::std::clone::Clone>::clone( + let output: Val<::bevy_render::sync_world::MainEntity> = <::bevy_render::sync_world::MainEntity as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -237,53 +195,68 @@ pub(crate) fn register_orthographic_projection_functions(world: &mut World) { &["_self"], ) .register_documented( - "default_2d", - || { - let output: Val<::bevy_render::camera::OrthographicProjection> = { + "eq", + | + _self: Ref<::bevy_render::sync_world::MainEntity>, + other: Ref<::bevy_render::sync_world::MainEntity>| + { + let output: bool = { { - let output: Val<::bevy_render::camera::OrthographicProjection> = ::bevy_render::camera::OrthographicProjection::default_2d() + let output: bool = <::bevy_render::sync_world::MainEntity as ::std::cmp::PartialEq< + ::bevy_render::sync_world::MainEntity, + >>::eq(&_self, &other) .into(); output } }; output }, - " Returns the default orthographic projection for a 2D context.\n The near plane is set to a negative value so that the camera can still\n render the scene when using positive z coordinates to order foreground elements.", - &[], + "", + &["_self", "other"], ) .register_documented( - "default_3d", - || { - let output: Val<::bevy_render::camera::OrthographicProjection> = { + "id", + |_self: Ref<::bevy_render::sync_world::MainEntity>| { + let output: Val<::bevy_ecs::entity::Entity> = { { - let output: Val<::bevy_render::camera::OrthographicProjection> = ::bevy_render::camera::OrthographicProjection::default_3d() + let output: Val<::bevy_ecs::entity::Entity> = ::bevy_render::sync_world::MainEntity::id( + &_self, + ) .into(); output } }; output }, - " Returns the default orthographic projection for a 3D context.\n The near plane is set to 0.0 so that the camera doesn't render\n objects that are behind it.", - &[], + "", + &["_self"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_render::camera::OrthographicProjection, + ::bevy_render::sync_world::MainEntity, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_perspective_projection_functions(world: &mut World) { +pub(crate) fn register_occlusion_culling_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::camera::PerspectiveProjection, + ::bevy_render::experimental::occlusion_culling::OcclusionCulling, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_render::camera::PerspectiveProjection>| { - let output: Val<::bevy_render::camera::PerspectiveProjection> = { + | + _self: Ref< + ::bevy_render::experimental::occlusion_culling::OcclusionCulling, + >| + { + let output: Val< + ::bevy_render::experimental::occlusion_culling::OcclusionCulling, + > = { { - let output: Val<::bevy_render::camera::PerspectiveProjection> = <::bevy_render::camera::PerspectiveProjection as ::std::clone::Clone>::clone( + let output: Val< + ::bevy_render::experimental::occlusion_culling::OcclusionCulling, + > = <::bevy_render::experimental::occlusion_culling::OcclusionCulling as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -299,48 +272,20 @@ pub(crate) fn register_perspective_projection_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_render::camera::PerspectiveProjection, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_projection_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::camera::Projection, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::camera::Projection>| { - let output: Val<::bevy_render::camera::Projection> = { - { - let output: Val<::bevy_render::camera::Projection> = - <::bevy_render::camera::Projection as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::camera::Projection, + ::bevy_render::experimental::occlusion_culling::OcclusionCulling, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_mesh_2_d_functions(world: &mut World) { +pub(crate) fn register_render_entity_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::mesh::Mesh2d, + ::bevy_render::sync_world::RenderEntity, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_render::mesh::Mesh2d>| { + |_self: Ref<::bevy_render::sync_world::RenderEntity>| { let output: () = { { - let output: () = <::bevy_render::mesh::Mesh2d as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_render::sync_world::RenderEntity as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -354,10 +299,10 @@ pub(crate) fn register_mesh_2_d_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_render::mesh::Mesh2d>| { - let output: Val<::bevy_render::mesh::Mesh2d> = { + |_self: Ref<::bevy_render::sync_world::RenderEntity>| { + let output: Val<::bevy_render::sync_world::RenderEntity> = { { - let output: Val<::bevy_render::mesh::Mesh2d> = <::bevy_render::mesh::Mesh2d as ::std::clone::Clone>::clone( + let output: Val<::bevy_render::sync_world::RenderEntity> = <::bevy_render::sync_world::RenderEntity as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -372,13 +317,13 @@ pub(crate) fn register_mesh_2_d_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_render::mesh::Mesh2d>, - other: Ref<::bevy_render::mesh::Mesh2d>| + _self: Ref<::bevy_render::sync_world::RenderEntity>, + other: Ref<::bevy_render::sync_world::RenderEntity>| { let output: bool = { { - let output: bool = <::bevy_render::mesh::Mesh2d as ::std::cmp::PartialEq< - ::bevy_render::mesh::Mesh2d, + let output: bool = <::bevy_render::sync_world::RenderEntity as ::std::cmp::PartialEq< + ::bevy_render::sync_world::RenderEntity, >>::eq(&_self, &other) .into(); output @@ -388,42 +333,13 @@ pub(crate) fn register_mesh_2_d_functions(world: &mut World) { }, "", &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::mesh::Mesh2d, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_mesh_3_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::mesh::Mesh3d, - >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_render::mesh::Mesh3d>| { - let output: () = { - { - let output: () = <::bevy_render::mesh::Mesh3d as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], ) .register_documented( - "clone", - |_self: Ref<::bevy_render::mesh::Mesh3d>| { - let output: Val<::bevy_render::mesh::Mesh3d> = { + "id", + |_self: Ref<::bevy_render::sync_world::RenderEntity>| { + let output: Val<::bevy_ecs::entity::Entity> = { { - let output: Val<::bevy_render::mesh::Mesh3d> = <::bevy_render::mesh::Mesh3d as ::std::clone::Clone>::clone( + let output: Val<::bevy_ecs::entity::Entity> = ::bevy_render::sync_world::RenderEntity::id( &_self, ) .into(); @@ -434,45 +350,25 @@ pub(crate) fn register_mesh_3_d_functions(world: &mut World) { }, "", &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_render::mesh::Mesh3d>, - other: Ref<::bevy_render::mesh::Mesh3d>| - { - let output: bool = { - { - let output: bool = <::bevy_render::mesh::Mesh3d as ::std::cmp::PartialEq< - ::bevy_render::mesh::Mesh3d, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_render::mesh::Mesh3d, + ::bevy_render::sync_world::RenderEntity, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_inherited_visibility_functions(world: &mut World) { +pub(crate) fn register_sync_to_render_world_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::view::visibility::InheritedVisibility, + ::bevy_render::sync_world::SyncToRenderWorld, >::new(world) .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_render::view::visibility::InheritedVisibility>| { - let output: () = { + "clone", + |_self: Ref<::bevy_render::sync_world::SyncToRenderWorld>| { + let output: Val<::bevy_render::sync_world::SyncToRenderWorld> = { { - let output: () = <::bevy_render::view::visibility::InheritedVisibility as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: Val<::bevy_render::sync_world::SyncToRenderWorld> = <::bevy_render::sync_world::SyncToRenderWorld as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -483,15 +379,25 @@ pub(crate) fn register_inherited_visibility_functions(world: &mut World) { }, "", &["_self"], - ) + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_render::sync_world::SyncToRenderWorld, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_color_grading_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_render::view::ColorGrading, + >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_render::view::visibility::InheritedVisibility>| { - let output: Val<::bevy_render::view::visibility::InheritedVisibility> = { + |_self: Ref<::bevy_render::view::ColorGrading>| { + let output: Val<::bevy_render::view::ColorGrading> = { { - let output: Val< - ::bevy_render::view::visibility::InheritedVisibility, - > = <::bevy_render::view::visibility::InheritedVisibility as ::std::clone::Clone>::clone( + let output: Val<::bevy_render::view::ColorGrading> = <::bevy_render::view::ColorGrading as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -504,32 +410,16 @@ pub(crate) fn register_inherited_visibility_functions(world: &mut World) { &["_self"], ) .register_documented( - "eq", + "with_identical_sections", | - _self: Ref<::bevy_render::view::visibility::InheritedVisibility>, - other: Ref<::bevy_render::view::visibility::InheritedVisibility>| + global: Val<::bevy_render::view::ColorGradingGlobal>, + section: Val<::bevy_render::view::ColorGradingSection>| { - let output: bool = { - { - let output: bool = <::bevy_render::view::visibility::InheritedVisibility as ::std::cmp::PartialEq< - ::bevy_render::view::visibility::InheritedVisibility, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "get", - |_self: Val<::bevy_render::view::visibility::InheritedVisibility>| { - let output: bool = { + let output: Val<::bevy_render::view::ColorGrading> = { { - let output: bool = ::bevy_render::view::visibility::InheritedVisibility::get( - _self.into_inner(), + let output: Val<::bevy_render::view::ColorGrading> = ::bevy_render::view::ColorGrading::with_identical_sections( + global.into_inner(), + section.into_inner(), ) .into(); output @@ -537,27 +427,27 @@ pub(crate) fn register_inherited_visibility_functions(world: &mut World) { }; output }, - " Returns `true` if the entity is visible in the hierarchy.\n Otherwise, returns `false`.", - &["_self"], + " Creates a new [`ColorGrading`] instance in which shadows, midtones, and\n highlights all have the same set of color grading values.", + &["global", "section"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_render::view::visibility::InheritedVisibility, + ::bevy_render::view::ColorGrading, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_msaa_functions(world: &mut World) { +pub(crate) fn register_hdr_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::view::Msaa, + ::bevy_render::view::Hdr, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_render::view::Msaa>| { + |_self: Ref<::bevy_render::view::Hdr>| { let output: () = { { - let output: () = <::bevy_render::view::Msaa as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_render::view::Hdr as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -571,10 +461,10 @@ pub(crate) fn register_msaa_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_render::view::Msaa>| { - let output: Val<::bevy_render::view::Msaa> = { + |_self: Ref<::bevy_render::view::Hdr>| { + let output: Val<::bevy_render::view::Hdr> = { { - let output: Val<::bevy_render::view::Msaa> = <::bevy_render::view::Msaa as ::std::clone::Clone>::clone( + let output: Val<::bevy_render::view::Hdr> = <::bevy_render::view::Hdr as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -588,1494 +478,11 @@ pub(crate) fn register_msaa_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_render::view::Msaa>, - other: Ref<::bevy_render::view::Msaa>| - { + |_self: Ref<::bevy_render::view::Hdr>, other: Ref<::bevy_render::view::Hdr>| { let output: bool = { { - let output: bool = <::bevy_render::view::Msaa as ::std::cmp::PartialEq< - ::bevy_render::view::Msaa, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "from_samples", - |samples: u32| { - let output: Val<::bevy_render::view::Msaa> = { - { - let output: Val<::bevy_render::view::Msaa> = ::bevy_render::view::Msaa::from_samples( - samples, - ) - .into(); - output - } - }; - output - }, - "", - &["samples"], - ) - .register_documented( - "samples", - |_self: Ref<::bevy_render::view::Msaa>| { - let output: u32 = { - { - let output: u32 = ::bevy_render::view::Msaa::samples(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::view::Msaa, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_view_visibility_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::view::visibility::ViewVisibility, - >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_render::view::visibility::ViewVisibility>| { - let output: () = { - { - let output: () = <::bevy_render::view::visibility::ViewVisibility as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_render::view::visibility::ViewVisibility>| { - let output: Val<::bevy_render::view::visibility::ViewVisibility> = { - { - let output: Val< - ::bevy_render::view::visibility::ViewVisibility, - > = <::bevy_render::view::visibility::ViewVisibility as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_render::view::visibility::ViewVisibility>, - other: Ref<::bevy_render::view::visibility::ViewVisibility>| - { - let output: bool = { - { - let output: bool = <::bevy_render::view::visibility::ViewVisibility as ::std::cmp::PartialEq< - ::bevy_render::view::visibility::ViewVisibility, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "get", - |_self: Val<::bevy_render::view::visibility::ViewVisibility>| { - let output: bool = { - { - let output: bool = ::bevy_render::view::visibility::ViewVisibility::get( - _self.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Returns `true` if the entity is visible in any view.\n Otherwise, returns `false`.", - &["_self"], - ) - .register_documented( - "set", - |mut _self: Mut<::bevy_render::view::visibility::ViewVisibility>| { - let output: () = { - { - let output: () = ::bevy_render::view::visibility::ViewVisibility::set( - &mut _self, - ) - .into(); - output - } - }; - output - }, - " Sets the visibility to `true`. This should not be considered reversible for a given frame,\n as this component tracks whether or not the entity visible in _any_ view.\n This will be automatically reset to `false` every frame in [`VisibilityPropagate`] and then set\n to the proper value in [`CheckVisibility`].\n You should only manually set this if you are defining a custom visibility system,\n in which case the system should be placed in the [`CheckVisibility`] set.\n For normal user-defined entity visibility, see [`Visibility`].\n [`VisibilityPropagate`]: VisibilitySystems::VisibilityPropagate\n [`CheckVisibility`]: VisibilitySystems::CheckVisibility", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::view::visibility::ViewVisibility, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_visibility_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::view::visibility::Visibility, - >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_render::view::visibility::Visibility>| { - let output: () = { - { - let output: () = <::bevy_render::view::visibility::Visibility as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_render::view::visibility::Visibility>| { - let output: Val<::bevy_render::view::visibility::Visibility> = { - { - let output: Val<::bevy_render::view::visibility::Visibility> = <::bevy_render::view::visibility::Visibility as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_render::view::visibility::Visibility>, - other: Ref<::bevy_render::view::visibility::Visibility>| - { - let output: bool = { - { - let output: bool = <::bevy_render::view::visibility::Visibility as ::std::cmp::PartialEq< - ::bevy_render::view::visibility::Visibility, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "toggle_inherited_hidden", - |mut _self: Mut<::bevy_render::view::visibility::Visibility>| { - let output: () = { - { - let output: () = ::bevy_render::view::visibility::Visibility::toggle_inherited_hidden( - &mut _self, - ) - .into(); - output - } - }; - output - }, - " Toggles between `Visibility::Inherited` and `Visibility::Hidden`.\n If the value is `Visibility::Visible`, it remains unaffected.", - &["_self"], - ) - .register_documented( - "toggle_inherited_visible", - |mut _self: Mut<::bevy_render::view::visibility::Visibility>| { - let output: () = { - { - let output: () = ::bevy_render::view::visibility::Visibility::toggle_inherited_visible( - &mut _self, - ) - .into(); - output - } - }; - output - }, - " Toggles between `Visibility::Inherited` and `Visibility::Visible`.\n If the value is `Visibility::Hidden`, it remains unaffected.", - &["_self"], - ) - .register_documented( - "toggle_visible_hidden", - |mut _self: Mut<::bevy_render::view::visibility::Visibility>| { - let output: () = { - { - let output: () = ::bevy_render::view::visibility::Visibility::toggle_visible_hidden( - &mut _self, - ) - .into(); - output - } - }; - output - }, - " Toggles between `Visibility::Visible` and `Visibility::Hidden`.\n If the value is `Visibility::Inherited`, it remains unaffected.", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::view::visibility::Visibility, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_sync_to_render_world_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::sync_world::SyncToRenderWorld, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::sync_world::SyncToRenderWorld>| { - let output: Val<::bevy_render::sync_world::SyncToRenderWorld> = { - { - let output: Val<::bevy_render::sync_world::SyncToRenderWorld> = <::bevy_render::sync_world::SyncToRenderWorld as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::sync_world::SyncToRenderWorld, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_aabb_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::primitives::Aabb, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::primitives::Aabb>| { - let output: Val<::bevy_render::primitives::Aabb> = { - { - let output: Val<::bevy_render::primitives::Aabb> = - <::bevy_render::primitives::Aabb as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_render::primitives::Aabb>, - other: Ref<::bevy_render::primitives::Aabb>| { - let output: bool = { - { - let output: bool = <::bevy_render::primitives::Aabb as ::std::cmp::PartialEq< - ::bevy_render::primitives::Aabb, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "from_min_max", - |minimum: Val<::bevy_math::Vec3>, maximum: Val<::bevy_math::Vec3>| { - let output: Val<::bevy_render::primitives::Aabb> = { - { - let output: Val<::bevy_render::primitives::Aabb> = - ::bevy_render::primitives::Aabb::from_min_max( - minimum.into_inner(), - maximum.into_inner(), - ) - .into(); - output - } - }; - output - }, - "", - &["minimum", "maximum"], - ) - .register_documented( - "max", - |_self: Ref<::bevy_render::primitives::Aabb>| { - let output: Val<::bevy_math::Vec3A> = { - { - let output: Val<::bevy_math::Vec3A> = - ::bevy_render::primitives::Aabb::max(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "min", - |_self: Ref<::bevy_render::primitives::Aabb>| { - let output: Val<::bevy_math::Vec3A> = { - { - let output: Val<::bevy_math::Vec3A> = - ::bevy_render::primitives::Aabb::min(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "relative_radius", - |_self: Ref<::bevy_render::primitives::Aabb>, - p_normal: Ref<::bevy_math::Vec3A>, - world_from_local: Ref<::bevy_math::Mat3A>| { - let output: f32 = { - { - let output: f32 = ::bevy_render::primitives::Aabb::relative_radius( - &_self, - &p_normal, - &world_from_local, - ) - .into(); - output - } - }; - output - }, - " Calculate the relative radius of the AABB with respect to a plane", - &["_self", "p_normal", "world_from_local"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::primitives::Aabb, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_cascades_frusta_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::primitives::CascadesFrusta, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::primitives::CascadesFrusta>| { - let output: Val<::bevy_render::primitives::CascadesFrusta> = { - { - let output: Val<::bevy_render::primitives::CascadesFrusta> = - <::bevy_render::primitives::CascadesFrusta as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::primitives::CascadesFrusta, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_cubemap_frusta_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::primitives::CubemapFrusta, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::primitives::CubemapFrusta>| { - let output: Val<::bevy_render::primitives::CubemapFrusta> = { - { - let output: Val<::bevy_render::primitives::CubemapFrusta> = - <::bevy_render::primitives::CubemapFrusta as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::primitives::CubemapFrusta, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_frustum_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::primitives::Frustum, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::primitives::Frustum>| { - let output: Val<::bevy_render::primitives::Frustum> = { - { - let output: Val<::bevy_render::primitives::Frustum> = <::bevy_render::primitives::Frustum as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "contains_aabb", - | - _self: Ref<::bevy_render::primitives::Frustum>, - aabb: Ref<::bevy_render::primitives::Aabb>, - world_from_local: Ref<::bevy_math::Affine3A>| - { - let output: bool = { - { - let output: bool = ::bevy_render::primitives::Frustum::contains_aabb( - &_self, - &aabb, - &world_from_local, - ) - .into(); - output - } - }; - output - }, - " Check if the frustum contains the Axis-Aligned Bounding Box (AABB).\n Referenced from: [Frustum Culling](https://learnopengl.com/Guest-Articles/2021/Scene/Frustum-Culling)", - &["_self", "aabb", "world_from_local"], - ) - .register_documented( - "from_clip_from_world", - |clip_from_world: Ref<::bevy_math::Mat4>| { - let output: Val<::bevy_render::primitives::Frustum> = { - { - let output: Val<::bevy_render::primitives::Frustum> = ::bevy_render::primitives::Frustum::from_clip_from_world( - &clip_from_world, - ) - .into(); - output - } - }; - output - }, - " Returns a frustum derived from `clip_from_world`.", - &["clip_from_world"], - ) - .register_documented( - "from_clip_from_world_custom_far", - | - clip_from_world: Ref<::bevy_math::Mat4>, - view_translation: Ref<::bevy_math::Vec3>, - view_backward: Ref<::bevy_math::Vec3>, - far: f32| - { - let output: Val<::bevy_render::primitives::Frustum> = { - { - let output: Val<::bevy_render::primitives::Frustum> = ::bevy_render::primitives::Frustum::from_clip_from_world_custom_far( - &clip_from_world, - &view_translation, - &view_backward, - far, - ) - .into(); - output - } - }; - output - }, - " Returns a frustum derived from `clip_from_world`,\n but with a custom far plane.", - &["clip_from_world", "view_translation", "view_backward", "far"], - ) - .register_documented( - "intersects_obb", - | - _self: Ref<::bevy_render::primitives::Frustum>, - aabb: Ref<::bevy_render::primitives::Aabb>, - world_from_local: Ref<::bevy_math::Affine3A>, - intersect_near: bool, - intersect_far: bool| - { - let output: bool = { - { - let output: bool = ::bevy_render::primitives::Frustum::intersects_obb( - &_self, - &aabb, - &world_from_local, - intersect_near, - intersect_far, - ) - .into(); - output - } - }; - output - }, - " Checks if an Oriented Bounding Box (obb) intersects the frustum.", - &["_self", "aabb", "world_from_local", "intersect_near", "intersect_far"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::primitives::Frustum, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_occlusion_culling_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::experimental::occlusion_culling::OcclusionCulling, - >::new(world) - .register_documented( - "clone", - | - _self: Ref< - ::bevy_render::experimental::occlusion_culling::OcclusionCulling, - >| - { - let output: Val< - ::bevy_render::experimental::occlusion_culling::OcclusionCulling, - > = { - { - let output: Val< - ::bevy_render::experimental::occlusion_culling::OcclusionCulling, - > = <::bevy_render::experimental::occlusion_culling::OcclusionCulling as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::experimental::occlusion_culling::OcclusionCulling, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_camera_render_graph_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::camera::CameraRenderGraph, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::camera::CameraRenderGraph>| { - let output: Val<::bevy_render::camera::CameraRenderGraph> = { - { - let output: Val<::bevy_render::camera::CameraRenderGraph> = - <::bevy_render::camera::CameraRenderGraph as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::camera::CameraRenderGraph, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_camera_main_texture_usages_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::camera::CameraMainTextureUsages, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::camera::CameraMainTextureUsages>| { - let output: Val<::bevy_render::camera::CameraMainTextureUsages> = { - { - let output: Val< - ::bevy_render::camera::CameraMainTextureUsages, - > = <::bevy_render::camera::CameraMainTextureUsages as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::camera::CameraMainTextureUsages, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_exposure_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::camera::Exposure, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::camera::Exposure>| { - let output: Val<::bevy_render::camera::Exposure> = { - { - let output: Val<::bevy_render::camera::Exposure> = <::bevy_render::camera::Exposure as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "exposure", - |_self: Ref<::bevy_render::camera::Exposure>| { - let output: f32 = { - { - let output: f32 = ::bevy_render::camera::Exposure::exposure( - &_self, - ) - .into(); - output - } - }; - output - }, - " Converts EV100 values to exposure values.\n ", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::camera::Exposure, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_temporal_jitter_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::camera::TemporalJitter, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::camera::TemporalJitter>| { - let output: Val<::bevy_render::camera::TemporalJitter> = { - { - let output: Val<::bevy_render::camera::TemporalJitter> = - <::bevy_render::camera::TemporalJitter as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "jitter_projection", - |_self: Ref<::bevy_render::camera::TemporalJitter>, - mut clip_from_view: Mut<::bevy_math::Mat4>, - view_size: Val<::bevy_math::Vec2>| { - let output: () = { - { - let output: () = ::bevy_render::camera::TemporalJitter::jitter_projection( - &_self, - &mut clip_from_view, - view_size.into_inner(), - ) - .into(); - output - } - }; - output - }, - "", - &["_self", "clip_from_view", "view_size"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::camera::TemporalJitter, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_mip_bias_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::camera::MipBias, - >::new(world); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::camera::MipBias, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_manual_texture_view_handle_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::camera::ManualTextureViewHandle, - >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_render::camera::ManualTextureViewHandle>| { - let output: () = { - { - let output: () = <::bevy_render::camera::ManualTextureViewHandle as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_render::camera::ManualTextureViewHandle>| { - let output: Val<::bevy_render::camera::ManualTextureViewHandle> = { - { - let output: Val< - ::bevy_render::camera::ManualTextureViewHandle, - > = <::bevy_render::camera::ManualTextureViewHandle as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_render::camera::ManualTextureViewHandle>, - other: Ref<::bevy_render::camera::ManualTextureViewHandle>| - { - let output: bool = { - { - let output: bool = <::bevy_render::camera::ManualTextureViewHandle as ::std::cmp::PartialEq< - ::bevy_render::camera::ManualTextureViewHandle, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::camera::ManualTextureViewHandle, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_color_grading_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::view::ColorGrading, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::view::ColorGrading>| { - let output: Val<::bevy_render::view::ColorGrading> = { - { - let output: Val<::bevy_render::view::ColorGrading> = <::bevy_render::view::ColorGrading as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "with_identical_sections", - | - global: Val<::bevy_render::view::ColorGradingGlobal>, - section: Val<::bevy_render::view::ColorGradingSection>| - { - let output: Val<::bevy_render::view::ColorGrading> = { - { - let output: Val<::bevy_render::view::ColorGrading> = ::bevy_render::view::ColorGrading::with_identical_sections( - global.into_inner(), - section.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Creates a new [`ColorGrading`] instance in which shadows, midtones, and\n highlights all have the same set of color grading values.", - &["global", "section"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::view::ColorGrading, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_render_layers_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::view::visibility::RenderLayers, - >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_render::view::visibility::RenderLayers>| { - let output: () = { - { - let output: () = <::bevy_render::view::visibility::RenderLayers as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_render::view::visibility::RenderLayers>| { - let output: Val<::bevy_render::view::visibility::RenderLayers> = { - { - let output: Val<::bevy_render::view::visibility::RenderLayers> = <::bevy_render::view::visibility::RenderLayers as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_render::view::visibility::RenderLayers>, - other: Ref<::bevy_render::view::visibility::RenderLayers>| - { - let output: bool = { - { - let output: bool = <::bevy_render::view::visibility::RenderLayers as ::std::cmp::PartialEq< - ::bevy_render::view::visibility::RenderLayers, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "intersection", - | - _self: Ref<::bevy_render::view::visibility::RenderLayers>, - other: Ref<::bevy_render::view::visibility::RenderLayers>| - { - let output: Val<::bevy_render::view::visibility::RenderLayers> = { - { - let output: Val<::bevy_render::view::visibility::RenderLayers> = ::bevy_render::view::visibility::RenderLayers::intersection( - &_self, - &other, - ) - .into(); - output - } - }; - output - }, - " Returns the set of [layers](Layer) shared by two instances of [`RenderLayers`].\n This corresponds to the `self & other` operation.", - &["_self", "other"], - ) - .register_documented( - "intersects", - | - _self: Ref<::bevy_render::view::visibility::RenderLayers>, - other: Ref<::bevy_render::view::visibility::RenderLayers>| - { - let output: bool = { - { - let output: bool = ::bevy_render::view::visibility::RenderLayers::intersects( - &_self, - &other, - ) - .into(); - output - } - }; - output - }, - " Determine if a `RenderLayers` intersects another.\n `RenderLayers`s intersect if they share any common layers.\n A `RenderLayers` with no layers will not match any other\n `RenderLayers`, even another with no layers.", - &["_self", "other"], - ) - .register_documented( - "layer", - |n: usize| { - let output: Val<::bevy_render::view::visibility::RenderLayers> = { - { - let output: Val<::bevy_render::view::visibility::RenderLayers> = ::bevy_render::view::visibility::RenderLayers::layer( - n, - ) - .into(); - output - } - }; - output - }, - " Create a new `RenderLayers` belonging to the given layer.\n This `const` constructor is limited to `size_of::()` layers.\n If you need to support an arbitrary number of layers, use [`with`](RenderLayers::with)\n or [`from_layers`](RenderLayers::from_layers).", - &["n"], - ) - .register_documented( - "none", - || { - let output: Val<::bevy_render::view::visibility::RenderLayers> = { - { - let output: Val<::bevy_render::view::visibility::RenderLayers> = ::bevy_render::view::visibility::RenderLayers::none() - .into(); - output - } - }; - output - }, - " Create a new `RenderLayers` that belongs to no layers.\n This is distinct from [`RenderLayers::default`], which belongs to the first layer.", - &[], - ) - .register_documented( - "symmetric_difference", - | - _self: Ref<::bevy_render::view::visibility::RenderLayers>, - other: Ref<::bevy_render::view::visibility::RenderLayers>| - { - let output: Val<::bevy_render::view::visibility::RenderLayers> = { - { - let output: Val<::bevy_render::view::visibility::RenderLayers> = ::bevy_render::view::visibility::RenderLayers::symmetric_difference( - &_self, - &other, - ) - .into(); - output - } - }; - output - }, - " Returns all [layers](Layer) included in exactly one of the instances of [`RenderLayers`].\n This corresponds to the \"exclusive or\" (XOR) operation: `self ^ other`.", - &["_self", "other"], - ) - .register_documented( - "union", - | - _self: Ref<::bevy_render::view::visibility::RenderLayers>, - other: Ref<::bevy_render::view::visibility::RenderLayers>| - { - let output: Val<::bevy_render::view::visibility::RenderLayers> = { - { - let output: Val<::bevy_render::view::visibility::RenderLayers> = ::bevy_render::view::visibility::RenderLayers::union( - &_self, - &other, - ) - .into(); - output - } - }; - output - }, - " Returns all [layers](Layer) included in either instance of [`RenderLayers`].\n This corresponds to the `self | other` operation.", - &["_self", "other"], - ) - .register_documented( - "with", - |_self: Val<::bevy_render::view::visibility::RenderLayers>, layer: usize| { - let output: Val<::bevy_render::view::visibility::RenderLayers> = { - { - let output: Val<::bevy_render::view::visibility::RenderLayers> = ::bevy_render::view::visibility::RenderLayers::with( - _self.into_inner(), - layer, - ) - .into(); - output - } - }; - output - }, - " Add the given layer.\n This may be called multiple times to allow an entity to belong\n to multiple rendering layers.", - &["_self", "layer"], - ) - .register_documented( - "without", - |_self: Val<::bevy_render::view::visibility::RenderLayers>, layer: usize| { - let output: Val<::bevy_render::view::visibility::RenderLayers> = { - { - let output: Val<::bevy_render::view::visibility::RenderLayers> = ::bevy_render::view::visibility::RenderLayers::without( - _self.into_inner(), - layer, - ) - .into(); - output - } - }; - output - }, - " Removes the given rendering layer.", - &["_self", "layer"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::view::visibility::RenderLayers, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_render_visible_entities_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::view::visibility::RenderVisibleEntities, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::view::visibility::RenderVisibleEntities>| { - let output: Val< - ::bevy_render::view::visibility::RenderVisibleEntities, - > = { - { - let output: Val< - ::bevy_render::view::visibility::RenderVisibleEntities, - > = <::bevy_render::view::visibility::RenderVisibleEntities as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::view::visibility::RenderVisibleEntities, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_visible_entities_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::view::visibility::VisibleEntities, - >::new(world) - .register_documented( - "clear", - | - mut _self: Mut<::bevy_render::view::visibility::VisibleEntities>, - type_id: Val<::std::any::TypeId>| - { - let output: () = { - { - let output: () = ::bevy_render::view::visibility::VisibleEntities::clear( - &mut _self, - type_id.into_inner(), - ) - .into(); - output - } - }; - output - }, - "", - &["_self", "type_id"], - ) - .register_documented( - "clear_all", - |mut _self: Mut<::bevy_render::view::visibility::VisibleEntities>| { - let output: () = { - { - let output: () = ::bevy_render::view::visibility::VisibleEntities::clear_all( - &mut _self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_render::view::visibility::VisibleEntities>| { - let output: Val<::bevy_render::view::visibility::VisibleEntities> = { - { - let output: Val< - ::bevy_render::view::visibility::VisibleEntities, - > = <::bevy_render::view::visibility::VisibleEntities as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "is_empty", - | - _self: Ref<::bevy_render::view::visibility::VisibleEntities>, - type_id: Val<::std::any::TypeId>| - { - let output: bool = { - { - let output: bool = ::bevy_render::view::visibility::VisibleEntities::is_empty( - &_self, - type_id.into_inner(), - ) - .into(); - output - } - }; - output - }, - "", - &["_self", "type_id"], - ) - .register_documented( - "len", - | - _self: Ref<::bevy_render::view::visibility::VisibleEntities>, - type_id: Val<::std::any::TypeId>| - { - let output: usize = { - { - let output: usize = ::bevy_render::view::visibility::VisibleEntities::len( - &_self, - type_id.into_inner(), - ) - .into(); - output - } - }; - output - }, - "", - &["_self", "type_id"], - ) - .register_documented( - "push", - | - mut _self: Mut<::bevy_render::view::visibility::VisibleEntities>, - entity: Val<::bevy_ecs::entity::Entity>, - type_id: Val<::std::any::TypeId>| - { - let output: () = { - { - let output: () = ::bevy_render::view::visibility::VisibleEntities::push( - &mut _self, - entity.into_inner(), - type_id.into_inner(), - ) - .into(); - output - } - }; - output - }, - "", - &["_self", "entity", "type_id"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::view::visibility::VisibleEntities, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_viewport_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::camera::Viewport, - >::new(world) - .register_documented( - "clamp_to_size", - | - mut _self: Mut<::bevy_render::camera::Viewport>, - size: Val<::bevy_math::UVec2>| - { - let output: () = { - { - let output: () = ::bevy_render::camera::Viewport::clamp_to_size( - &mut _self, - size.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Cut the viewport rectangle so that it lies inside a rectangle of the\n given size.\n If either of the viewport's position coordinates lies outside the given\n dimensions, it will be moved just inside first. If either of the given\n dimensions is zero, the position and size of the viewport rectangle will\n both be set to zero in that dimension.", - &["_self", "size"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_render::camera::Viewport>| { - let output: Val<::bevy_render::camera::Viewport> = { - { - let output: Val<::bevy_render::camera::Viewport> = <::bevy_render::camera::Viewport as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::camera::Viewport, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_sub_camera_view_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::camera::SubCameraView, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::camera::SubCameraView>| { - let output: Val<::bevy_render::camera::SubCameraView> = { - { - let output: Val<::bevy_render::camera::SubCameraView> = - <::bevy_render::camera::SubCameraView as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_render::camera::SubCameraView>, - other: Ref<::bevy_render::camera::SubCameraView>| { - let output: bool = { - { - let output: bool = - <::bevy_render::camera::SubCameraView as ::std::cmp::PartialEq< - ::bevy_render::camera::SubCameraView, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::camera::SubCameraView, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_render_target_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::camera::RenderTarget, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::camera::RenderTarget>| { - let output: Val<::bevy_render::camera::RenderTarget> = { - { - let output: Val<::bevy_render::camera::RenderTarget> = - <::bevy_render::camera::RenderTarget as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::camera::RenderTarget, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_image_render_target_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::camera::ImageRenderTarget, - >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_render::camera::ImageRenderTarget>| { - let output: () = { - { - let output: () = <::bevy_render::camera::ImageRenderTarget as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_render::camera::ImageRenderTarget>| { - let output: Val<::bevy_render::camera::ImageRenderTarget> = { - { - let output: Val<::bevy_render::camera::ImageRenderTarget> = <::bevy_render::camera::ImageRenderTarget as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_render::camera::ImageRenderTarget>, - other: Ref<::bevy_render::camera::ImageRenderTarget>| - { - let output: bool = { - { - let output: bool = <::bevy_render::camera::ImageRenderTarget as ::std::cmp::PartialEq< - ::bevy_render::camera::ImageRenderTarget, + let output: bool = <::bevy_render::view::Hdr as ::std::cmp::PartialEq< + ::bevy_render::view::Hdr, >>::eq(&_self, &other) .into(); output @@ -2090,59 +497,26 @@ pub(crate) fn register_image_render_target_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_render::camera::ImageRenderTarget, + ::bevy_render::view::Hdr, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_normalized_render_target_functions(world: &mut World) { +pub(crate) fn register_render_visible_entities_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::camera::NormalizedRenderTarget, + ::bevy_render::view::visibility::RenderVisibleEntities, >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_render::camera::NormalizedRenderTarget>| { - let output: () = { - { - let output: () = <::bevy_render::camera::NormalizedRenderTarget as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) .register_documented( "clone", - |_self: Ref<::bevy_render::camera::NormalizedRenderTarget>| { - let output: Val<::bevy_render::camera::NormalizedRenderTarget> = { - { - let output: Val<::bevy_render::camera::NormalizedRenderTarget> = <::bevy_render::camera::NormalizedRenderTarget as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_render::camera::NormalizedRenderTarget>, - other: Ref<::bevy_render::camera::NormalizedRenderTarget>| - { - let output: bool = { + |_self: Ref<::bevy_render::view::visibility::RenderVisibleEntities>| { + let output: Val< + ::bevy_render::view::visibility::RenderVisibleEntities, + > = { { - let output: bool = <::bevy_render::camera::NormalizedRenderTarget as ::std::cmp::PartialEq< - ::bevy_render::camera::NormalizedRenderTarget, - >>::eq(&_self, &other) + let output: Val< + ::bevy_render::view::visibility::RenderVisibleEntities, + > = <::bevy_render::view::visibility::RenderVisibleEntities as ::std::clone::Clone>::clone( + &_self, + ) .into(); output } @@ -2150,27 +524,57 @@ pub(crate) fn register_normalized_render_target_functions(world: &mut World) { output }, "", - &["_self", "other"], + &["_self"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_render::camera::NormalizedRenderTarget, + ::bevy_render::view::visibility::RenderVisibleEntities, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_camera_render_graph_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_render::camera::CameraRenderGraph, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_render::camera::CameraRenderGraph>| { + let output: Val<::bevy_render::camera::CameraRenderGraph> = { + { + let output: Val<::bevy_render::camera::CameraRenderGraph> = + <::bevy_render::camera::CameraRenderGraph as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_render::camera::CameraRenderGraph, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_custom_projection_functions(world: &mut World) { +pub(crate) fn register_temporal_jitter_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::camera::CustomProjection, + ::bevy_render::camera::TemporalJitter, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_render::camera::CustomProjection>| { - let output: Val<::bevy_render::camera::CustomProjection> = { + |_self: Ref<::bevy_render::camera::TemporalJitter>| { + let output: Val<::bevy_render::camera::TemporalJitter> = { { - let output: Val<::bevy_render::camera::CustomProjection> = - <::bevy_render::camera::CustomProjection as ::std::clone::Clone>::clone( + let output: Val<::bevy_render::camera::TemporalJitter> = + <::bevy_render::camera::TemporalJitter as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -2181,26 +585,47 @@ pub(crate) fn register_custom_projection_functions(world: &mut World) { }, "", &["_self"], + ) + .register_documented( + "jitter_projection", + |_self: Ref<::bevy_render::camera::TemporalJitter>, + mut clip_from_view: Mut<::bevy_math::Mat4>, + view_size: Val<::bevy_math::Vec2>| { + let output: () = { + { + let output: () = ::bevy_render::camera::TemporalJitter::jitter_projection( + &_self, + &mut clip_from_view, + view_size.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "clip_from_view", "view_size"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_render::camera::CustomProjection, + ::bevy_render::camera::TemporalJitter, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_scaling_mode_functions(world: &mut World) { +pub(crate) fn register_mip_bias_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::camera::ScalingMode, + ::bevy_render::camera::MipBias, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_render::camera::ScalingMode>| { - let output: Val<::bevy_render::camera::ScalingMode> = { + |_self: Ref<::bevy_render::camera::MipBias>| { + let output: Val<::bevy_render::camera::MipBias> = { { - let output: Val<::bevy_render::camera::ScalingMode> = - <::bevy_render::camera::ScalingMode as ::std::clone::Clone>::clone(&_self) + let output: Val<::bevy_render::camera::MipBias> = + <::bevy_render::camera::MipBias as ::std::clone::Clone>::clone(&_self) .into(); output } @@ -2214,7 +639,7 @@ pub(crate) fn register_scaling_mode_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_render::camera::ScalingMode, + ::bevy_render::camera::MipBias, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -2271,10 +696,7 @@ pub(crate) fn register_shader_storage_buffer_functions(world: &mut World) { ) .register_documented( "with_size", - | - size: usize, - asset_usage: Val<::bevy_render::render_asset::RenderAssetUsages>| - { + |size: usize, asset_usage: Val<::bevy_asset::RenderAssetUsages>| { let output: Val<::bevy_render::storage::ShaderStorageBuffer> = { { let output: Val<::bevy_render::storage::ShaderStorageBuffer> = ::bevy_render::storage::ShaderStorageBuffer::with_size( @@ -2310,103 +732,6 @@ pub(crate) fn register_readback_complete_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_mesh_tag_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::mesh::MeshTag, - >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_render::mesh::MeshTag>| { - let output: () = { - { - let output: () = <::bevy_render::mesh::MeshTag as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_render::mesh::MeshTag>| { - let output: Val<::bevy_render::mesh::MeshTag> = { - { - let output: Val<::bevy_render::mesh::MeshTag> = <::bevy_render::mesh::MeshTag as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_render::mesh::MeshTag>, - other: Ref<::bevy_render::mesh::MeshTag>| - { - let output: bool = { - { - let output: bool = <::bevy_render::mesh::MeshTag as ::std::cmp::PartialEq< - ::bevy_render::mesh::MeshTag, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::mesh::MeshTag, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_visibility_class_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::view::visibility::VisibilityClass, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::view::visibility::VisibilityClass>| { - let output: Val<::bevy_render::view::visibility::VisibilityClass> = { - { - let output: Val< - ::bevy_render::view::visibility::VisibilityClass, - > = <::bevy_render::view::visibility::VisibilityClass as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::view::visibility::VisibilityClass, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} pub(crate) fn register_temporary_render_entity_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_render::sync_world::TemporaryRenderEntity, @@ -2438,18 +763,6 @@ pub(crate) fn register_temporary_render_entity_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_no_frustum_culling_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::view::visibility::NoFrustumCulling, - >::new(world); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::view::visibility::NoFrustumCulling, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} pub(crate) fn register_color_grading_global_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_render::view::ColorGradingGlobal, @@ -2529,136 +842,6 @@ pub(crate) fn register_color_grading_section_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_visibility_range_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::view::visibility::VisibilityRange, - >::new(world) - .register_documented( - "abrupt", - |start: f32, end: f32| { - let output: Val<::bevy_render::view::visibility::VisibilityRange> = { - { - let output: Val< - ::bevy_render::view::visibility::VisibilityRange, - > = ::bevy_render::view::visibility::VisibilityRange::abrupt( - start, - end, - ) - .into(); - output - } - }; - output - }, - " Creates a new *abrupt* visibility range, with no crossfade.\n There will be no crossfade; the object will immediately vanish if the\n camera is closer than `start` units or farther than `end` units from the\n model.\n The `start` value must be less than or equal to the `end` value.", - &["start", "end"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_render::view::visibility::VisibilityRange>| { - let output: Val<::bevy_render::view::visibility::VisibilityRange> = { - { - let output: Val< - ::bevy_render::view::visibility::VisibilityRange, - > = <::bevy_render::view::visibility::VisibilityRange as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_render::view::visibility::VisibilityRange>, - other: Ref<::bevy_render::view::visibility::VisibilityRange>| - { - let output: bool = { - { - let output: bool = <::bevy_render::view::visibility::VisibilityRange as ::std::cmp::PartialEq< - ::bevy_render::view::visibility::VisibilityRange, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "is_abrupt", - |_self: Ref<::bevy_render::view::visibility::VisibilityRange>| { - let output: bool = { - { - let output: bool = ::bevy_render::view::visibility::VisibilityRange::is_abrupt( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns true if both the start and end transitions for this range are\n abrupt: that is, there is no crossfading.", - &["_self"], - ) - .register_documented( - "is_culled", - | - _self: Ref<::bevy_render::view::visibility::VisibilityRange>, - camera_distance: f32| - { - let output: bool = { - { - let output: bool = ::bevy_render::view::visibility::VisibilityRange::is_culled( - &_self, - camera_distance, - ) - .into(); - output - } - }; - output - }, - " Returns true if the object is completely invisible, given a camera\n `camera_distance` units away.\n This is equivalent to `!VisibilityRange::is_visible_at_all()`.", - &["_self", "camera_distance"], - ) - .register_documented( - "is_visible_at_all", - | - _self: Ref<::bevy_render::view::visibility::VisibilityRange>, - camera_distance: f32| - { - let output: bool = { - { - let output: bool = ::bevy_render::view::visibility::VisibilityRange::is_visible_at_all( - &_self, - camera_distance, - ) - .into(); - output - } - }; - output - }, - " Returns true if the object will be visible at all, given a camera\n `camera_distance` units away.\n Any amount of visibility, even with the heaviest dithering applied, is\n considered visible according to this check.", - &["_self", "camera_distance"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_render::view::visibility::VisibilityRange, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} pub(crate) fn register_screenshot_captured_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_render::view::window::screenshot::ScreenshotCaptured, @@ -2693,7 +876,7 @@ pub(crate) fn register_screenshot_functions(world: &mut World) { ) .register_documented( "texture_view", - |texture_view: Val<::bevy_render::camera::ManualTextureViewHandle>| { + |texture_view: Val<::bevy_camera::ManualTextureViewHandle>| { let output: Val<::bevy_render::view::window::screenshot::Screenshot> = { { let output: Val<::bevy_render::view::window::screenshot::Screenshot> = @@ -2739,51 +922,23 @@ impl Plugin for BevyRenderScriptingPlugin { fn build(&self, app: &mut App) { let mut world = app.world_mut(); register_alpha_mode_functions(&mut world); - register_camera_functions(&mut world); - register_clear_color_functions(&mut world); - register_clear_color_config_functions(&mut world); - register_orthographic_projection_functions(&mut world); - register_perspective_projection_functions(&mut world); - register_projection_functions(&mut world); - register_mesh_2_d_functions(&mut world); - register_mesh_3_d_functions(&mut world); - register_inherited_visibility_functions(&mut world); register_msaa_functions(&mut world); - register_view_visibility_functions(&mut world); - register_visibility_functions(&mut world); - register_sync_to_render_world_functions(&mut world); - register_aabb_functions(&mut world); - register_cascades_frusta_functions(&mut world); - register_cubemap_frusta_functions(&mut world); - register_frustum_functions(&mut world); + register_main_entity_functions(&mut world); register_occlusion_culling_functions(&mut world); + register_render_entity_functions(&mut world); + register_sync_to_render_world_functions(&mut world); + register_color_grading_functions(&mut world); + register_hdr_functions(&mut world); + register_render_visible_entities_functions(&mut world); register_camera_render_graph_functions(&mut world); - register_camera_main_texture_usages_functions(&mut world); - register_exposure_functions(&mut world); register_temporal_jitter_functions(&mut world); register_mip_bias_functions(&mut world); - register_manual_texture_view_handle_functions(&mut world); - register_color_grading_functions(&mut world); - register_render_layers_functions(&mut world); - register_render_visible_entities_functions(&mut world); - register_visible_entities_functions(&mut world); - register_viewport_functions(&mut world); - register_sub_camera_view_functions(&mut world); - register_render_target_functions(&mut world); - register_image_render_target_functions(&mut world); - register_normalized_render_target_functions(&mut world); - register_custom_projection_functions(&mut world); - register_scaling_mode_functions(&mut world); register_globals_uniform_functions(&mut world); register_shader_storage_buffer_functions(&mut world); register_readback_complete_functions(&mut world); - register_mesh_tag_functions(&mut world); - register_visibility_class_functions(&mut world); register_temporary_render_entity_functions(&mut world); - register_no_frustum_culling_functions(&mut world); register_color_grading_global_functions(&mut world); register_color_grading_section_functions(&mut world); - register_visibility_range_functions(&mut world); register_screenshot_captured_functions(&mut world); register_screenshot_functions(&mut world); } diff --git a/crates/bindings/bevy_scene_bms_bindings/Cargo.toml b/crates/bindings/bevy_scene_bms_bindings/Cargo.toml index 257402def5..334a1766ff 100644 --- a/crates/bindings/bevy_scene_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_scene_bms_bindings/Cargo.toml @@ -17,37 +17,29 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_scene = { version = "0.16.1", features = [ - "bevy_render", - "serialize", -], default-features = true } +bevy_scene = { version = "0.17.2", features = ["serialize"], default-features = true} -bevy_app = { version = "^0.16.1", features = [], default-features = true } +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} -bevy_asset = { version = "^0.16.1", features = [], default-features = true } +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} -bevy_derive = { version = "^0.16.1", features = [], default-features = true } +bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.16.1", features = [ - "serialize", -], default-features = false } +bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_platform = { version = "^0.16.1", features = [ - "serialize", -], default-features = false } +bevy_ecs = { version = "^0.17.2", features = ["serialize", "std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace"], default-features = true} -bevy_reflect = { version = "^0.16.1", features = [], default-features = true } +bevy_platform = { version = "^0.17.2", features = ["serialize", "alloc", "std"], default-features = true} -bevy_render = { version = "^0.16.1", features = [], default-features = true } +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_transform = { version = "^0.16.1", features = [], default-features = true } +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.16.1", features = [], default-features = true } +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} + +serde = { version = "^1.0", features = [], default-features = true} + +uuid = { version = "^1.13.1", features = ["serde", "serde"], default-features = false} -serde = { version = "^1.0", features = [], default-features = true } -uuid = { version = "^1.13.1", features = [ - "serde", - "serde", -], default-features = false } diff --git a/crates/bindings/bevy_sprite_bms_bindings/Cargo.toml b/crates/bindings/bevy_sprite_bms_bindings/Cargo.toml index 5df1ed4c40..6603309374 100644 --- a/crates/bindings/bevy_sprite_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_sprite_bms_bindings/Cargo.toml @@ -17,49 +17,37 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_sprite = { version = "0.16.1", features = [ - "bevy_picking", - "bevy_window", - "bevy_sprite_picking_backend", - "webgl", -], default-features = true } +bevy_sprite = { version = "0.17.2", features = ["bevy_picking", "bevy_window", "bevy_sprite_picking_backend", "bevy_text"], default-features = true} -bevy_app = { version = "^0.16.1", features = [], default-features = true } +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} -bevy_asset = { version = "^0.16.1", features = [], default-features = true } +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} -bevy_color = { version = "^0.16.2", features = [], default-features = true } +bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_core_pipeline = { version = "^0.16.1", features = [ -], default-features = true } +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} -bevy_derive = { version = "^0.16.1", features = [], default-features = true } +bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.16.1", features = [], default-features = true } +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_image = { version = "^0.16.1", features = [], default-features = true } +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} -bevy_math = { version = "^0.16.1", features = [], default-features = true } +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} -bevy_picking = { version = "^0.16.1", features = [], default-features = true } +bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.16.1", features = [], default-features = true } +bevy_picking = { version = "^0.17.2", features = ["bevy_mesh_picking_backend"], default-features = true} -bevy_render = { version = "^0.16.1", features = [], default-features = true } +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_transform = { version = "^0.16.1", features = [], default-features = true } +bevy_text = { version = "^0.17.2", features = ["default_font"], default-features = true} -bevy_utils = { version = "^0.16.1", features = [], default-features = true } +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_window = { version = "^0.16.1", features = [], default-features = true } +bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} -bitflags = { version = "^2.3", features = [], default-features = true } +radsort = { version = "^0.1", features = [], default-features = true} -bytemuck = { version = "^1", features = [], default-features = true } -fixedbitset = { version = "^0.5", features = [], default-features = true } - -nonmax = { version = "^0.5", features = [], default-features = true } - -radsort = { version = "^0.1", features = [], default-features = true } diff --git a/crates/bindings/bevy_sprite_bms_bindings/src/lib.rs b/crates/bindings/bevy_sprite_bms_bindings/src/lib.rs index 2595f269c4..f47b492175 100644 --- a/crates/bindings/bevy_sprite_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_sprite_bms_bindings/src/lib.rs @@ -83,6 +83,34 @@ pub(crate) fn register_sprite_picking_settings_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } +pub(crate) fn register_text_2_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_sprite::prelude::Text2d, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_sprite::prelude::Text2d>| { + let output: Val<::bevy_sprite::prelude::Text2d> = { + { + let output: Val<::bevy_sprite::prelude::Text2d> = + <::bevy_sprite::prelude::Text2d as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_sprite::prelude::Text2d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} pub(crate) fn register_sprite_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_sprite::prelude::Sprite, @@ -196,6 +224,26 @@ pub(crate) fn register_border_rect_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_sprite::prelude::BorderRect, >::new(world) + .register_documented( + "add", + | + _self: Val<::bevy_sprite::prelude::BorderRect>, + rhs: Val<::bevy_sprite::prelude::BorderRect>| + { + let output: Val<::bevy_sprite::prelude::BorderRect> = { + { + let output: Val<::bevy_sprite::prelude::BorderRect> = <::bevy_sprite::prelude::BorderRect as ::std::ops::Add< + ::bevy_sprite::prelude::BorderRect, + >>::add(_self.into_inner(), rhs.into_inner()) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "all", |extent: f32| { @@ -248,6 +296,23 @@ pub(crate) fn register_border_rect_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "div", + |_self: Val<::bevy_sprite::prelude::BorderRect>, rhs: f32| { + let output: Val<::bevy_sprite::prelude::BorderRect> = { + { + let output: Val<::bevy_sprite::prelude::BorderRect> = <::bevy_sprite::prelude::BorderRect as ::std::ops::Div< + f32, + >>::div(_self.into_inner(), rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "eq", | @@ -267,6 +332,43 @@ pub(crate) fn register_border_rect_functions(world: &mut World) { }, "", &["_self", "other"], + ) + .register_documented( + "mul", + |_self: Val<::bevy_sprite::prelude::BorderRect>, rhs: f32| { + let output: Val<::bevy_sprite::prelude::BorderRect> = { + { + let output: Val<::bevy_sprite::prelude::BorderRect> = <::bevy_sprite::prelude::BorderRect as ::std::ops::Mul< + f32, + >>::mul(_self.into_inner(), rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "sub", + | + _self: Val<::bevy_sprite::prelude::BorderRect>, + rhs: Val<::bevy_sprite::prelude::BorderRect>| + { + let output: Val<::bevy_sprite::prelude::BorderRect> = { + { + let output: Val<::bevy_sprite::prelude::BorderRect> = <::bevy_sprite::prelude::BorderRect as ::std::ops::Sub< + ::bevy_sprite::prelude::BorderRect, + >>::sub(_self.into_inner(), rhs.into_inner()) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -374,36 +476,6 @@ pub(crate) fn register_texture_slicer_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_color_material_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_sprite::prelude::ColorMaterial, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_sprite::prelude::ColorMaterial>| { - let output: Val<::bevy_sprite::prelude::ColorMaterial> = { - { - let output: Val<::bevy_sprite::prelude::ColorMaterial> = - <::bevy_sprite::prelude::ColorMaterial as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_sprite::prelude::ColorMaterial, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} pub(crate) fn register_scaling_mode_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_sprite::prelude::ScalingMode, @@ -512,298 +584,16 @@ pub(crate) fn register_anchor_functions(world: &mut World) { .register_type_data::<::bevy_sprite::Anchor, bevy_mod_scripting_bindings::MarkAsGenerated>( ); } -pub(crate) fn register_alpha_mode_2_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_sprite::AlphaMode2d, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_sprite::AlphaMode2d>| { - let output: Val<::bevy_sprite::AlphaMode2d> = { - { - let output: Val<::bevy_sprite::AlphaMode2d> = <::bevy_sprite::AlphaMode2d as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_sprite::AlphaMode2d>, - other: Ref<::bevy_sprite::AlphaMode2d>| - { - let output: bool = { - { - let output: bool = <::bevy_sprite::AlphaMode2d as ::std::cmp::PartialEq< - ::bevy_sprite::AlphaMode2d, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_sprite::AlphaMode2d, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_wireframe_2_d_material_functions(world: &mut World) { +pub(crate) fn register_text_2_d_shadow_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_sprite::Wireframe2dMaterial, + ::bevy_sprite::Text2dShadow, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_sprite::Wireframe2dMaterial>| { - let output: Val<::bevy_sprite::Wireframe2dMaterial> = { - { - let output: Val<::bevy_sprite::Wireframe2dMaterial> = - <::bevy_sprite::Wireframe2dMaterial as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_sprite::Wireframe2dMaterial, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_no_wireframe_2_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_sprite::NoWireframe2d, - >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_sprite::NoWireframe2d>| { - let output: () = { - { - let output: () = <::bevy_sprite::NoWireframe2d as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_sprite::NoWireframe2d>| { - let output: Val<::bevy_sprite::NoWireframe2d> = { - { - let output: Val<::bevy_sprite::NoWireframe2d> = <::bevy_sprite::NoWireframe2d as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_sprite::NoWireframe2d>, - other: Ref<::bevy_sprite::NoWireframe2d>| - { - let output: bool = { - { - let output: bool = <::bevy_sprite::NoWireframe2d as ::std::cmp::PartialEq< - ::bevy_sprite::NoWireframe2d, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_sprite::NoWireframe2d, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_wireframe_2_d_config_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_sprite::Wireframe2dConfig, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_sprite::Wireframe2dConfig>| { - let output: Val<::bevy_sprite::Wireframe2dConfig> = { - { - let output: Val<::bevy_sprite::Wireframe2dConfig> = - <::bevy_sprite::Wireframe2dConfig as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_sprite::Wireframe2dConfig, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_wireframe_2_d_color_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_sprite::Wireframe2dColor, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_sprite::Wireframe2dColor>| { - let output: Val<::bevy_sprite::Wireframe2dColor> = { - { - let output: Val<::bevy_sprite::Wireframe2dColor> = - <::bevy_sprite::Wireframe2dColor as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_sprite::Wireframe2dColor, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_wireframe_2_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_sprite::Wireframe2d, - >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_sprite::Wireframe2d>| { - let output: () = { - { - let output: () = <::bevy_sprite::Wireframe2d as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_sprite::Wireframe2d>| { - let output: Val<::bevy_sprite::Wireframe2d> = { - { - let output: Val<::bevy_sprite::Wireframe2d> = <::bevy_sprite::Wireframe2d as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_sprite::Wireframe2d>, - other: Ref<::bevy_sprite::Wireframe2d>| - { - let output: bool = { - { - let output: bool = <::bevy_sprite::Wireframe2d as ::std::cmp::PartialEq< - ::bevy_sprite::Wireframe2d, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_sprite::Wireframe2d, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_mesh_2_d_wireframe_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_sprite::Mesh2dWireframe, - >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_sprite::Mesh2dWireframe>| { - let output: () = { - { - let output: () = <::bevy_sprite::Mesh2dWireframe as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) .register_documented( "clone", - |_self: Ref<::bevy_sprite::Mesh2dWireframe>| { - let output: Val<::bevy_sprite::Mesh2dWireframe> = { + |_self: Ref<::bevy_sprite::Text2dShadow>| { + let output: Val<::bevy_sprite::Text2dShadow> = { { - let output: Val<::bevy_sprite::Mesh2dWireframe> = <::bevy_sprite::Mesh2dWireframe as ::std::clone::Clone>::clone( + let output: Val<::bevy_sprite::Text2dShadow> = <::bevy_sprite::Text2dShadow as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -818,13 +608,13 @@ pub(crate) fn register_mesh_2_d_wireframe_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_sprite::Mesh2dWireframe>, - other: Ref<::bevy_sprite::Mesh2dWireframe>| + _self: Ref<::bevy_sprite::Text2dShadow>, + other: Ref<::bevy_sprite::Text2dShadow>| { let output: bool = { { - let output: bool = <::bevy_sprite::Mesh2dWireframe as ::std::cmp::PartialEq< - ::bevy_sprite::Mesh2dWireframe, + let output: bool = <::bevy_sprite::Text2dShadow as ::std::cmp::PartialEq< + ::bevy_sprite::Text2dShadow, >>::eq(&_self, &other) .into(); output @@ -839,7 +629,7 @@ pub(crate) fn register_mesh_2_d_wireframe_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_sprite::Mesh2dWireframe, + ::bevy_sprite::Text2dShadow, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -849,20 +639,14 @@ impl Plugin for BevySpriteScriptingPlugin { register_sprite_picking_camera_functions(&mut world); register_sprite_picking_mode_functions(&mut world); register_sprite_picking_settings_functions(&mut world); + register_text_2_d_functions(&mut world); register_sprite_functions(&mut world); register_sprite_image_mode_functions(&mut world); register_border_rect_functions(&mut world); register_slice_scale_mode_functions(&mut world); register_texture_slicer_functions(&mut world); - register_color_material_functions(&mut world); register_scaling_mode_functions(&mut world); register_anchor_functions(&mut world); - register_alpha_mode_2_d_functions(&mut world); - register_wireframe_2_d_material_functions(&mut world); - register_no_wireframe_2_d_functions(&mut world); - register_wireframe_2_d_config_functions(&mut world); - register_wireframe_2_d_color_functions(&mut world); - register_wireframe_2_d_functions(&mut world); - register_mesh_2_d_wireframe_functions(&mut world); + register_text_2_d_shadow_functions(&mut world); } } diff --git a/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml b/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml new file mode 100644 index 0000000000..c037728a5f --- /dev/null +++ b/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml @@ -0,0 +1,65 @@ +[package] +name = "bevy_sprite_render_bms_bindings" +description = "Automatically generated bindings for bevy_sprite_render crate" +readme = "README.md" +version.workspace = true +edition.workspace = true +authors.workspace = true +license.workspace = true +homepage.workspace = true +repository.workspace = true +keywords.workspace = true +categories.workspace = true + +[dependencies] + + +bevy_mod_scripting_core = { workspace = true } +bevy_mod_scripting_bindings = { workspace = true } +bevy_mod_scripting_derive = { workspace = true } +bevy_sprite_render = { version = "0.17.2", features = ["bevy_text", "webgl"], default-features = true} + + +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} + +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} + +bevy_camera = { version = "^0.17.2", features = [], default-features = true} + +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} + +bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} + +bevy_derive = { version = "^0.17.2", features = [], default-features = true} + +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} + +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} + +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} + +bevy_mesh = { version = "^0.17.2", features = [], default-features = true} + +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} + +bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} + +bevy_shader = { version = "^0.17.2", features = [], default-features = true} + +bevy_sprite = { version = "^0.17.2", features = ["bevy_text", "bevy_picking", "bevy_window", "bevy_sprite_picking_backend"], default-features = true} + +bevy_text = { version = "^0.17.2", features = ["default_font"], default-features = true} + +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} + +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} + +bitflags = { version = "^2.3", features = [], default-features = true} + +bytemuck = { version = "^1", features = [], default-features = true} + +fixedbitset = { version = "^0.5", features = [], default-features = true} + +nonmax = { version = "^0.5", features = [], default-features = true} + + diff --git a/crates/bindings/bevy_sprite_render_bms_bindings/README.md b/crates/bindings/bevy_sprite_render_bms_bindings/README.md new file mode 100644 index 0000000000..034c4fe8e2 --- /dev/null +++ b/crates/bindings/bevy_sprite_render_bms_bindings/README.md @@ -0,0 +1,4 @@ +# bevy_sprite_render bindings +This crate is part of the [bevy_mod_scripting](http://github.com/makspll/bevy_mod_scripting) project. + +The code inside is fully generated via a custom rustc plugin. \ No newline at end of file diff --git a/crates/bindings/bevy_sprite_render_bms_bindings/src/lib.rs b/crates/bindings/bevy_sprite_render_bms_bindings/src/lib.rs new file mode 100644 index 0000000000..1886204657 --- /dev/null +++ b/crates/bindings/bevy_sprite_render_bms_bindings/src/lib.rs @@ -0,0 +1,527 @@ +#![allow(clippy::all)] +#![allow(unused, deprecated, dead_code)] + +use bevy_app::{App, Plugin}; +use bevy_ecs::prelude::*; +use bevy_mod_scripting_bindings::{ + ReflectReference, + function::{ + from::{Mut, Ref, Val}, + namespace::NamespaceBuilder, + }, +}; +use bevy_mod_scripting_derive::script_bindings; +pub struct BevySpriteRenderScriptingPlugin; +pub(crate) fn register_color_material_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_sprite_render::prelude::ColorMaterial, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_sprite_render::prelude::ColorMaterial>| { + let output: Val<::bevy_sprite_render::prelude::ColorMaterial> = { + { + let output: Val<::bevy_sprite_render::prelude::ColorMaterial> = <::bevy_sprite_render::prelude::ColorMaterial as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_sprite_render::prelude::ColorMaterial, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_alpha_mode_2_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_sprite_render::AlphaMode2d, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_sprite_render::AlphaMode2d>| { + let output: Val<::bevy_sprite_render::AlphaMode2d> = { + { + let output: Val<::bevy_sprite_render::AlphaMode2d> = + <::bevy_sprite_render::AlphaMode2d as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_sprite_render::AlphaMode2d>, + other: Ref<::bevy_sprite_render::AlphaMode2d>| { + let output: bool = { + { + let output: bool = + <::bevy_sprite_render::AlphaMode2d as ::std::cmp::PartialEq< + ::bevy_sprite_render::AlphaMode2d, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_sprite_render::AlphaMode2d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_wireframe_2_d_material_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_sprite_render::Wireframe2dMaterial, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_sprite_render::Wireframe2dMaterial>| { + let output: Val<::bevy_sprite_render::Wireframe2dMaterial> = { + { + let output: Val<::bevy_sprite_render::Wireframe2dMaterial> = + <::bevy_sprite_render::Wireframe2dMaterial as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_sprite_render::Wireframe2dMaterial, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_wireframe_2_d_config_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_sprite_render::Wireframe2dConfig, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_sprite_render::Wireframe2dConfig>| { + let output: Val<::bevy_sprite_render::Wireframe2dConfig> = { + { + let output: Val<::bevy_sprite_render::Wireframe2dConfig> = + <::bevy_sprite_render::Wireframe2dConfig as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_sprite_render::Wireframe2dConfig, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_wireframe_2_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_sprite_render::Wireframe2d, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_sprite_render::Wireframe2d>| { + let output: () = { + { + let output: () = <::bevy_sprite_render::Wireframe2d as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_sprite_render::Wireframe2d>| { + let output: Val<::bevy_sprite_render::Wireframe2d> = { + { + let output: Val<::bevy_sprite_render::Wireframe2d> = <::bevy_sprite_render::Wireframe2d as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_sprite_render::Wireframe2d>, + other: Ref<::bevy_sprite_render::Wireframe2d>| + { + let output: bool = { + { + let output: bool = <::bevy_sprite_render::Wireframe2d as ::std::cmp::PartialEq< + ::bevy_sprite_render::Wireframe2d, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_sprite_render::Wireframe2d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_wireframe_2_d_color_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_sprite_render::Wireframe2dColor, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_sprite_render::Wireframe2dColor>| { + let output: Val<::bevy_sprite_render::Wireframe2dColor> = { + { + let output: Val<::bevy_sprite_render::Wireframe2dColor> = + <::bevy_sprite_render::Wireframe2dColor as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_sprite_render::Wireframe2dColor, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_no_wireframe_2_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_sprite_render::NoWireframe2d, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_sprite_render::NoWireframe2d>| { + let output: () = { + { + let output: () = <::bevy_sprite_render::NoWireframe2d as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_sprite_render::NoWireframe2d>| { + let output: Val<::bevy_sprite_render::NoWireframe2d> = { + { + let output: Val<::bevy_sprite_render::NoWireframe2d> = <::bevy_sprite_render::NoWireframe2d as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_sprite_render::NoWireframe2d>, + other: Ref<::bevy_sprite_render::NoWireframe2d>| + { + let output: bool = { + { + let output: bool = <::bevy_sprite_render::NoWireframe2d as ::std::cmp::PartialEq< + ::bevy_sprite_render::NoWireframe2d, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_sprite_render::NoWireframe2d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_mesh_2_d_wireframe_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_sprite_render::Mesh2dWireframe, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_sprite_render::Mesh2dWireframe>| { + let output: () = { + { + let output: () = <::bevy_sprite_render::Mesh2dWireframe as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_sprite_render::Mesh2dWireframe>| { + let output: Val<::bevy_sprite_render::Mesh2dWireframe> = { + { + let output: Val<::bevy_sprite_render::Mesh2dWireframe> = <::bevy_sprite_render::Mesh2dWireframe as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_sprite_render::Mesh2dWireframe>, + other: Ref<::bevy_sprite_render::Mesh2dWireframe>| + { + let output: bool = { + { + let output: bool = <::bevy_sprite_render::Mesh2dWireframe as ::std::cmp::PartialEq< + ::bevy_sprite_render::Mesh2dWireframe, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_sprite_render::Mesh2dWireframe, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_tilemap_chunk_mesh_cache_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_sprite_render::TilemapChunkMeshCache, + >::new(world); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_sprite_render::TilemapChunkMeshCache, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_tilemap_chunk_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_sprite_render::TilemapChunk, + >::new(world) + .register_documented( + "calculate_tile_transform", + |_self: Ref<::bevy_sprite_render::TilemapChunk>, position: Val<::bevy_math::UVec2>| { + let output: Val<::bevy_transform::components::Transform> = { + { + let output: Val<::bevy_transform::components::Transform> = + ::bevy_sprite_render::TilemapChunk::calculate_tile_transform( + &_self, + position.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "position"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_sprite_render::TilemapChunk>| { + let output: Val<::bevy_sprite_render::TilemapChunk> = { + { + let output: Val<::bevy_sprite_render::TilemapChunk> = + <::bevy_sprite_render::TilemapChunk as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_sprite_render::TilemapChunk, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_tile_data_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_sprite_render::TileData, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_sprite_render::TileData>| { + let output: Val<::bevy_sprite_render::TileData> = { + { + let output: Val<::bevy_sprite_render::TileData> = + <::bevy_sprite_render::TileData as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "from_tileset_index", + |tileset_index: u16| { + let output: Val<::bevy_sprite_render::TileData> = { + { + let output: Val<::bevy_sprite_render::TileData> = + ::bevy_sprite_render::TileData::from_tileset_index(tileset_index).into(); + output + } + }; + output + }, + " Creates a new `TileData` with the given tileset index and default values.", + &["tileset_index"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_sprite_render::TileData, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_tilemap_chunk_tile_data_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_sprite_render::TilemapChunkTileData, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_sprite_render::TilemapChunkTileData>| { + let output: Val<::bevy_sprite_render::TilemapChunkTileData> = { + { + let output: Val<::bevy_sprite_render::TilemapChunkTileData> = + <::bevy_sprite_render::TilemapChunkTileData as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_sprite_render::TilemapChunkTileData, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +impl Plugin for BevySpriteRenderScriptingPlugin { + fn build(&self, app: &mut App) { + let mut world = app.world_mut(); + register_color_material_functions(&mut world); + register_alpha_mode_2_d_functions(&mut world); + register_wireframe_2_d_material_functions(&mut world); + register_wireframe_2_d_config_functions(&mut world); + register_wireframe_2_d_functions(&mut world); + register_wireframe_2_d_color_functions(&mut world); + register_no_wireframe_2_d_functions(&mut world); + register_mesh_2_d_wireframe_functions(&mut world); + register_tilemap_chunk_mesh_cache_functions(&mut world); + register_tilemap_chunk_functions(&mut world); + register_tile_data_functions(&mut world); + register_tilemap_chunk_tile_data_functions(&mut world); + } +} diff --git a/crates/bindings/bevy_text_bms_bindings/Cargo.toml b/crates/bindings/bevy_text_bms_bindings/Cargo.toml index af777c7000..1fab9a0ad3 100644 --- a/crates/bindings/bevy_text_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_text_bms_bindings/Cargo.toml @@ -17,45 +17,33 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_text = { version = "0.16.1", features = [ - "default_font", -], default-features = true } +bevy_text = { version = "0.17.2", features = ["default_font"], default-features = true} -bevy_app = { version = "^0.16.1", features = [], default-features = true } +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} -bevy_asset = { version = "^0.16.1", features = [], default-features = true } +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} -bevy_color = { version = "^0.16.2", features = [], default-features = true } +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} -bevy_derive = { version = "^0.16.1", features = [], default-features = true } +bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.16.1", features = [], default-features = true } +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_image = { version = "^0.16.1", features = [], default-features = true } +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} -bevy_log = { version = "^0.16.1", features = [], default-features = true } +bevy_log = { version = "^0.17.2", features = [], default-features = true} -bevy_math = { version = "^0.16.1", features = [], default-features = true } +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} -bevy_reflect = { version = "^0.16.1", features = [], default-features = true } +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_render = { version = "^0.16.1", features = [], default-features = true } +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} -bevy_sprite = { version = "^0.16.1", features = [], default-features = true } +cosmic-text = { version = "^0.14", features = [], default-features = true} -bevy_transform = { version = "^0.16.1", features = [], default-features = true } +serde = { version = "^1", features = [], default-features = true} -bevy_utils = { version = "^0.16.1", features = [], default-features = true } +sys-locale = { version = "^0.3.0", features = [], default-features = true} -bevy_window = { version = "^0.16.1", features = [], default-features = true } -cosmic-text = { version = "^0.13", features = [], default-features = true } - -serde = { version = "^1", features = [], default-features = true } - -smallvec = { version = "^1.13", features = [], default-features = true } - -sys-locale = { version = "^0.3.0", features = [], default-features = true } - -unicode-bidi = { version = "^0.3.13", features = [], default-features = true } diff --git a/crates/bindings/bevy_text_bms_bindings/src/lib.rs b/crates/bindings/bevy_text_bms_bindings/src/lib.rs index bb61288940..b31aa09f96 100644 --- a/crates/bindings/bevy_text_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_text_bms_bindings/src/lib.rs @@ -12,16 +12,16 @@ use bevy_mod_scripting_bindings::{ }; use bevy_mod_scripting_derive::script_bindings; pub struct BevyTextScriptingPlugin; -pub(crate) fn register_justify_text_functions(world: &mut World) { +pub(crate) fn register_justify_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_text::prelude::JustifyText, + ::bevy_text::prelude::Justify, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_text::prelude::JustifyText>| { + |_self: Ref<::bevy_text::prelude::Justify>| { let output: () = { { - let output: () = <::bevy_text::prelude::JustifyText as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_text::prelude::Justify as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -35,10 +35,10 @@ pub(crate) fn register_justify_text_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_text::prelude::JustifyText>| { - let output: Val<::bevy_text::prelude::JustifyText> = { + |_self: Ref<::bevy_text::prelude::Justify>| { + let output: Val<::bevy_text::prelude::Justify> = { { - let output: Val<::bevy_text::prelude::JustifyText> = <::bevy_text::prelude::JustifyText as ::std::clone::Clone>::clone( + let output: Val<::bevy_text::prelude::Justify> = <::bevy_text::prelude::Justify as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -53,13 +53,13 @@ pub(crate) fn register_justify_text_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_text::prelude::JustifyText>, - other: Ref<::bevy_text::prelude::JustifyText>| + _self: Ref<::bevy_text::prelude::Justify>, + other: Ref<::bevy_text::prelude::Justify>| { let output: bool = { { - let output: bool = <::bevy_text::prelude::JustifyText as ::std::cmp::PartialEq< - ::bevy_text::prelude::JustifyText, + let output: bool = <::bevy_text::prelude::Justify as ::std::cmp::PartialEq< + ::bevy_text::prelude::Justify, >>::eq(&_self, &other) .into(); output @@ -74,7 +74,7 @@ pub(crate) fn register_justify_text_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_text::prelude::JustifyText, + ::bevy_text::prelude::Justify, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -144,33 +144,6 @@ pub(crate) fn register_line_break_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_text_2_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_text::prelude::Text2d, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_text::prelude::Text2d>| { - let output: Val<::bevy_text::prelude::Text2d> = { - { - let output: Val<::bevy_text::prelude::Text2d> = - <::bevy_text::prelude::Text2d as ::std::clone::Clone>::clone(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_text::prelude::Text2d, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} pub(crate) fn register_text_color_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_text::prelude::TextColor, @@ -237,6 +210,23 @@ pub(crate) fn register_text_font_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "eq", + |_self: Ref<::bevy_text::prelude::TextFont>, other: Ref<::bevy_text::prelude::TextFont>| { + let output: bool = { + { + let output: bool = <::bevy_text::prelude::TextFont as ::std::cmp::PartialEq< + ::bevy_text::prelude::TextFont, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) .register_documented( "from_font_size", |font_size: f32| { @@ -342,7 +332,7 @@ pub(crate) fn register_text_layout_functions(world: &mut World) { .register_documented( "new", | - justify: Val<::bevy_text::prelude::JustifyText>, + justify: Val<::bevy_text::prelude::Justify>, linebreak: Val<::bevy_text::prelude::LineBreak>| { let output: Val<::bevy_text::prelude::TextLayout> = { @@ -362,7 +352,7 @@ pub(crate) fn register_text_layout_functions(world: &mut World) { ) .register_documented( "new_with_justify", - |justify: Val<::bevy_text::prelude::JustifyText>| { + |justify: Val<::bevy_text::prelude::Justify>| { let output: Val<::bevy_text::prelude::TextLayout> = { { let output: Val<::bevy_text::prelude::TextLayout> = ::bevy_text::prelude::TextLayout::new_with_justify( @@ -374,7 +364,7 @@ pub(crate) fn register_text_layout_functions(world: &mut World) { }; output }, - " Makes a new [`TextLayout`] with the specified [`JustifyText`].", + " Makes a new [`TextLayout`] with the specified [`Justify`].", &["justify"], ) .register_documented( @@ -413,7 +403,7 @@ pub(crate) fn register_text_layout_functions(world: &mut World) { "with_justify", | _self: Val<::bevy_text::prelude::TextLayout>, - justify: Val<::bevy_text::prelude::JustifyText>| + justify: Val<::bevy_text::prelude::Justify>| { let output: Val<::bevy_text::prelude::TextLayout> = { { @@ -427,7 +417,7 @@ pub(crate) fn register_text_layout_functions(world: &mut World) { }; output }, - " Returns this [`TextLayout`] with the specified [`JustifyText`].", + " Returns this [`TextLayout`] with the specified [`Justify`].", &["_self", "justify"], ) .register_documented( @@ -504,35 +494,6 @@ pub(crate) fn register_text_span_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_line_height_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_text::LineHeight, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_text::LineHeight>| { - let output: Val<::bevy_text::LineHeight> = { - { - let output: Val<::bevy_text::LineHeight> = <::bevy_text::LineHeight as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_text::LineHeight, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} pub(crate) fn register_text_bounds_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_text::TextBounds, @@ -614,81 +575,6 @@ pub(crate) fn register_text_bounds_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_computed_text_block_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_text::ComputedTextBlock, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_text::ComputedTextBlock>| { - let output: Val<::bevy_text::ComputedTextBlock> = { - { - let output: Val<::bevy_text::ComputedTextBlock> = <::bevy_text::ComputedTextBlock as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "needs_rerender", - |_self: Ref<::bevy_text::ComputedTextBlock>| { - let output: bool = { - { - let output: bool = ::bevy_text::ComputedTextBlock::needs_rerender( - &_self, - ) - .into(); - output - } - }; - output - }, - " Indicates if the text needs to be refreshed in [`TextLayoutInfo`].\n Updated automatically by [`detect_text_needs_rerender`] and cleared\n by [`TextPipeline`](crate::TextPipeline) methods.", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_text::ComputedTextBlock, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_text_entity_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_text::TextEntity, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_text::TextEntity>| { - let output: Val<::bevy_text::TextEntity> = { - { - let output: Val<::bevy_text::TextEntity> = <::bevy_text::TextEntity as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_text::TextEntity, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} pub(crate) fn register_font_smoothing_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_text::FontSmoothing, @@ -839,6 +725,81 @@ pub(crate) fn register_positioned_glyph_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } +pub(crate) fn register_computed_text_block_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_text::ComputedTextBlock, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_text::ComputedTextBlock>| { + let output: Val<::bevy_text::ComputedTextBlock> = { + { + let output: Val<::bevy_text::ComputedTextBlock> = <::bevy_text::ComputedTextBlock as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "needs_rerender", + |_self: Ref<::bevy_text::ComputedTextBlock>| { + let output: bool = { + { + let output: bool = ::bevy_text::ComputedTextBlock::needs_rerender( + &_self, + ) + .into(); + output + } + }; + output + }, + " Indicates if the text needs to be refreshed in [`TextLayoutInfo`].\n Updated automatically by [`detect_text_needs_rerender`] and cleared\n by [`TextPipeline`](crate::TextPipeline) methods.", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_text::ComputedTextBlock, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_text_entity_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_text::TextEntity, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_text::TextEntity>| { + let output: Val<::bevy_text::TextEntity> = { + { + let output: Val<::bevy_text::TextEntity> = <::bevy_text::TextEntity as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_text::TextEntity, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} pub(crate) fn register_text_layout_info_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_text::TextLayoutInfo, @@ -868,24 +829,117 @@ pub(crate) fn register_text_layout_info_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } +pub(crate) fn register_line_height_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_text::LineHeight, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_text::LineHeight>| { + let output: Val<::bevy_text::LineHeight> = { + { + let output: Val<::bevy_text::LineHeight> = <::bevy_text::LineHeight as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_text::LineHeight>, other: Ref<::bevy_text::LineHeight>| { + let output: bool = { + { + let output: bool = <::bevy_text::LineHeight as ::std::cmp::PartialEq< + ::bevy_text::LineHeight, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_text::LineHeight, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_text_background_color_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_text::TextBackgroundColor, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_text::TextBackgroundColor>| { + let output: Val<::bevy_text::TextBackgroundColor> = { + { + let output: Val<::bevy_text::TextBackgroundColor> = + <::bevy_text::TextBackgroundColor as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_text::TextBackgroundColor>, + other: Ref<::bevy_text::TextBackgroundColor>| { + let output: bool = { + { + let output: bool = + <::bevy_text::TextBackgroundColor as ::std::cmp::PartialEq< + ::bevy_text::TextBackgroundColor, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_text::TextBackgroundColor, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} impl Plugin for BevyTextScriptingPlugin { fn build(&self, app: &mut App) { let mut world = app.world_mut(); - register_justify_text_functions(&mut world); + register_justify_functions(&mut world); register_line_break_functions(&mut world); - register_text_2_d_functions(&mut world); register_text_color_functions(&mut world); register_text_font_functions(&mut world); register_text_layout_functions(&mut world); register_text_span_functions(&mut world); - register_line_height_functions(&mut world); register_text_bounds_functions(&mut world); - register_computed_text_block_functions(&mut world); - register_text_entity_functions(&mut world); register_font_smoothing_functions(&mut world); register_glyph_atlas_location_functions(&mut world); register_glyph_atlas_info_functions(&mut world); register_positioned_glyph_functions(&mut world); + register_computed_text_block_functions(&mut world); + register_text_entity_functions(&mut world); register_text_layout_info_functions(&mut world); + register_line_height_functions(&mut world); + register_text_background_color_functions(&mut world); } } diff --git a/crates/bindings/bevy_time_bms_bindings/Cargo.toml b/crates/bindings/bevy_time_bms_bindings/Cargo.toml index 3fd6513518..c5c2c83399 100644 --- a/crates/bindings/bevy_time_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_time_bms_bindings/Cargo.toml @@ -17,26 +17,15 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_time = { version = "0.16.1", features = [ - "std", - "bevy_reflect", -], default-features = true } +bevy_time = { version = "0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_app = { version = "^0.16.1", features = [ - "std", - "bevy_reflect", -], default-features = true } +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "reflect_auto_register", "error_panic_hook"], default-features = true} -bevy_ecs = { version = "^0.16.1", features = [ - "std", - "bevy_reflect", -], default-features = false } +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "multi_threaded", "reflect_auto_register", "backtrace", "serialize"], default-features = true} + +bevy_platform = { version = "^0.17.2", features = ["std", "alloc", "serialize"], default-features = true} + +bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_platform = { version = "^0.16.1", features = [ - "std", -], default-features = false } -bevy_reflect = { version = "^0.16.1", features = [ - "std", -], default-features = false } diff --git a/crates/bindings/bevy_time_bms_bindings/src/lib.rs b/crates/bindings/bevy_time_bms_bindings/src/lib.rs index 744f6fb367..10a323f092 100644 --- a/crates/bindings/bevy_time_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_time_bms_bindings/src/lib.rs @@ -196,6 +196,21 @@ pub(crate) fn register_timer_functions(world: &mut World) { "", &["_self", "other"], ) + .register_documented( + "finish", + |mut _self: Mut<::bevy_time::prelude::Timer>| { + let output: () = { + { + let output: () = ::bevy_time::prelude::Timer::finish(&mut _self) + .into(); + output + } + }; + output + }, + " Finishes the timer.\n # Examples\n ```\n # use bevy_time::*;\n let mut timer = Timer::from_seconds(1.5, TimerMode::Once);\n timer.finish();\n assert!(timer.finished());\n ```", + &["_self"], + ) .register_documented( "finished", |_self: Ref<::bevy_time::prelude::Timer>| { @@ -261,6 +276,38 @@ pub(crate) fn register_timer_functions(world: &mut World) { " Creates a new timer with a given duration in seconds.\n # Example\n ```\n # use bevy_time::*;\n let mut timer = Timer::from_seconds(1.0, TimerMode::Once);\n ```", &["duration", "mode"], ) + .register_documented( + "is_finished", + |_self: Ref<::bevy_time::prelude::Timer>| { + let output: bool = { + { + let output: bool = ::bevy_time::prelude::Timer::is_finished( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns `true` if the timer has reached its duration.\n For repeating timers, this method behaves identically to [`Timer::just_finished`].\n # Examples\n ```\n # use bevy_time::*;\n use std::time::Duration;\n let mut timer_once = Timer::from_seconds(1.0, TimerMode::Once);\n timer_once.tick(Duration::from_secs_f32(1.5));\n assert!(timer_once.is_finished());\n timer_once.tick(Duration::from_secs_f32(0.5));\n assert!(timer_once.is_finished());\n let mut timer_repeating = Timer::from_seconds(1.0, TimerMode::Repeating);\n timer_repeating.tick(Duration::from_secs_f32(1.1));\n assert!(timer_repeating.is_finished());\n timer_repeating.tick(Duration::from_secs_f32(0.8));\n assert!(!timer_repeating.is_finished());\n timer_repeating.tick(Duration::from_secs_f32(0.6));\n assert!(timer_repeating.is_finished());\n ```", + &["_self"], + ) + .register_documented( + "is_paused", + |_self: Ref<::bevy_time::prelude::Timer>| { + let output: bool = { + { + let output: bool = ::bevy_time::prelude::Timer::is_paused(&_self) + .into(); + output + } + }; + output + }, + " Returns `true` if the timer is paused.\n See also [`Stopwatch::is_paused`](Stopwatch::is_paused).\n # Examples\n ```\n # use bevy_time::*;\n let mut timer = Timer::from_seconds(1.0, TimerMode::Once);\n assert!(!timer.is_paused());\n timer.pause();\n assert!(timer.is_paused());\n timer.unpause();\n assert!(!timer.is_paused());\n ```", + &["_self"], + ) .register_documented( "just_finished", |_self: Ref<::bevy_time::prelude::Timer>| { @@ -392,7 +439,7 @@ pub(crate) fn register_timer_functions(world: &mut World) { }; output }, - " Resets the timer. The reset doesn't affect the `paused` state of the timer.\n See also [`Stopwatch::reset`](Stopwatch::reset).\n Examples\n ```\n # use bevy_time::*;\n use std::time::Duration;\n let mut timer = Timer::from_seconds(1.0, TimerMode::Once);\n timer.tick(Duration::from_secs_f32(1.5));\n timer.reset();\n assert!(!timer.finished());\n assert!(!timer.just_finished());\n assert_eq!(timer.elapsed_secs(), 0.0);\n ```", + " Resets the timer. The reset doesn't affect the `paused` state of the timer.\n See also [`Stopwatch::reset`](Stopwatch::reset).\n Examples\n ```\n # use bevy_time::*;\n use std::time::Duration;\n let mut timer = Timer::from_seconds(1.0, TimerMode::Once);\n timer.tick(Duration::from_secs_f32(1.5));\n timer.reset();\n assert!(!timer.is_finished());\n assert!(!timer.just_finished());\n assert_eq!(timer.elapsed_secs(), 0.0);\n ```", &["_self"], ) .register_documented( @@ -434,7 +481,7 @@ pub(crate) fn register_timer_functions(world: &mut World) { }; output }, - " Sets the elapsed time of the timer without any other considerations.\n See also [`Stopwatch::set`](Stopwatch::set).\n #\n ```\n # use bevy_time::*;\n use std::time::Duration;\n let mut timer = Timer::from_seconds(1.0, TimerMode::Once);\n timer.set_elapsed(Duration::from_secs(2));\n assert_eq!(timer.elapsed(), Duration::from_secs(2));\n // the timer is not finished even if the elapsed time is greater than the duration.\n assert!(!timer.finished());\n ```", + " Sets the elapsed time of the timer without any other considerations.\n See also [`Stopwatch::set`](Stopwatch::set).\n #\n ```\n # use bevy_time::*;\n use std::time::Duration;\n let mut timer = Timer::from_seconds(1.0, TimerMode::Once);\n timer.set_elapsed(Duration::from_secs(2));\n assert_eq!(timer.elapsed(), Duration::from_secs(2));\n // the timer is not finished even if the elapsed time is greater than the duration.\n assert!(!timer.is_finished());\n ```", &["_self", "time"], ) .register_documented( diff --git a/crates/bindings/bevy_transform_bms_bindings/Cargo.toml b/crates/bindings/bevy_transform_bms_bindings/Cargo.toml index 6ca5d9c4f7..1dea392fa8 100644 --- a/crates/bindings/bevy_transform_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_transform_bms_bindings/Cargo.toml @@ -17,40 +17,19 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_transform = { version = "0.16.1", features = [ - "std", - "bevy-support", - "bevy_reflect", - "async_executor", - "alloc", - "bevy_log", -], default-features = true } - - -bevy_app = { version = "^0.16.1", features = [ - "std", - "bevy_reflect", -], default-features = false } - -bevy_ecs = { version = "^0.16.1", features = [ - "std", - "bevy_reflect", -], default-features = false } - -bevy_math = { version = "^0.16.1", features = [ - "std", - "bevy_reflect", -], default-features = false } - -bevy_reflect = { version = "^0.16.1", features = [ - "std", -], default-features = false } - -bevy_tasks = { version = "^0.16.1", features = [ - "std", - "async_executor", -], default-features = false } - -bevy_utils = { version = "^0.16.1", features = [ - "std", -], default-features = false } +bevy_transform = { version = "0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} + + +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "reflect_auto_register", "error_panic_hook"], default-features = true} + +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "multi_threaded", "reflect_auto_register", "backtrace", "serialize"], default-features = true} + +bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "alloc", "rand", "curve"], default-features = true} + +bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} + +bevy_tasks = { version = "^0.17.2", features = ["async_executor", "futures-lite", "multi_threaded"], default-features = true} + +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} + + diff --git a/crates/bindings/bevy_transform_bms_bindings/src/lib.rs b/crates/bindings/bevy_transform_bms_bindings/src/lib.rs index 93df8ca88b..3e376cb112 100644 --- a/crates/bindings/bevy_transform_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_transform_bms_bindings/src/lib.rs @@ -67,23 +67,6 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { "", &["_self"], ) - .register_documented( - "compute_matrix", - |_self: Ref<::bevy_transform::components::GlobalTransform>| { - let output: Val<::bevy_math::Mat4> = { - { - let output: Val<::bevy_math::Mat4> = ::bevy_transform::components::GlobalTransform::compute_matrix( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the 3d affine transformation matrix as a [`Mat4`].", - &["_self"], - ) .register_documented( "compute_transform", |_self: Ref<::bevy_transform::components::GlobalTransform>| { @@ -379,7 +362,7 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { }; output }, - " Returns the [`Transform`] `self` would have if it was a child of an entity\n with the `parent` [`GlobalTransform`].\n This is useful if you want to \"reparent\" an [`Entity`](bevy_ecs::entity::Entity).\n Say you have an entity `e1` that you want to turn into a child of `e2`,\n but you want `e1` to keep the same global transform, even after re-parenting. You would use:\n ```\n # use bevy_transform::prelude::{GlobalTransform, Transform};\n # use bevy_ecs::prelude::{Entity, Query, Component, Commands};\n #[derive(Component)]\n struct ToReparent {\n new_parent: Entity,\n }\n fn reparent_system(\n mut commands: Commands,\n mut targets: Query<(&mut Transform, Entity, &GlobalTransform, &ToReparent)>,\n transforms: Query<&GlobalTransform>,\n ) {\n for (mut transform, entity, initial, to_reparent) in targets.iter_mut() {\n if let Ok(parent_transform) = transforms.get(to_reparent.new_parent) {\n *transform = initial.reparented_to(parent_transform);\n commands.entity(entity)\n .remove::()\n .set_parent(to_reparent.new_parent);\n }\n }\n }\n ```\n The transform is expected to be non-degenerate and without shearing, or the output\n will be invalid.", + " Returns the [`Transform`] `self` would have if it was a child of an entity\n with the `parent` [`GlobalTransform`].\n This is useful if you want to \"reparent\" an [`Entity`](bevy_ecs::entity::Entity).\n Say you have an entity `e1` that you want to turn into a child of `e2`,\n but you want `e1` to keep the same global transform, even after re-parenting. You would use:\n ```\n # use bevy_transform::prelude::{GlobalTransform, Transform};\n # use bevy_ecs::prelude::{Entity, Query, Component, Commands, ChildOf};\n #[derive(Component)]\n struct ToReparent {\n new_parent: Entity,\n }\n fn reparent_system(\n mut commands: Commands,\n mut targets: Query<(&mut Transform, Entity, &GlobalTransform, &ToReparent)>,\n transforms: Query<&GlobalTransform>,\n ) {\n for (mut transform, entity, initial, to_reparent) in targets.iter_mut() {\n if let Ok(parent_transform) = transforms.get(to_reparent.new_parent) {\n *transform = initial.reparented_to(parent_transform);\n commands.entity(entity)\n .remove::()\n .insert(ChildOf(to_reparent.new_parent));\n }\n }\n }\n ```\n The transform is expected to be non-degenerate and without shearing, or the output\n will be invalid.", &["_self", "parent"], ) .register_documented( @@ -447,7 +430,24 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { }; output }, - " Returns the isometric part of the transformation as an [isometry]. Any scaling done by the\n transformation will be ignored.\n The transform is expected to be non-degenerate and without shearing, or the output\n will be invalid.\n [isometry]: Isometry3d", + " Computes a Scale-Rotation-Translation decomposition of the transformation and returns\n the isometric part as an [isometry]. Any scaling done by the transformation will be ignored.\n Note: this is a somewhat costly and lossy conversion.\n The transform is expected to be non-degenerate and without shearing, or the output\n will be invalid.\n [isometry]: Isometry3d", + &["_self"], + ) + .register_documented( + "to_matrix", + |_self: Ref<::bevy_transform::components::GlobalTransform>| { + let output: Val<::bevy_math::Mat4> = { + { + let output: Val<::bevy_math::Mat4> = ::bevy_transform::components::GlobalTransform::to_matrix( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the 3d affine transformation matrix as a [`Mat4`].", &["_self"], ) .register_documented( @@ -585,23 +585,6 @@ pub(crate) fn register_transform_functions(world: &mut World) { " Returns the 3d affine transformation matrix from this transforms translation,\n rotation, and scale.", &["_self"], ) - .register_documented( - "compute_matrix", - |_self: Ref<::bevy_transform::components::Transform>| { - let output: Val<::bevy_math::Mat4> = { - { - let output: Val<::bevy_math::Mat4> = ::bevy_transform::components::Transform::compute_matrix( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the 3d affine transformation matrix from this transforms translation,\n rotation, and scale.", - &["_self"], - ) .register_documented( "down", |_self: Ref<::bevy_transform::components::Transform>| { @@ -1179,6 +1162,23 @@ pub(crate) fn register_transform_functions(world: &mut World) { " Get the [isometry] defined by this transform's rotation and translation, ignoring scale.\n [isometry]: Isometry3d", &["_self"], ) + .register_documented( + "to_matrix", + |_self: Ref<::bevy_transform::components::Transform>| { + let output: Val<::bevy_math::Mat4> = { + { + let output: Val<::bevy_math::Mat4> = ::bevy_transform::components::Transform::to_matrix( + &_self, + ) + .into(); + output + } + }; + output + }, + " Computes the 3d affine transformation matrix from this transform's translation,\n rotation, and scale.", + &["_self"], + ) .register_documented( "transform_point", | diff --git a/crates/bindings/bevy_ui_bms_bindings/Cargo.toml b/crates/bindings/bevy_ui_bms_bindings/Cargo.toml new file mode 100644 index 0000000000..80a8023ab6 --- /dev/null +++ b/crates/bindings/bevy_ui_bms_bindings/Cargo.toml @@ -0,0 +1,63 @@ +[package] +name = "bevy_ui_bms_bindings" +description = "Automatically generated bindings for bevy_ui crate" +readme = "README.md" +version.workspace = true +edition.workspace = true +authors.workspace = true +license.workspace = true +homepage.workspace = true +repository.workspace = true +keywords.workspace = true +categories.workspace = true + +[dependencies] + + +bevy_mod_scripting_core = { workspace = true } +bevy_mod_scripting_bindings = { workspace = true } +bevy_mod_scripting_derive = { workspace = true } +bevy_ui = { version = "0.17.2", features = ["bevy_picking", "bevy_ui_picking_backend"], default-features = true} + + +accesskit = { version = "^0.21", features = [], default-features = true} + +bevy_a11y = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} + +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} + +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} + +bevy_camera = { version = "^0.17.2", features = [], default-features = true} + +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} + +bevy_derive = { version = "^0.17.2", features = [], default-features = true} + +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} + +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} + +bevy_input = { version = "^0.17.2", features = ["std", "bevy_reflect", "smol_str"], default-features = true} + +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} + +bevy_picking = { version = "^0.17.2", features = ["bevy_mesh_picking_backend"], default-features = true} + +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} + +bevy_sprite = { version = "^0.17.2", features = ["bevy_picking", "bevy_window", "bevy_sprite_picking_backend", "bevy_text"], default-features = true} + +bevy_text = { version = "^0.17.2", features = ["default_font"], default-features = true} + +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} + +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} + +bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} + +taffy = { version = "^0.7", features = [], default-features = true} + +uuid = { version = "^1.1", features = [], default-features = true} + + diff --git a/crates/bindings/bevy_ui_bms_bindings/README.md b/crates/bindings/bevy_ui_bms_bindings/README.md new file mode 100644 index 0000000000..0edceffbab --- /dev/null +++ b/crates/bindings/bevy_ui_bms_bindings/README.md @@ -0,0 +1,4 @@ +# bevy_ui bindings +This crate is part of the [bevy_mod_scripting](http://github.com/makspll/bevy_mod_scripting) project. + +The code inside is fully generated via a custom rustc plugin. \ No newline at end of file diff --git a/crates/bindings/bevy_ui_bms_bindings/src/lib.rs b/crates/bindings/bevy_ui_bms_bindings/src/lib.rs new file mode 100644 index 0000000000..107dc8f562 --- /dev/null +++ b/crates/bindings/bevy_ui_bms_bindings/src/lib.rs @@ -0,0 +1,6263 @@ +#![allow(clippy::all)] +#![allow(unused, deprecated, dead_code)] + +use bevy_app::{App, Plugin}; +use bevy_ecs::prelude::*; +use bevy_mod_scripting_bindings::{ + ReflectReference, + function::{ + from::{Mut, Ref, Val}, + namespace::NamespaceBuilder, + }, +}; +use bevy_mod_scripting_derive::script_bindings; +pub struct BevyUiScriptingPlugin; +pub(crate) fn register_display_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::Display, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::prelude::Display>| { + let output: () = { + { + let output: () = <::bevy_ui::prelude::Display as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::Display>| { + let output: Val<::bevy_ui::prelude::Display> = { + { + let output: Val<::bevy_ui::prelude::Display> = <::bevy_ui::prelude::Display as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::Display>, + other: Ref<::bevy_ui::prelude::Display>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::Display as ::std::cmp::PartialEq< + ::bevy_ui::prelude::Display, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::Display, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_ui_picking_camera_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::picking_backend::UiPickingCamera, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::picking_backend::UiPickingCamera>| { + let output: Val<::bevy_ui::picking_backend::UiPickingCamera> = { + { + let output: Val<::bevy_ui::picking_backend::UiPickingCamera> = <::bevy_ui::picking_backend::UiPickingCamera as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::picking_backend::UiPickingCamera, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_ui_picking_settings_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::picking_backend::UiPickingSettings, + >::new(world); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::picking_backend::UiPickingSettings, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_text_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::widget::Text, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::widget::Text>| { + let output: Val<::bevy_ui::widget::Text> = { + { + let output: Val<::bevy_ui::widget::Text> = <::bevy_ui::widget::Text as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::widget::Text>, other: Ref<::bevy_ui::widget::Text>| { + let output: bool = { + { + let output: bool = <::bevy_ui::widget::Text as ::std::cmp::PartialEq< + ::bevy_ui::widget::Text, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::widget::Text, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_text_shadow_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::widget::TextShadow, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::widget::TextShadow>| { + let output: Val<::bevy_ui::widget::TextShadow> = { + { + let output: Val<::bevy_ui::widget::TextShadow> = + <::bevy_ui::widget::TextShadow as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::widget::TextShadow>, other: Ref<::bevy_ui::widget::TextShadow>| { + let output: bool = { + { + let output: bool = <::bevy_ui::widget::TextShadow as ::std::cmp::PartialEq< + ::bevy_ui::widget::TextShadow, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::widget::TextShadow, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_button_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::widget::Button, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::widget::Button>| { + let output: () = { + { + let output: () = <::bevy_ui::widget::Button as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::widget::Button>| { + let output: Val<::bevy_ui::widget::Button> = { + { + let output: Val<::bevy_ui::widget::Button> = <::bevy_ui::widget::Button as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::widget::Button>, + other: Ref<::bevy_ui::widget::Button>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::widget::Button as ::std::cmp::PartialEq< + ::bevy_ui::widget::Button, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::widget::Button, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_image_node_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::widget::ImageNode, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::widget::ImageNode>| { + let output: Val<::bevy_ui::widget::ImageNode> = { + { + let output: Val<::bevy_ui::widget::ImageNode> = <::bevy_ui::widget::ImageNode as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "solid_color", + |color: Val<::bevy_color::Color>| { + let output: Val<::bevy_ui::widget::ImageNode> = { + { + let output: Val<::bevy_ui::widget::ImageNode> = ::bevy_ui::widget::ImageNode::solid_color( + color.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a solid color [`ImageNode`].\n This is primarily useful for debugging / mocking the extents of your image.", + &["color"], + ) + .register_documented( + "with_color", + |_self: Val<::bevy_ui::widget::ImageNode>, color: Val<::bevy_color::Color>| { + let output: Val<::bevy_ui::widget::ImageNode> = { + { + let output: Val<::bevy_ui::widget::ImageNode> = ::bevy_ui::widget::ImageNode::with_color( + _self.into_inner(), + color.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Set the color tint", + &["_self", "color"], + ) + .register_documented( + "with_flip_x", + |_self: Val<::bevy_ui::widget::ImageNode>| { + let output: Val<::bevy_ui::widget::ImageNode> = { + { + let output: Val<::bevy_ui::widget::ImageNode> = ::bevy_ui::widget::ImageNode::with_flip_x( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Flip the image along its x-axis", + &["_self"], + ) + .register_documented( + "with_flip_y", + |_self: Val<::bevy_ui::widget::ImageNode>| { + let output: Val<::bevy_ui::widget::ImageNode> = { + { + let output: Val<::bevy_ui::widget::ImageNode> = ::bevy_ui::widget::ImageNode::with_flip_y( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Flip the image along its y-axis", + &["_self"], + ) + .register_documented( + "with_mode", + | + _self: Val<::bevy_ui::widget::ImageNode>, + mode: Val<::bevy_ui::widget::NodeImageMode>| + { + let output: Val<::bevy_ui::widget::ImageNode> = { + { + let output: Val<::bevy_ui::widget::ImageNode> = ::bevy_ui::widget::ImageNode::with_mode( + _self.into_inner(), + mode.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "mode"], + ) + .register_documented( + "with_rect", + |_self: Val<::bevy_ui::widget::ImageNode>, rect: Val<::bevy_math::Rect>| { + let output: Val<::bevy_ui::widget::ImageNode> = { + { + let output: Val<::bevy_ui::widget::ImageNode> = ::bevy_ui::widget::ImageNode::with_rect( + _self.into_inner(), + rect.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "rect"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::widget::ImageNode, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_label_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::widget::Label, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::widget::Label>| { + let output: Val<::bevy_ui::widget::Label> = { + { + let output: Val<::bevy_ui::widget::Label> = <::bevy_ui::widget::Label as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::widget::Label, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_node_image_mode_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::widget::NodeImageMode, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::widget::NodeImageMode>| { + let output: Val<::bevy_ui::widget::NodeImageMode> = { + { + let output: Val<::bevy_ui::widget::NodeImageMode> = <::bevy_ui::widget::NodeImageMode as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::widget::NodeImageMode>, + other: Ref<::bevy_ui::widget::NodeImageMode>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::widget::NodeImageMode as ::std::cmp::PartialEq< + ::bevy_ui::widget::NodeImageMode, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "uses_slices", + |_self: Ref<::bevy_ui::widget::NodeImageMode>| { + let output: bool = { + { + let output: bool = ::bevy_ui::widget::NodeImageMode::uses_slices( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns true if this mode uses slices internally ([`NodeImageMode::Sliced`] or [`NodeImageMode::Tiled`])", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::widget::NodeImageMode, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_viewport_node_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::widget::ViewportNode, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::widget::ViewportNode>| { + let output: Val<::bevy_ui::widget::ViewportNode> = { + { + let output: Val<::bevy_ui::widget::ViewportNode> = + <::bevy_ui::widget::ViewportNode as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "new", + |camera: Val<::bevy_ecs::entity::Entity>| { + let output: Val<::bevy_ui::widget::ViewportNode> = { + { + let output: Val<::bevy_ui::widget::ViewportNode> = + ::bevy_ui::widget::ViewportNode::new(camera.into_inner()).into(); + output + } + }; + output + }, + " Creates a new [`ViewportNode`] with a given `camera`.", + &["camera"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::widget::ViewportNode, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_interaction_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::Interaction, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::prelude::Interaction>| { + let output: () = { + { + let output: () = <::bevy_ui::prelude::Interaction as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::Interaction>| { + let output: Val<::bevy_ui::prelude::Interaction> = { + { + let output: Val<::bevy_ui::prelude::Interaction> = <::bevy_ui::prelude::Interaction as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::Interaction>, + other: Ref<::bevy_ui::prelude::Interaction>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::Interaction as ::std::cmp::PartialEq< + ::bevy_ui::prelude::Interaction, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::Interaction, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_ui_scale_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::UiScale, + >::new(world); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::UiScale, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_computed_ui_target_camera_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::ComputedUiTargetCamera, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::ComputedUiTargetCamera>| { + let output: Val<::bevy_ui::prelude::ComputedUiTargetCamera> = { + { + let output: Val<::bevy_ui::prelude::ComputedUiTargetCamera> = + <::bevy_ui::prelude::ComputedUiTargetCamera as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::prelude::ComputedUiTargetCamera>, + other: Ref<::bevy_ui::prelude::ComputedUiTargetCamera>| { + let output: bool = { + { + let output: bool = + <::bevy_ui::prelude::ComputedUiTargetCamera as ::std::cmp::PartialEq< + ::bevy_ui::prelude::ComputedUiTargetCamera, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::ComputedUiTargetCamera, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_computed_ui_render_target_info_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::ComputedUiRenderTargetInfo, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::ComputedUiRenderTargetInfo>| { + let output: Val<::bevy_ui::prelude::ComputedUiRenderTargetInfo> = { + { + let output: Val< + ::bevy_ui::prelude::ComputedUiRenderTargetInfo, + > = <::bevy_ui::prelude::ComputedUiRenderTargetInfo as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::ComputedUiRenderTargetInfo>, + other: Ref<::bevy_ui::prelude::ComputedUiRenderTargetInfo>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::ComputedUiRenderTargetInfo as ::std::cmp::PartialEq< + ::bevy_ui::prelude::ComputedUiRenderTargetInfo, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "logical_size", + |_self: Ref<::bevy_ui::prelude::ComputedUiRenderTargetInfo>| { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = ::bevy_ui::prelude::ComputedUiRenderTargetInfo::logical_size( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the size of the target camera's viewport in logical pixels.", + &["_self"], + ) + .register_documented( + "physical_size", + |_self: Ref<::bevy_ui::prelude::ComputedUiRenderTargetInfo>| { + let output: Val<::bevy_math::UVec2> = { + { + let output: Val<::bevy_math::UVec2> = ::bevy_ui::prelude::ComputedUiRenderTargetInfo::physical_size( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the size of the target camera's viewport in physical pixels.", + &["_self"], + ) + .register_documented( + "scale_factor", + |_self: Ref<::bevy_ui::prelude::ComputedUiRenderTargetInfo>| { + let output: f32 = { + { + let output: f32 = ::bevy_ui::prelude::ComputedUiRenderTargetInfo::scale_factor( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::ComputedUiRenderTargetInfo, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_content_size_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::measurement::ContentSize, + >::new(world) + .register_documented( + "fixed_size", + |size: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_ui::measurement::ContentSize> = { + { + let output: Val<::bevy_ui::measurement::ContentSize> = ::bevy_ui::measurement::ContentSize::fixed_size( + size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a `ContentSize` with a `Measure` that always returns given `size` argument, regardless of the UI layout's constraints.", + &["size"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::measurement::ContentSize, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_ui_global_transform_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::ui_transform::UiGlobalTransform, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::ui_transform::UiGlobalTransform>| { + let output: Val<::bevy_ui::ui_transform::UiGlobalTransform> = { + { + let output: Val<::bevy_ui::ui_transform::UiGlobalTransform> = + <::bevy_ui::ui_transform::UiGlobalTransform as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::ui_transform::UiGlobalTransform>, + other: Ref<::bevy_ui::ui_transform::UiGlobalTransform>| { + let output: bool = { + { + let output: bool = + <::bevy_ui::ui_transform::UiGlobalTransform as ::std::cmp::PartialEq< + ::bevy_ui::ui_transform::UiGlobalTransform, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::ui_transform::UiGlobalTransform, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_calculated_clip_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::CalculatedClip, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::CalculatedClip>| { + let output: Val<::bevy_ui::prelude::CalculatedClip> = { + { + let output: Val<::bevy_ui::prelude::CalculatedClip> = + <::bevy_ui::prelude::CalculatedClip as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::CalculatedClip, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_node_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::Node, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::Node>| { + let output: Val<::bevy_ui::prelude::Node> = { + { + let output: Val<::bevy_ui::prelude::Node> = <::bevy_ui::prelude::Node as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::prelude::Node>, other: Ref<::bevy_ui::prelude::Node>| { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::Node as ::std::cmp::PartialEq< + ::bevy_ui::prelude::Node, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::Node, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_overflow_axis_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::OverflowAxis, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::prelude::OverflowAxis>| { + let output: () = { + { + let output: () = <::bevy_ui::prelude::OverflowAxis as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::OverflowAxis>| { + let output: Val<::bevy_ui::prelude::OverflowAxis> = { + { + let output: Val<::bevy_ui::prelude::OverflowAxis> = <::bevy_ui::prelude::OverflowAxis as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::OverflowAxis>, + other: Ref<::bevy_ui::prelude::OverflowAxis>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::OverflowAxis as ::std::cmp::PartialEq< + ::bevy_ui::prelude::OverflowAxis, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "is_visible", + |_self: Ref<::bevy_ui::prelude::OverflowAxis>| { + let output: bool = { + { + let output: bool = ::bevy_ui::prelude::OverflowAxis::is_visible( + &_self, + ) + .into(); + output + } + }; + output + }, + " Overflow is visible on this axis", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::OverflowAxis, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_ui_target_camera_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::UiTargetCamera, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::prelude::UiTargetCamera>| { + let output: () = { + { + let output: () = <::bevy_ui::prelude::UiTargetCamera as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::UiTargetCamera>| { + let output: Val<::bevy_ui::prelude::UiTargetCamera> = { + { + let output: Val<::bevy_ui::prelude::UiTargetCamera> = <::bevy_ui::prelude::UiTargetCamera as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "entity", + |_self: Ref<::bevy_ui::prelude::UiTargetCamera>| { + let output: Val<::bevy_ecs::entity::Entity> = { + { + let output: Val<::bevy_ecs::entity::Entity> = ::bevy_ui::prelude::UiTargetCamera::entity( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::UiTargetCamera>, + other: Ref<::bevy_ui::prelude::UiTargetCamera>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::UiTargetCamera as ::std::cmp::PartialEq< + ::bevy_ui::prelude::UiTargetCamera, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::UiTargetCamera, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_computed_node_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::ComputedNode, + >::new(world) + .register_documented( + "border", + |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + let output: Val<::bevy_ui::prelude::BorderRect> = { + { + let output: Val<::bevy_ui::prelude::BorderRect> = ::bevy_ui::prelude::ComputedNode::border( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the thickness of the node's border on each edge in physical pixels.\n Automatically calculated by [`ui_layout_system`](`super::layout::ui_layout_system`).", + &["_self"], + ) + .register_documented( + "border_radius", + |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + let output: Val<::bevy_ui::prelude::ResolvedBorderRadius> = { + { + let output: Val<::bevy_ui::prelude::ResolvedBorderRadius> = ::bevy_ui::prelude::ComputedNode::border_radius( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the border radius for each of the node's corners in physical pixels.\n Automatically calculated by [`ui_layout_system`](`super::layout::ui_layout_system`).", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + let output: Val<::bevy_ui::prelude::ComputedNode> = { + { + let output: Val<::bevy_ui::prelude::ComputedNode> = <::bevy_ui::prelude::ComputedNode as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "contains_point", + | + _self: Ref<::bevy_ui::prelude::ComputedNode>, + transform: Val<::bevy_ui::ui_transform::UiGlobalTransform>, + point: Val<::bevy_math::Vec2>| + { + let output: bool = { + { + let output: bool = ::bevy_ui::prelude::ComputedNode::contains_point( + &_self, + transform.into_inner(), + point.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "transform", "point"], + ) + .register_documented( + "content_inset", + |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + let output: Val<::bevy_ui::prelude::BorderRect> = { + { + let output: Val<::bevy_ui::prelude::BorderRect> = ::bevy_ui::prelude::ComputedNode::content_inset( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the combined inset on each edge including both padding and border thickness in physical pixels.", + &["_self"], + ) + .register_documented( + "content_size", + |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = ::bevy_ui::prelude::ComputedNode::content_size( + &_self, + ) + .into(); + output + } + }; + output + }, + " The calculated node content size as width and height in physical pixels.\n Automatically calculated by [`ui_layout_system`](`super::layout::ui_layout_system`).", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::ComputedNode>, + other: Ref<::bevy_ui::prelude::ComputedNode>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::ComputedNode as ::std::cmp::PartialEq< + ::bevy_ui::prelude::ComputedNode, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "inner_radius", + |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + let output: Val<::bevy_ui::prelude::ResolvedBorderRadius> = { + { + let output: Val<::bevy_ui::prelude::ResolvedBorderRadius> = ::bevy_ui::prelude::ComputedNode::inner_radius( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the inner border radius for each of the node's corners in physical pixels.", + &["_self"], + ) + .register_documented( + "inverse_scale_factor", + |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + let output: f32 = { + { + let output: f32 = ::bevy_ui::prelude::ComputedNode::inverse_scale_factor( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the inverse of the scale factor for this node.\n To convert from physical coordinates to logical coordinates multiply by this value.", + &["_self"], + ) + .register_documented( + "is_empty", + |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + let output: bool = { + { + let output: bool = ::bevy_ui::prelude::ComputedNode::is_empty( + &_self, + ) + .into(); + output + } + }; + output + }, + " Check if the node is empty.\n A node is considered empty if it has a zero or negative extent along either of its axes.", + &["_self"], + ) + .register_documented( + "outline_offset", + |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + let output: f32 = { + { + let output: f32 = ::bevy_ui::prelude::ComputedNode::outline_offset( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the amount of space between the outline and the edge of the node in physical pixels.\n Automatically calculated by [`ui_layout_system`](`super::layout::ui_layout_system`).", + &["_self"], + ) + .register_documented( + "outline_radius", + |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + let output: Val<::bevy_ui::prelude::ResolvedBorderRadius> = { + { + let output: Val<::bevy_ui::prelude::ResolvedBorderRadius> = ::bevy_ui::prelude::ComputedNode::outline_radius( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the border radius for each corner of the outline\n An outline's border radius is derived from the node's border-radius\n so that the outline wraps the border equally at all points.\n Automatically calculated by [`ui_layout_system`](`super::layout::ui_layout_system`).", + &["_self"], + ) + .register_documented( + "outline_width", + |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + let output: f32 = { + { + let output: f32 = ::bevy_ui::prelude::ComputedNode::outline_width( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the thickness of the UI node's outline in physical pixels.\n If this value is negative or `0.` then no outline will be rendered.\n Automatically calculated by [`ui_layout_system`](`super::layout::ui_layout_system`).", + &["_self"], + ) + .register_documented( + "outlined_node_size", + |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = ::bevy_ui::prelude::ComputedNode::outlined_node_size( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the size of the node when including its outline.\n Automatically calculated by [`ui_layout_system`](`super::layout::ui_layout_system`).", + &["_self"], + ) + .register_documented( + "padding", + |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + let output: Val<::bevy_ui::prelude::BorderRect> = { + { + let output: Val<::bevy_ui::prelude::BorderRect> = ::bevy_ui::prelude::ComputedNode::padding( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the thickness of the node's padding on each edge in physical pixels.\n Automatically calculated by [`ui_layout_system`](`super::layout::ui_layout_system`).", + &["_self"], + ) + .register_documented( + "resolve_clip_rect", + | + _self: Ref<::bevy_ui::prelude::ComputedNode>, + overflow: Val<::bevy_ui::prelude::Overflow>, + overflow_clip_margin: Val<::bevy_ui::prelude::OverflowClipMargin>| + { + let output: Val<::bevy_math::Rect> = { + { + let output: Val<::bevy_math::Rect> = ::bevy_ui::prelude::ComputedNode::resolve_clip_rect( + &_self, + overflow.into_inner(), + overflow_clip_margin.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Resolve the node's clipping rect in local space", + &["_self", "overflow", "overflow_clip_margin"], + ) + .register_documented( + "size", + |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = ::bevy_ui::prelude::ComputedNode::size( + &_self, + ) + .into(); + output + } + }; + output + }, + " The calculated node size as width and height in physical pixels.\n Automatically calculated by [`ui_layout_system`](`super::layout::ui_layout_system`).", + &["_self"], + ) + .register_documented( + "stack_index", + |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + let output: u32 = { + { + let output: u32 = ::bevy_ui::prelude::ComputedNode::stack_index( + &_self, + ) + .into(); + output + } + }; + output + }, + " The order of the node in the UI layout.\n Nodes with a higher stack index are drawn on top of and receive interactions before nodes with lower stack indices.\n Automatically calculated in [`UiSystems::Stack`](super::UiSystems::Stack).", + &["_self"], + ) + .register_documented( + "unrounded_size", + |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = ::bevy_ui::prelude::ComputedNode::unrounded_size( + &_self, + ) + .into(); + output + } + }; + output + }, + " The calculated node size as width and height in physical pixels before rounding.\n Automatically calculated by [`ui_layout_system`](`super::layout::ui_layout_system`).", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::ComputedNode, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_overflow_clip_box_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::OverflowClipBox, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::prelude::OverflowClipBox>| { + let output: () = { + { + let output: () = <::bevy_ui::prelude::OverflowClipBox as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::OverflowClipBox>| { + let output: Val<::bevy_ui::prelude::OverflowClipBox> = { + { + let output: Val<::bevy_ui::prelude::OverflowClipBox> = <::bevy_ui::prelude::OverflowClipBox as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::OverflowClipBox>, + other: Ref<::bevy_ui::prelude::OverflowClipBox>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::OverflowClipBox as ::std::cmp::PartialEq< + ::bevy_ui::prelude::OverflowClipBox, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::OverflowClipBox, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_focus_policy_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::FocusPolicy, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::FocusPolicy>| { + let output: () = { + { + let output: () = <::bevy_ui::FocusPolicy as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::FocusPolicy>| { + let output: Val<::bevy_ui::FocusPolicy> = { + { + let output: Val<::bevy_ui::FocusPolicy> = <::bevy_ui::FocusPolicy as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::FocusPolicy>, other: Ref<::bevy_ui::FocusPolicy>| { + let output: bool = { + { + let output: bool = <::bevy_ui::FocusPolicy as ::std::cmp::PartialEq< + ::bevy_ui::FocusPolicy, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::<::bevy_ui::FocusPolicy, bevy_mod_scripting_bindings::MarkAsGenerated>( + ); +} +pub(crate) fn register_image_node_size_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::widget::ImageNodeSize, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::widget::ImageNodeSize>| { + let output: Val<::bevy_ui::widget::ImageNodeSize> = { + { + let output: Val<::bevy_ui::widget::ImageNodeSize> = + <::bevy_ui::widget::ImageNodeSize as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "size", + |_self: Ref<::bevy_ui::widget::ImageNodeSize>| { + let output: Val<::bevy_math::UVec2> = { + { + let output: Val<::bevy_math::UVec2> = + ::bevy_ui::widget::ImageNodeSize::size(&_self).into(); + output + } + }; + output + }, + " The size of the image's texture", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::widget::ImageNodeSize, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_text_node_flags_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::widget::TextNodeFlags, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::widget::TextNodeFlags>| { + let output: Val<::bevy_ui::widget::TextNodeFlags> = { + { + let output: Val<::bevy_ui::widget::TextNodeFlags> = + <::bevy_ui::widget::TextNodeFlags as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::widget::TextNodeFlags, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_ui_position_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::UiPosition, + >::new(world) + .register_documented( + "anchor", + |anchor: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_ui::prelude::UiPosition> = { + { + let output: Val<::bevy_ui::prelude::UiPosition> = + ::bevy_ui::prelude::UiPosition::anchor(anchor.into_inner()).into(); + output + } + }; + output + }, + " Position at the given normalized anchor point", + &["anchor"], + ) + .register_documented( + "at", + |_self: Val<::bevy_ui::prelude::UiPosition>, + x: Val<::bevy_ui::prelude::Val>, + y: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiPosition> = { + { + let output: Val<::bevy_ui::prelude::UiPosition> = + ::bevy_ui::prelude::UiPosition::at( + _self.into_inner(), + x.into_inner(), + y.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a position from self with the given `x` and `y` coordinates", + &["_self", "x", "y"], + ) + .register_documented( + "at_percent", + |_self: Val<::bevy_ui::prelude::UiPosition>, x: f32, y: f32| { + let output: Val<::bevy_ui::prelude::UiPosition> = { + { + let output: Val<::bevy_ui::prelude::UiPosition> = + ::bevy_ui::prelude::UiPosition::at_percent(_self.into_inner(), x, y).into(); + output + } + }; + output + }, + " Creates a percentage position from self with the given `x` and `y` coordinates", + &["_self", "x", "y"], + ) + .register_documented( + "at_px", + |_self: Val<::bevy_ui::prelude::UiPosition>, x: f32, y: f32| { + let output: Val<::bevy_ui::prelude::UiPosition> = { + { + let output: Val<::bevy_ui::prelude::UiPosition> = + ::bevy_ui::prelude::UiPosition::at_px(_self.into_inner(), x, y).into(); + output + } + }; + output + }, + " Creates a position in logical pixels from self with the given `x` and `y` coordinates", + &["_self", "x", "y"], + ) + .register_documented( + "at_x", + |_self: Val<::bevy_ui::prelude::UiPosition>, x: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiPosition> = { + { + let output: Val<::bevy_ui::prelude::UiPosition> = + ::bevy_ui::prelude::UiPosition::at_x(_self.into_inner(), x.into_inner()) + .into(); + output + } + }; + output + }, + " Creates a position from self with the given `x` coordinate", + &["_self", "x"], + ) + .register_documented( + "at_y", + |_self: Val<::bevy_ui::prelude::UiPosition>, y: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiPosition> = { + { + let output: Val<::bevy_ui::prelude::UiPosition> = + ::bevy_ui::prelude::UiPosition::at_y(_self.into_inner(), y.into_inner()) + .into(); + output + } + }; + output + }, + " Creates a position from self with the given `y` coordinate", + &["_self", "y"], + ) + .register_documented( + "bottom", + |x: Val<::bevy_ui::prelude::Val>, y: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiPosition> = { + { + let output: Val<::bevy_ui::prelude::UiPosition> = + ::bevy_ui::prelude::UiPosition::bottom(x.into_inner(), y.into_inner()) + .into(); + output + } + }; + output + }, + " Position relative to the bottom edge", + &["x", "y"], + ) + .register_documented( + "bottom_left", + |x: Val<::bevy_ui::prelude::Val>, y: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiPosition> = { + { + let output: Val<::bevy_ui::prelude::UiPosition> = + ::bevy_ui::prelude::UiPosition::bottom_left(x.into_inner(), y.into_inner()) + .into(); + output + } + }; + output + }, + " Position relative to the bottom-left corner", + &["x", "y"], + ) + .register_documented( + "bottom_right", + |x: Val<::bevy_ui::prelude::Val>, y: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiPosition> = { + { + let output: Val<::bevy_ui::prelude::UiPosition> = + ::bevy_ui::prelude::UiPosition::bottom_right( + x.into_inner(), + y.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Position relative to the bottom-right corner", + &["x", "y"], + ) + .register_documented( + "center", + |x: Val<::bevy_ui::prelude::Val>, y: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiPosition> = { + { + let output: Val<::bevy_ui::prelude::UiPosition> = + ::bevy_ui::prelude::UiPosition::center(x.into_inner(), y.into_inner()) + .into(); + output + } + }; + output + }, + " Position relative to the center", + &["x", "y"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::UiPosition>| { + let output: Val<::bevy_ui::prelude::UiPosition> = { + { + let output: Val<::bevy_ui::prelude::UiPosition> = + <::bevy_ui::prelude::UiPosition as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::prelude::UiPosition>, other: Ref<::bevy_ui::prelude::UiPosition>| { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::UiPosition as ::std::cmp::PartialEq< + ::bevy_ui::prelude::UiPosition, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "left", + |x: Val<::bevy_ui::prelude::Val>, y: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiPosition> = { + { + let output: Val<::bevy_ui::prelude::UiPosition> = + ::bevy_ui::prelude::UiPosition::left(x.into_inner(), y.into_inner()).into(); + output + } + }; + output + }, + " Position relative to the left edge", + &["x", "y"], + ) + .register_documented( + "new", + |anchor: Val<::bevy_math::Vec2>, + x: Val<::bevy_ui::prelude::Val>, + y: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiPosition> = { + { + let output: Val<::bevy_ui::prelude::UiPosition> = + ::bevy_ui::prelude::UiPosition::new( + anchor.into_inner(), + x.into_inner(), + y.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new position", + &["anchor", "x", "y"], + ) + .register_documented( + "resolve", + |_self: Val<::bevy_ui::prelude::UiPosition>, + scale_factor: f32, + physical_size: Val<::bevy_math::Vec2>, + physical_target_size: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = ::bevy_ui::prelude::UiPosition::resolve( + _self.into_inner(), + scale_factor, + physical_size.into_inner(), + physical_target_size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Resolves the `Position` into physical coordinates.", + &[ + "_self", + "scale_factor", + "physical_size", + "physical_target_size", + ], + ) + .register_documented( + "right", + |x: Val<::bevy_ui::prelude::Val>, y: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiPosition> = { + { + let output: Val<::bevy_ui::prelude::UiPosition> = + ::bevy_ui::prelude::UiPosition::right(x.into_inner(), y.into_inner()) + .into(); + output + } + }; + output + }, + " Position relative to the right edge", + &["x", "y"], + ) + .register_documented( + "top", + |x: Val<::bevy_ui::prelude::Val>, y: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiPosition> = { + { + let output: Val<::bevy_ui::prelude::UiPosition> = + ::bevy_ui::prelude::UiPosition::top(x.into_inner(), y.into_inner()).into(); + output + } + }; + output + }, + " Position relative to the top edge", + &["x", "y"], + ) + .register_documented( + "top_left", + |x: Val<::bevy_ui::prelude::Val>, y: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiPosition> = { + { + let output: Val<::bevy_ui::prelude::UiPosition> = + ::bevy_ui::prelude::UiPosition::top_left(x.into_inner(), y.into_inner()) + .into(); + output + } + }; + output + }, + " Position relative to the top-left corner", + &["x", "y"], + ) + .register_documented( + "top_right", + |x: Val<::bevy_ui::prelude::Val>, y: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiPosition> = { + { + let output: Val<::bevy_ui::prelude::UiPosition> = + ::bevy_ui::prelude::UiPosition::top_right(x.into_inner(), y.into_inner()) + .into(); + output + } + }; + output + }, + " Position relative to the top-right corner", + &["x", "y"], + ) + .register_documented( + "with_anchor", + |_self: Val<::bevy_ui::prelude::UiPosition>, anchor: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_ui::prelude::UiPosition> = { + { + let output: Val<::bevy_ui::prelude::UiPosition> = + ::bevy_ui::prelude::UiPosition::with_anchor( + _self.into_inner(), + anchor.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a position from self with the given `anchor` point", + &["_self", "anchor"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::UiPosition, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_val_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::Val, + >::new(world) + .register_documented( + "all", + |_self: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiRect> = { + { + let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::Val::all( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns a [`UiRect`] with all its fields equal to this value.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = Val::Px(1.).all();\n assert_eq!(ui_rect.left, Val::Px(1.));\n assert_eq!(ui_rect.right, Val::Px(1.));\n assert_eq!(ui_rect.top, Val::Px(1.));\n assert_eq!(ui_rect.bottom, Val::Px(1.));\n ```", + &["_self"], + ) + .register_documented( + "bottom", + |_self: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiRect> = { + { + let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::Val::bottom( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns a [`UiRect`] with its `bottom` equal to this value,\n and all other fields set to `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = Val::Px(1.).bottom();\n assert_eq!(ui_rect.left, Val::ZERO);\n assert_eq!(ui_rect.right, Val::ZERO);\n assert_eq!(ui_rect.top, Val::ZERO);\n assert_eq!(ui_rect.bottom, Val::Px(1.));\n ```", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::Val> = { + { + let output: Val<::bevy_ui::prelude::Val> = <::bevy_ui::prelude::Val as ::std::clone::Clone>::clone( + &_self.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "div", + |_self: Val<::bevy_ui::prelude::Val>, rhs: f32| { + let output: Val<::bevy_ui::prelude::Val> = { + { + let output: Val<::bevy_ui::prelude::Val> = <::bevy_ui::prelude::Val as ::std::ops::Div< + f32, + >>::div(_self.into_inner(), rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::prelude::Val>, other: Ref<::bevy_ui::prelude::Val>| { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::Val as ::std::cmp::PartialEq< + ::bevy_ui::prelude::Val, + >>::eq(&_self.into_inner(), &other.into_inner()) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "horizontal", + |_self: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiRect> = { + { + let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::Val::horizontal( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns a [`UiRect`] with all its `left` and `right` equal to this value,\n and its `top` and `bottom` set to `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = Val::Px(1.).horizontal();\n assert_eq!(ui_rect.left, Val::Px(1.));\n assert_eq!(ui_rect.right, Val::Px(1.));\n assert_eq!(ui_rect.top, Val::ZERO);\n assert_eq!(ui_rect.bottom, Val::ZERO);\n ```", + &["_self"], + ) + .register_documented( + "left", + |_self: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiRect> = { + { + let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::Val::left( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns a [`UiRect`] with its `left` equal to this value,\n and all other fields set to `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = Val::Px(1.).left();\n assert_eq!(ui_rect.left, Val::Px(1.));\n assert_eq!(ui_rect.right, Val::ZERO);\n assert_eq!(ui_rect.top, Val::ZERO);\n assert_eq!(ui_rect.bottom, Val::ZERO);\n ```", + &["_self"], + ) + .register_documented( + "mul", + |_self: Val<::bevy_ui::prelude::Val>, rhs: f32| { + let output: Val<::bevy_ui::prelude::Val> = { + { + let output: Val<::bevy_ui::prelude::Val> = <::bevy_ui::prelude::Val as ::std::ops::Mul< + f32, + >>::mul(_self.into_inner(), rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "neg", + |_self: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::Val> = { + { + let output: Val<::bevy_ui::prelude::Val> = <::bevy_ui::prelude::Val as ::std::ops::Neg>::neg( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "right", + |_self: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiRect> = { + { + let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::Val::right( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns a [`UiRect`] with its `right` equal to this value,\n and all other fields set to `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = Val::Px(1.).right();\n assert_eq!(ui_rect.left, Val::ZERO);\n assert_eq!(ui_rect.right, Val::Px(1.));\n assert_eq!(ui_rect.top, Val::ZERO);\n assert_eq!(ui_rect.bottom, Val::ZERO);\n ```", + &["_self"], + ) + .register_documented( + "top", + |_self: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiRect> = { + { + let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::Val::top( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns a [`UiRect`] with its `top` equal to this value,\n and all other fields set to `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = Val::Px(1.).top();\n assert_eq!(ui_rect.left, Val::ZERO);\n assert_eq!(ui_rect.right, Val::ZERO);\n assert_eq!(ui_rect.top, Val::Px(1.));\n assert_eq!(ui_rect.bottom, Val::ZERO);\n ```", + &["_self"], + ) + .register_documented( + "vertical", + |_self: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiRect> = { + { + let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::Val::vertical( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns a [`UiRect`] with all its `top` and `bottom` equal to this value,\n and its `left` and `right` set to `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = Val::Px(1.).vertical();\n assert_eq!(ui_rect.left, Val::ZERO);\n assert_eq!(ui_rect.right, Val::ZERO);\n assert_eq!(ui_rect.top, Val::Px(1.));\n assert_eq!(ui_rect.bottom, Val::Px(1.));\n ```", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::Val, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_color_stop_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::gradients::ColorStop, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::gradients::ColorStop>| { + let output: Val<::bevy_ui::gradients::ColorStop> = { + { + let output: Val<::bevy_ui::gradients::ColorStop> = + <::bevy_ui::gradients::ColorStop as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::gradients::ColorStop>, + other: Ref<::bevy_ui::gradients::ColorStop>| { + let output: bool = { + { + let output: bool = <::bevy_ui::gradients::ColorStop as ::std::cmp::PartialEq< + ::bevy_ui::gradients::ColorStop, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "with_hint", + |_self: Val<::bevy_ui::gradients::ColorStop>, hint: f32| { + let output: Val<::bevy_ui::gradients::ColorStop> = { + { + let output: Val<::bevy_ui::gradients::ColorStop> = + ::bevy_ui::gradients::ColorStop::with_hint(_self.into_inner(), hint).into(); + output + } + }; + output + }, + "", + &["_self", "hint"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::gradients::ColorStop, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_angular_color_stop_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::gradients::AngularColorStop, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::gradients::AngularColorStop>| { + let output: Val<::bevy_ui::gradients::AngularColorStop> = { + { + let output: Val<::bevy_ui::gradients::AngularColorStop> = + <::bevy_ui::gradients::AngularColorStop as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::gradients::AngularColorStop>, + other: Ref<::bevy_ui::gradients::AngularColorStop>| { + let output: bool = { + { + let output: bool = + <::bevy_ui::gradients::AngularColorStop as ::std::cmp::PartialEq< + ::bevy_ui::gradients::AngularColorStop, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "with_hint", + |_self: Val<::bevy_ui::gradients::AngularColorStop>, hint: f32| { + let output: Val<::bevy_ui::gradients::AngularColorStop> = { + { + let output: Val<::bevy_ui::gradients::AngularColorStop> = + ::bevy_ui::gradients::AngularColorStop::with_hint(_self.into_inner(), hint) + .into(); + output + } + }; + output + }, + "", + &["_self", "hint"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::gradients::AngularColorStop, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_linear_gradient_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::gradients::LinearGradient, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::gradients::LinearGradient>| { + let output: Val<::bevy_ui::gradients::LinearGradient> = { + { + let output: Val<::bevy_ui::gradients::LinearGradient> = + <::bevy_ui::gradients::LinearGradient as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::gradients::LinearGradient>, + other: Ref<::bevy_ui::gradients::LinearGradient>| { + let output: bool = { + { + let output: bool = + <::bevy_ui::gradients::LinearGradient as ::std::cmp::PartialEq< + ::bevy_ui::gradients::LinearGradient, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "in_color_space", + |_self: Val<::bevy_ui::gradients::LinearGradient>, + color_space: Val<::bevy_ui::gradients::InterpolationColorSpace>| { + let output: Val<::bevy_ui::gradients::LinearGradient> = { + { + let output: Val<::bevy_ui::gradients::LinearGradient> = + ::bevy_ui::gradients::LinearGradient::in_color_space( + _self.into_inner(), + color_space.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "color_space"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::gradients::LinearGradient, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_interpolation_color_space_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::gradients::InterpolationColorSpace, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::gradients::InterpolationColorSpace>| { + let output: () = { + { + let output: () = <::bevy_ui::gradients::InterpolationColorSpace as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::gradients::InterpolationColorSpace>| { + let output: Val<::bevy_ui::gradients::InterpolationColorSpace> = { + { + let output: Val<::bevy_ui::gradients::InterpolationColorSpace> = <::bevy_ui::gradients::InterpolationColorSpace as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::gradients::InterpolationColorSpace>, + other: Ref<::bevy_ui::gradients::InterpolationColorSpace>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::gradients::InterpolationColorSpace as ::std::cmp::PartialEq< + ::bevy_ui::gradients::InterpolationColorSpace, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::gradients::InterpolationColorSpace, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_radial_gradient_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::gradients::RadialGradient, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::gradients::RadialGradient>| { + let output: Val<::bevy_ui::gradients::RadialGradient> = { + { + let output: Val<::bevy_ui::gradients::RadialGradient> = + <::bevy_ui::gradients::RadialGradient as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::gradients::RadialGradient>, + other: Ref<::bevy_ui::gradients::RadialGradient>| { + let output: bool = { + { + let output: bool = + <::bevy_ui::gradients::RadialGradient as ::std::cmp::PartialEq< + ::bevy_ui::gradients::RadialGradient, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "in_color_space", + |_self: Val<::bevy_ui::gradients::RadialGradient>, + color_space: Val<::bevy_ui::gradients::InterpolationColorSpace>| { + let output: Val<::bevy_ui::gradients::RadialGradient> = { + { + let output: Val<::bevy_ui::gradients::RadialGradient> = + ::bevy_ui::gradients::RadialGradient::in_color_space( + _self.into_inner(), + color_space.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "color_space"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::gradients::RadialGradient, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_radial_gradient_shape_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::gradients::RadialGradientShape, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::gradients::RadialGradientShape>| { + let output: Val<::bevy_ui::gradients::RadialGradientShape> = { + { + let output: Val<::bevy_ui::gradients::RadialGradientShape> = + <::bevy_ui::gradients::RadialGradientShape as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::gradients::RadialGradientShape>, + other: Ref<::bevy_ui::gradients::RadialGradientShape>| { + let output: bool = { + { + let output: bool = + <::bevy_ui::gradients::RadialGradientShape as ::std::cmp::PartialEq< + ::bevy_ui::gradients::RadialGradientShape, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "resolve", + |_self: Val<::bevy_ui::gradients::RadialGradientShape>, + position: Val<::bevy_math::Vec2>, + scale_factor: f32, + physical_size: Val<::bevy_math::Vec2>, + physical_target_size: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = + ::bevy_ui::gradients::RadialGradientShape::resolve( + _self.into_inner(), + position.into_inner(), + scale_factor, + physical_size.into_inner(), + physical_target_size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Resolve the physical dimensions of the end shape of the radial gradient", + &[ + "_self", + "position", + "scale_factor", + "physical_size", + "physical_target_size", + ], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::gradients::RadialGradientShape, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_conic_gradient_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::gradients::ConicGradient, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::gradients::ConicGradient>| { + let output: Val<::bevy_ui::gradients::ConicGradient> = { + { + let output: Val<::bevy_ui::gradients::ConicGradient> = + <::bevy_ui::gradients::ConicGradient as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::gradients::ConicGradient>, + other: Ref<::bevy_ui::gradients::ConicGradient>| { + let output: bool = { + { + let output: bool = + <::bevy_ui::gradients::ConicGradient as ::std::cmp::PartialEq< + ::bevy_ui::gradients::ConicGradient, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "in_color_space", + |_self: Val<::bevy_ui::gradients::ConicGradient>, + color_space: Val<::bevy_ui::gradients::InterpolationColorSpace>| { + let output: Val<::bevy_ui::gradients::ConicGradient> = { + { + let output: Val<::bevy_ui::gradients::ConicGradient> = + ::bevy_ui::gradients::ConicGradient::in_color_space( + _self.into_inner(), + color_space.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "color_space"], + ) + .register_documented( + "with_position", + |_self: Val<::bevy_ui::gradients::ConicGradient>, + position: Val<::bevy_ui::prelude::UiPosition>| { + let output: Val<::bevy_ui::gradients::ConicGradient> = { + { + let output: Val<::bevy_ui::gradients::ConicGradient> = + ::bevy_ui::gradients::ConicGradient::with_position( + _self.into_inner(), + position.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Sets the position of the gradient", + &["_self", "position"], + ) + .register_documented( + "with_start", + |_self: Val<::bevy_ui::gradients::ConicGradient>, start: f32| { + let output: Val<::bevy_ui::gradients::ConicGradient> = { + { + let output: Val<::bevy_ui::gradients::ConicGradient> = + ::bevy_ui::gradients::ConicGradient::with_start(_self.into_inner(), start) + .into(); + output + } + }; + output + }, + " Sets the starting angle of the gradient in radians", + &["_self", "start"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::gradients::ConicGradient, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_gradient_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::gradients::Gradient, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::gradients::Gradient>| { + let output: Val<::bevy_ui::gradients::Gradient> = { + { + let output: Val<::bevy_ui::gradients::Gradient> = + <::bevy_ui::gradients::Gradient as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::gradients::Gradient>, other: Ref<::bevy_ui::gradients::Gradient>| { + let output: bool = { + { + let output: bool = <::bevy_ui::gradients::Gradient as ::std::cmp::PartialEq< + ::bevy_ui::gradients::Gradient, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "is_empty", + |_self: Ref<::bevy_ui::gradients::Gradient>| { + let output: bool = { + { + let output: bool = ::bevy_ui::gradients::Gradient::is_empty(&_self).into(); + output + } + }; + output + }, + " Returns true if the gradient has no stops.", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::gradients::Gradient, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_background_gradient_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::gradients::BackgroundGradient, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::gradients::BackgroundGradient>| { + let output: Val<::bevy_ui::gradients::BackgroundGradient> = { + { + let output: Val<::bevy_ui::gradients::BackgroundGradient> = + <::bevy_ui::gradients::BackgroundGradient as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::gradients::BackgroundGradient>, + other: Ref<::bevy_ui::gradients::BackgroundGradient>| { + let output: bool = { + { + let output: bool = + <::bevy_ui::gradients::BackgroundGradient as ::std::cmp::PartialEq< + ::bevy_ui::gradients::BackgroundGradient, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::gradients::BackgroundGradient, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_border_gradient_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::gradients::BorderGradient, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::gradients::BorderGradient>| { + let output: Val<::bevy_ui::gradients::BorderGradient> = { + { + let output: Val<::bevy_ui::gradients::BorderGradient> = + <::bevy_ui::gradients::BorderGradient as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::gradients::BorderGradient>, + other: Ref<::bevy_ui::gradients::BorderGradient>| { + let output: bool = { + { + let output: bool = + <::bevy_ui::gradients::BorderGradient as ::std::cmp::PartialEq< + ::bevy_ui::gradients::BorderGradient, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::gradients::BorderGradient, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_val_2_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::ui_transform::Val2, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::ui_transform::Val2>| { + let output: Val<::bevy_ui::ui_transform::Val2> = { + { + let output: Val<::bevy_ui::ui_transform::Val2> = <::bevy_ui::ui_transform::Val2 as ::std::clone::Clone>::clone( + &_self.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::ui_transform::Val2>, + other: Ref<::bevy_ui::ui_transform::Val2>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::ui_transform::Val2 as ::std::cmp::PartialEq< + ::bevy_ui::ui_transform::Val2, + >>::eq(&_self.into_inner(), &other.into_inner()) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "new", + |x: Val<::bevy_ui::prelude::Val>, y: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::ui_transform::Val2> = { + { + let output: Val<::bevy_ui::ui_transform::Val2> = ::bevy_ui::ui_transform::Val2::new( + x.into_inner(), + y.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a new [`Val2`]", + &["x", "y"], + ) + .register_documented( + "percent", + |x: f32, y: f32| { + let output: Val<::bevy_ui::ui_transform::Val2> = { + { + let output: Val<::bevy_ui::ui_transform::Val2> = ::bevy_ui::ui_transform::Val2::percent( + x, + y, + ) + .into(); + output + } + }; + output + }, + " Creates a new [`Val2`] where both components are percentage values", + &["x", "y"], + ) + .register_documented( + "px", + |x: f32, y: f32| { + let output: Val<::bevy_ui::ui_transform::Val2> = { + { + let output: Val<::bevy_ui::ui_transform::Val2> = ::bevy_ui::ui_transform::Val2::px( + x, + y, + ) + .into(); + output + } + }; + output + }, + " Creates a new [`Val2`] where both components are in logical pixels", + &["x", "y"], + ) + .register_documented( + "resolve", + | + _self: Ref<::bevy_ui::ui_transform::Val2>, + scale_factor: f32, + base_size: Val<::bevy_math::Vec2>, + viewport_size: Val<::bevy_math::Vec2>| + { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = ::bevy_ui::ui_transform::Val2::resolve( + &_self.into_inner(), + scale_factor, + base_size.into_inner(), + viewport_size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Resolves this [`Val2`] from the given `scale_factor`, `parent_size`,\n and `viewport_size`.\n Component values of [`Val::Auto`] are resolved to 0.", + &["_self", "scale_factor", "base_size", "viewport_size"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::ui_transform::Val2, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_ui_transform_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::ui_transform::UiTransform, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::ui_transform::UiTransform>| { + let output: Val<::bevy_ui::ui_transform::UiTransform> = { + { + let output: Val<::bevy_ui::ui_transform::UiTransform> = <::bevy_ui::ui_transform::UiTransform as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "compute_affine", + | + _self: Ref<::bevy_ui::ui_transform::UiTransform>, + scale_factor: f32, + base_size: Val<::bevy_math::Vec2>, + target_size: Val<::bevy_math::Vec2>| + { + let output: Val<::bevy_math::Affine2> = { + { + let output: Val<::bevy_math::Affine2> = ::bevy_ui::ui_transform::UiTransform::compute_affine( + &_self, + scale_factor, + base_size.into_inner(), + target_size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Resolves the translation from the given `scale_factor`, `base_value`, and `target_size`\n and returns a 2d affine transform from the resolved translation, and the `UiTransform`'s rotation, and scale.", + &["_self", "scale_factor", "base_size", "target_size"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::ui_transform::UiTransform>, + other: Ref<::bevy_ui::ui_transform::UiTransform>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::ui_transform::UiTransform as ::std::cmp::PartialEq< + ::bevy_ui::ui_transform::UiTransform, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "from_rotation", + |rotation: Val<::bevy_math::Rot2>| { + let output: Val<::bevy_ui::ui_transform::UiTransform> = { + { + let output: Val<::bevy_ui::ui_transform::UiTransform> = ::bevy_ui::ui_transform::UiTransform::from_rotation( + rotation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a UI transform representing a rotation.", + &["rotation"], + ) + .register_documented( + "from_scale", + |scale: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_ui::ui_transform::UiTransform> = { + { + let output: Val<::bevy_ui::ui_transform::UiTransform> = ::bevy_ui::ui_transform::UiTransform::from_scale( + scale.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a UI transform representing a scaling.", + &["scale"], + ) + .register_documented( + "from_translation", + |translation: Val<::bevy_ui::ui_transform::Val2>| { + let output: Val<::bevy_ui::ui_transform::UiTransform> = { + { + let output: Val<::bevy_ui::ui_transform::UiTransform> = ::bevy_ui::ui_transform::UiTransform::from_translation( + translation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a UI transform representing a responsive translation.", + &["translation"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::ui_transform::UiTransform, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_relative_cursor_position_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::RelativeCursorPosition, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::RelativeCursorPosition>| { + let output: Val<::bevy_ui::RelativeCursorPosition> = { + { + let output: Val<::bevy_ui::RelativeCursorPosition> = + <::bevy_ui::RelativeCursorPosition as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "cursor_over", + |_self: Ref<::bevy_ui::RelativeCursorPosition>| { + let output: bool = { + { + let output: bool = + ::bevy_ui::RelativeCursorPosition::cursor_over(&_self).into(); + output + } + }; + output + }, + " A helper function to check if the mouse is over the node", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::RelativeCursorPosition>, + other: Ref<::bevy_ui::RelativeCursorPosition>| { + let output: bool = { + { + let output: bool = + <::bevy_ui::RelativeCursorPosition as ::std::cmp::PartialEq< + ::bevy_ui::RelativeCursorPosition, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::RelativeCursorPosition, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_ui_rect_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::UiRect, + >::new(world) + .register_documented( + "all", + |value: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiRect> = { + { + let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::all( + value.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a new [`UiRect`] where all sides have the same value.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = UiRect::all(Val::Px(10.0));\n assert_eq!(ui_rect.left, Val::Px(10.0));\n assert_eq!(ui_rect.right, Val::Px(10.0));\n assert_eq!(ui_rect.top, Val::Px(10.0));\n assert_eq!(ui_rect.bottom, Val::Px(10.0));\n ```", + &["value"], + ) + .register_documented( + "axes", + | + horizontal: Val<::bevy_ui::prelude::Val>, + vertical: Val<::bevy_ui::prelude::Val>| + { + let output: Val<::bevy_ui::prelude::UiRect> = { + { + let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::axes( + horizontal.into_inner(), + vertical.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a new [`UiRect`] where both `left` and `right` take the value of `horizontal`, and both `top` and `bottom` take the value of `vertical`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = UiRect::axes(Val::Px(10.0), Val::Percent(15.0));\n assert_eq!(ui_rect.left, Val::Px(10.0));\n assert_eq!(ui_rect.right, Val::Px(10.0));\n assert_eq!(ui_rect.top, Val::Percent(15.0));\n assert_eq!(ui_rect.bottom, Val::Percent(15.0));\n ```", + &["horizontal", "vertical"], + ) + .register_documented( + "bottom", + |bottom: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiRect> = { + { + let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::bottom( + bottom.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a new [`UiRect`] where `bottom` takes the given value,\n and the other fields are set to `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = UiRect::bottom(Val::Px(10.0));\n assert_eq!(ui_rect.left, Val::ZERO);\n assert_eq!(ui_rect.right, Val::ZERO);\n assert_eq!(ui_rect.top, Val::ZERO);\n assert_eq!(ui_rect.bottom, Val::Px(10.0));\n ```", + &["bottom"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::UiRect>| { + let output: Val<::bevy_ui::prelude::UiRect> = { + { + let output: Val<::bevy_ui::prelude::UiRect> = <::bevy_ui::prelude::UiRect as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::UiRect>, + other: Ref<::bevy_ui::prelude::UiRect>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::UiRect as ::std::cmp::PartialEq< + ::bevy_ui::prelude::UiRect, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "horizontal", + |value: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiRect> = { + { + let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::horizontal( + value.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a new [`UiRect`] where `left` and `right` take the given value,\n and `top` and `bottom` set to zero `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = UiRect::horizontal(Val::Px(10.0));\n assert_eq!(ui_rect.left, Val::Px(10.0));\n assert_eq!(ui_rect.right, Val::Px(10.0));\n assert_eq!(ui_rect.top, Val::ZERO);\n assert_eq!(ui_rect.bottom, Val::ZERO);\n ```", + &["value"], + ) + .register_documented( + "left", + |left: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiRect> = { + { + let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::left( + left.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a new [`UiRect`] where `left` takes the given value, and\n the other fields are set to `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = UiRect::left(Val::Px(10.0));\n assert_eq!(ui_rect.left, Val::Px(10.0));\n assert_eq!(ui_rect.right, Val::ZERO);\n assert_eq!(ui_rect.top, Val::ZERO);\n assert_eq!(ui_rect.bottom, Val::ZERO);\n ```", + &["left"], + ) + .register_documented( + "new", + | + left: Val<::bevy_ui::prelude::Val>, + right: Val<::bevy_ui::prelude::Val>, + top: Val<::bevy_ui::prelude::Val>, + bottom: Val<::bevy_ui::prelude::Val>| + { + let output: Val<::bevy_ui::prelude::UiRect> = { + { + let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::new( + left.into_inner(), + right.into_inner(), + top.into_inner(), + bottom.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a new [`UiRect`] from the values specified.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = UiRect::new(\n Val::Px(10.0),\n Val::Px(20.0),\n Val::Px(30.0),\n Val::Px(40.0),\n );\n assert_eq!(ui_rect.left, Val::Px(10.0));\n assert_eq!(ui_rect.right, Val::Px(20.0));\n assert_eq!(ui_rect.top, Val::Px(30.0));\n assert_eq!(ui_rect.bottom, Val::Px(40.0));\n ```", + &["left", "right", "top", "bottom"], + ) + .register_documented( + "percent", + |left: f32, right: f32, top: f32, bottom: f32| { + let output: Val<::bevy_ui::prelude::UiRect> = { + { + let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::percent( + left, + right, + top, + bottom, + ) + .into(); + output + } + }; + output + }, + " Creates a new [`UiRect`] from the values specified in percentages.\n This is a shortcut for [`UiRect::new()`], applying [`Val::Percent`] to all arguments.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = UiRect::percent(5., 10., 2., 1.);\n assert_eq!(ui_rect.left, Val::Percent(5.));\n assert_eq!(ui_rect.right, Val::Percent(10.));\n assert_eq!(ui_rect.top, Val::Percent(2.));\n assert_eq!(ui_rect.bottom, Val::Percent(1.));\n ```", + &["left", "right", "top", "bottom"], + ) + .register_documented( + "px", + |left: f32, right: f32, top: f32, bottom: f32| { + let output: Val<::bevy_ui::prelude::UiRect> = { + { + let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::px( + left, + right, + top, + bottom, + ) + .into(); + output + } + }; + output + }, + " Creates a new [`UiRect`] from the values specified in logical pixels.\n This is a shortcut for [`UiRect::new()`], applying [`Val::Px`] to all arguments.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = UiRect::px(10., 20., 30., 40.);\n assert_eq!(ui_rect.left, Val::Px(10.));\n assert_eq!(ui_rect.right, Val::Px(20.));\n assert_eq!(ui_rect.top, Val::Px(30.));\n assert_eq!(ui_rect.bottom, Val::Px(40.));\n ```", + &["left", "right", "top", "bottom"], + ) + .register_documented( + "right", + |right: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiRect> = { + { + let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::right( + right.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a new [`UiRect`] where `right` takes the given value,\n and the other fields are set to `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = UiRect::right(Val::Px(10.0));\n assert_eq!(ui_rect.left, Val::ZERO);\n assert_eq!(ui_rect.right, Val::Px(10.0));\n assert_eq!(ui_rect.top, Val::ZERO);\n assert_eq!(ui_rect.bottom, Val::ZERO);\n ```", + &["right"], + ) + .register_documented( + "top", + |top: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiRect> = { + { + let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::top( + top.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a new [`UiRect`] where `top` takes the given value,\n and the other fields are set to `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = UiRect::top(Val::Px(10.0));\n assert_eq!(ui_rect.left, Val::ZERO);\n assert_eq!(ui_rect.right, Val::ZERO);\n assert_eq!(ui_rect.top, Val::Px(10.0));\n assert_eq!(ui_rect.bottom, Val::ZERO);\n ```", + &["top"], + ) + .register_documented( + "vertical", + |value: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiRect> = { + { + let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::vertical( + value.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a new [`UiRect`] where `top` and `bottom` take the given value,\n and `left` and `right` are set to `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = UiRect::vertical(Val::Px(10.0));\n assert_eq!(ui_rect.left, Val::ZERO);\n assert_eq!(ui_rect.right, Val::ZERO);\n assert_eq!(ui_rect.top, Val::Px(10.0));\n assert_eq!(ui_rect.bottom, Val::Px(10.0));\n ```", + &["value"], + ) + .register_documented( + "with_bottom", + | + _self: Val<::bevy_ui::prelude::UiRect>, + bottom: Val<::bevy_ui::prelude::Val>| + { + let output: Val<::bevy_ui::prelude::UiRect> = { + { + let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::with_bottom( + _self.into_inner(), + bottom.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the [`UiRect`] with its `bottom` field set to the given value.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = UiRect::all(Val::Px(20.0)).with_bottom(Val::Px(10.0));\n assert_eq!(ui_rect.left, Val::Px(20.0));\n assert_eq!(ui_rect.right, Val::Px(20.0));\n assert_eq!(ui_rect.top, Val::Px(20.0));\n assert_eq!(ui_rect.bottom, Val::Px(10.0));\n ```", + &["_self", "bottom"], + ) + .register_documented( + "with_left", + |_self: Val<::bevy_ui::prelude::UiRect>, left: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiRect> = { + { + let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::with_left( + _self.into_inner(), + left.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the [`UiRect`] with its `left` field set to the given value.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = UiRect::all(Val::Px(20.0)).with_left(Val::Px(10.0));\n assert_eq!(ui_rect.left, Val::Px(10.0));\n assert_eq!(ui_rect.right, Val::Px(20.0));\n assert_eq!(ui_rect.top, Val::Px(20.0));\n assert_eq!(ui_rect.bottom, Val::Px(20.0));\n ```", + &["_self", "left"], + ) + .register_documented( + "with_right", + | + _self: Val<::bevy_ui::prelude::UiRect>, + right: Val<::bevy_ui::prelude::Val>| + { + let output: Val<::bevy_ui::prelude::UiRect> = { + { + let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::with_right( + _self.into_inner(), + right.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the [`UiRect`] with its `right` field set to the given value.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = UiRect::all(Val::Px(20.0)).with_right(Val::Px(10.0));\n assert_eq!(ui_rect.left, Val::Px(20.0));\n assert_eq!(ui_rect.right, Val::Px(10.0));\n assert_eq!(ui_rect.top, Val::Px(20.0));\n assert_eq!(ui_rect.bottom, Val::Px(20.0));\n ```", + &["_self", "right"], + ) + .register_documented( + "with_top", + |_self: Val<::bevy_ui::prelude::UiRect>, top: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::UiRect> = { + { + let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::with_top( + _self.into_inner(), + top.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the [`UiRect`] with its `top` field set to the given value.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = UiRect::all(Val::Px(20.0)).with_top(Val::Px(10.0));\n assert_eq!(ui_rect.left, Val::Px(20.0));\n assert_eq!(ui_rect.right, Val::Px(20.0));\n assert_eq!(ui_rect.top, Val::Px(10.0));\n assert_eq!(ui_rect.bottom, Val::Px(20.0));\n ```", + &["_self", "top"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::UiRect, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_border_radius_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::BorderRadius, + >::new(world) + .register_documented( + "all", + |radius: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::BorderRadius> = { + { + let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::all( + radius.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Set all four corners to the same curvature.", + &["radius"], + ) + .register_documented( + "bottom", + |radius: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::BorderRadius> = { + { + let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::bottom( + radius.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Sets the radii for the bottom left and bottom right corners.\n Remaining corners will be right-angled.", + &["radius"], + ) + .register_documented( + "bottom_left", + |radius: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::BorderRadius> = { + { + let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::bottom_left( + radius.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Sets the radius for the bottom left corner.\n Remaining corners will be right-angled.", + &["radius"], + ) + .register_documented( + "bottom_right", + |radius: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::BorderRadius> = { + { + let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::bottom_right( + radius.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Sets the radius for the bottom right corner.\n Remaining corners will be right-angled.", + &["radius"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::BorderRadius>| { + let output: Val<::bevy_ui::prelude::BorderRadius> = { + { + let output: Val<::bevy_ui::prelude::BorderRadius> = <::bevy_ui::prelude::BorderRadius as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::BorderRadius>, + other: Ref<::bevy_ui::prelude::BorderRadius>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::BorderRadius as ::std::cmp::PartialEq< + ::bevy_ui::prelude::BorderRadius, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "left", + |radius: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::BorderRadius> = { + { + let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::left( + radius.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Sets the radii for the top left and bottom left corners.\n Remaining corners will be right-angled.", + &["radius"], + ) + .register_documented( + "new", + | + top_left: Val<::bevy_ui::prelude::Val>, + top_right: Val<::bevy_ui::prelude::Val>, + bottom_right: Val<::bevy_ui::prelude::Val>, + bottom_left: Val<::bevy_ui::prelude::Val>| + { + let output: Val<::bevy_ui::prelude::BorderRadius> = { + { + let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::new( + top_left.into_inner(), + top_right.into_inner(), + bottom_right.into_inner(), + bottom_left.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["top_left", "top_right", "bottom_right", "bottom_left"], + ) + .register_documented( + "percent", + |top_left: f32, top_right: f32, bottom_right: f32, bottom_left: f32| { + let output: Val<::bevy_ui::prelude::BorderRadius> = { + { + let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::percent( + top_left, + top_right, + bottom_right, + bottom_left, + ) + .into(); + output + } + }; + output + }, + " Sets the radii to percentage values.", + &["top_left", "top_right", "bottom_right", "bottom_left"], + ) + .register_documented( + "px", + |top_left: f32, top_right: f32, bottom_right: f32, bottom_left: f32| { + let output: Val<::bevy_ui::prelude::BorderRadius> = { + { + let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::px( + top_left, + top_right, + bottom_right, + bottom_left, + ) + .into(); + output + } + }; + output + }, + " Sets the radii to logical pixel values.", + &["top_left", "top_right", "bottom_right", "bottom_left"], + ) + .register_documented( + "resolve", + | + _self: Ref<::bevy_ui::prelude::BorderRadius>, + scale_factor: f32, + node_size: Val<::bevy_math::Vec2>, + viewport_size: Val<::bevy_math::Vec2>| + { + let output: Val<::bevy_ui::prelude::ResolvedBorderRadius> = { + { + let output: Val<::bevy_ui::prelude::ResolvedBorderRadius> = ::bevy_ui::prelude::BorderRadius::resolve( + &_self, + scale_factor, + node_size.into_inner(), + viewport_size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Resolve the border radii for the corners from the given context values.\n Returns the radii of the each corner in physical pixels.", + &["_self", "scale_factor", "node_size", "viewport_size"], + ) + .register_documented( + "resolve_single_corner", + | + radius: Val<::bevy_ui::prelude::Val>, + scale_factor: f32, + min_length: f32, + viewport_size: Val<::bevy_math::Vec2>| + { + let output: f32 = { + { + let output: f32 = ::bevy_ui::prelude::BorderRadius::resolve_single_corner( + radius.into_inner(), + scale_factor, + min_length, + viewport_size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Resolve the border radius for a single corner from the given context values.\n Returns the radius of the corner in physical pixels.", + &["radius", "scale_factor", "min_length", "viewport_size"], + ) + .register_documented( + "right", + |radius: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::BorderRadius> = { + { + let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::right( + radius.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Sets the radii for the top right and bottom right corners.\n Remaining corners will be right-angled.", + &["radius"], + ) + .register_documented( + "top", + |radius: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::BorderRadius> = { + { + let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::top( + radius.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Sets the radii for the top left and top right corners.\n Remaining corners will be right-angled.", + &["radius"], + ) + .register_documented( + "top_left", + |radius: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::BorderRadius> = { + { + let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::top_left( + radius.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Sets the radius for the top left corner.\n Remaining corners will be right-angled.", + &["radius"], + ) + .register_documented( + "top_right", + |radius: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::BorderRadius> = { + { + let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::top_right( + radius.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Sets the radius for the top right corner.\n Remaining corners will be right-angled.", + &["radius"], + ) + .register_documented( + "with_bottom", + | + _self: Val<::bevy_ui::prelude::BorderRadius>, + radius: Val<::bevy_ui::prelude::Val>| + { + let output: Val<::bevy_ui::prelude::BorderRadius> = { + { + let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::with_bottom( + _self.into_inner(), + radius.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the [`BorderRadius`] with its `bottom_left` and `bottom_right` fields set to the given value.", + &["_self", "radius"], + ) + .register_documented( + "with_bottom_left", + | + _self: Val<::bevy_ui::prelude::BorderRadius>, + radius: Val<::bevy_ui::prelude::Val>| + { + let output: Val<::bevy_ui::prelude::BorderRadius> = { + { + let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::with_bottom_left( + _self.into_inner(), + radius.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the [`BorderRadius`] with its `bottom_left` field set to the given value.", + &["_self", "radius"], + ) + .register_documented( + "with_bottom_right", + | + _self: Val<::bevy_ui::prelude::BorderRadius>, + radius: Val<::bevy_ui::prelude::Val>| + { + let output: Val<::bevy_ui::prelude::BorderRadius> = { + { + let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::with_bottom_right( + _self.into_inner(), + radius.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the [`BorderRadius`] with its `bottom_right` field set to the given value.", + &["_self", "radius"], + ) + .register_documented( + "with_left", + | + _self: Val<::bevy_ui::prelude::BorderRadius>, + radius: Val<::bevy_ui::prelude::Val>| + { + let output: Val<::bevy_ui::prelude::BorderRadius> = { + { + let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::with_left( + _self.into_inner(), + radius.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the [`BorderRadius`] with its `top_left` and `bottom_left` fields set to the given value.", + &["_self", "radius"], + ) + .register_documented( + "with_right", + | + _self: Val<::bevy_ui::prelude::BorderRadius>, + radius: Val<::bevy_ui::prelude::Val>| + { + let output: Val<::bevy_ui::prelude::BorderRadius> = { + { + let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::with_right( + _self.into_inner(), + radius.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the [`BorderRadius`] with its `top_right` and `bottom_right` fields set to the given value.", + &["_self", "radius"], + ) + .register_documented( + "with_top", + | + _self: Val<::bevy_ui::prelude::BorderRadius>, + radius: Val<::bevy_ui::prelude::Val>| + { + let output: Val<::bevy_ui::prelude::BorderRadius> = { + { + let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::with_top( + _self.into_inner(), + radius.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the [`BorderRadius`] with its `top_left` and `top_right` fields set to the given value.", + &["_self", "radius"], + ) + .register_documented( + "with_top_left", + | + _self: Val<::bevy_ui::prelude::BorderRadius>, + radius: Val<::bevy_ui::prelude::Val>| + { + let output: Val<::bevy_ui::prelude::BorderRadius> = { + { + let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::with_top_left( + _self.into_inner(), + radius.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the [`BorderRadius`] with its `top_left` field set to the given value.", + &["_self", "radius"], + ) + .register_documented( + "with_top_right", + | + _self: Val<::bevy_ui::prelude::BorderRadius>, + radius: Val<::bevy_ui::prelude::Val>| + { + let output: Val<::bevy_ui::prelude::BorderRadius> = { + { + let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::with_top_right( + _self.into_inner(), + radius.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the [`BorderRadius`] with its `top_right` field set to the given value.", + &["_self", "radius"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::BorderRadius, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_layout_config_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::LayoutConfig, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::LayoutConfig>| { + let output: Val<::bevy_ui::prelude::LayoutConfig> = { + { + let output: Val<::bevy_ui::prelude::LayoutConfig> = + <::bevy_ui::prelude::LayoutConfig as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::prelude::LayoutConfig>, + other: Ref<::bevy_ui::prelude::LayoutConfig>| { + let output: bool = { + { + let output: bool = + <::bevy_ui::prelude::LayoutConfig as ::std::cmp::PartialEq< + ::bevy_ui::prelude::LayoutConfig, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::LayoutConfig, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_outline_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::Outline, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::Outline>| { + let output: Val<::bevy_ui::prelude::Outline> = { + { + let output: Val<::bevy_ui::prelude::Outline> = <::bevy_ui::prelude::Outline as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::Outline>, + other: Ref<::bevy_ui::prelude::Outline>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::Outline as ::std::cmp::PartialEq< + ::bevy_ui::prelude::Outline, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "new", + | + width: Val<::bevy_ui::prelude::Val>, + offset: Val<::bevy_ui::prelude::Val>, + color: Val<::bevy_color::Color>| + { + let output: Val<::bevy_ui::prelude::Outline> = { + { + let output: Val<::bevy_ui::prelude::Outline> = ::bevy_ui::prelude::Outline::new( + width.into_inner(), + offset.into_inner(), + color.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new outline", + &["width", "offset", "color"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::Outline, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_scroll_position_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::ScrollPosition, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::ScrollPosition>| { + let output: Val<::bevy_ui::prelude::ScrollPosition> = { + { + let output: Val<::bevy_ui::prelude::ScrollPosition> = + <::bevy_ui::prelude::ScrollPosition as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::ScrollPosition, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_position_type_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::PositionType, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::prelude::PositionType>| { + let output: () = { + { + let output: () = <::bevy_ui::prelude::PositionType as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::PositionType>| { + let output: Val<::bevy_ui::prelude::PositionType> = { + { + let output: Val<::bevy_ui::prelude::PositionType> = <::bevy_ui::prelude::PositionType as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::PositionType>, + other: Ref<::bevy_ui::prelude::PositionType>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::PositionType as ::std::cmp::PartialEq< + ::bevy_ui::prelude::PositionType, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::PositionType, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_align_self_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::AlignSelf, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::prelude::AlignSelf>| { + let output: () = { + { + let output: () = <::bevy_ui::prelude::AlignSelf as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::AlignSelf>| { + let output: Val<::bevy_ui::prelude::AlignSelf> = { + { + let output: Val<::bevy_ui::prelude::AlignSelf> = <::bevy_ui::prelude::AlignSelf as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::AlignSelf>, + other: Ref<::bevy_ui::prelude::AlignSelf>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::AlignSelf as ::std::cmp::PartialEq< + ::bevy_ui::prelude::AlignSelf, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::AlignSelf, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_repeated_grid_track_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::RepeatedGridTrack, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::RepeatedGridTrack>| { + let output: Val<::bevy_ui::prelude::RepeatedGridTrack> = { + { + let output: Val<::bevy_ui::prelude::RepeatedGridTrack> = + <::bevy_ui::prelude::RepeatedGridTrack as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::prelude::RepeatedGridTrack>, + other: Ref<::bevy_ui::prelude::RepeatedGridTrack>| { + let output: bool = { + { + let output: bool = + <::bevy_ui::prelude::RepeatedGridTrack as ::std::cmp::PartialEq< + ::bevy_ui::prelude::RepeatedGridTrack, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::RepeatedGridTrack, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_align_content_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::AlignContent, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::prelude::AlignContent>| { + let output: () = { + { + let output: () = <::bevy_ui::prelude::AlignContent as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::AlignContent>| { + let output: Val<::bevy_ui::prelude::AlignContent> = { + { + let output: Val<::bevy_ui::prelude::AlignContent> = <::bevy_ui::prelude::AlignContent as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::AlignContent>, + other: Ref<::bevy_ui::prelude::AlignContent>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::AlignContent as ::std::cmp::PartialEq< + ::bevy_ui::prelude::AlignContent, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::AlignContent, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_align_items_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::AlignItems, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::prelude::AlignItems>| { + let output: () = { + { + let output: () = <::bevy_ui::prelude::AlignItems as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::AlignItems>| { + let output: Val<::bevy_ui::prelude::AlignItems> = { + { + let output: Val<::bevy_ui::prelude::AlignItems> = <::bevy_ui::prelude::AlignItems as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::AlignItems>, + other: Ref<::bevy_ui::prelude::AlignItems>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::AlignItems as ::std::cmp::PartialEq< + ::bevy_ui::prelude::AlignItems, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::AlignItems, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_box_sizing_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::BoxSizing, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::prelude::BoxSizing>| { + let output: () = { + { + let output: () = <::bevy_ui::prelude::BoxSizing as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::BoxSizing>| { + let output: Val<::bevy_ui::prelude::BoxSizing> = { + { + let output: Val<::bevy_ui::prelude::BoxSizing> = <::bevy_ui::prelude::BoxSizing as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::BoxSizing>, + other: Ref<::bevy_ui::prelude::BoxSizing>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::BoxSizing as ::std::cmp::PartialEq< + ::bevy_ui::prelude::BoxSizing, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::BoxSizing, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_flex_direction_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::FlexDirection, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::prelude::FlexDirection>| { + let output: () = { + { + let output: () = <::bevy_ui::prelude::FlexDirection as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::FlexDirection>| { + let output: Val<::bevy_ui::prelude::FlexDirection> = { + { + let output: Val<::bevy_ui::prelude::FlexDirection> = <::bevy_ui::prelude::FlexDirection as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::FlexDirection>, + other: Ref<::bevy_ui::prelude::FlexDirection>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::FlexDirection as ::std::cmp::PartialEq< + ::bevy_ui::prelude::FlexDirection, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::FlexDirection, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_flex_wrap_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::FlexWrap, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::prelude::FlexWrap>| { + let output: () = { + { + let output: () = <::bevy_ui::prelude::FlexWrap as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::FlexWrap>| { + let output: Val<::bevy_ui::prelude::FlexWrap> = { + { + let output: Val<::bevy_ui::prelude::FlexWrap> = <::bevy_ui::prelude::FlexWrap as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::FlexWrap>, + other: Ref<::bevy_ui::prelude::FlexWrap>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::FlexWrap as ::std::cmp::PartialEq< + ::bevy_ui::prelude::FlexWrap, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::FlexWrap, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_grid_auto_flow_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::GridAutoFlow, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::prelude::GridAutoFlow>| { + let output: () = { + { + let output: () = <::bevy_ui::prelude::GridAutoFlow as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::GridAutoFlow>| { + let output: Val<::bevy_ui::prelude::GridAutoFlow> = { + { + let output: Val<::bevy_ui::prelude::GridAutoFlow> = <::bevy_ui::prelude::GridAutoFlow as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::GridAutoFlow>, + other: Ref<::bevy_ui::prelude::GridAutoFlow>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::GridAutoFlow as ::std::cmp::PartialEq< + ::bevy_ui::prelude::GridAutoFlow, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::GridAutoFlow, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_grid_placement_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::GridPlacement, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::prelude::GridPlacement>| { + let output: () = { + { + let output: () = <::bevy_ui::prelude::GridPlacement as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "auto", + || { + let output: Val<::bevy_ui::prelude::GridPlacement> = { + { + let output: Val<::bevy_ui::prelude::GridPlacement> = ::bevy_ui::prelude::GridPlacement::auto() + .into(); + output + } + }; + output + }, + " Place the grid item automatically (letting the `span` default to `1`).", + &[], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::GridPlacement>| { + let output: Val<::bevy_ui::prelude::GridPlacement> = { + { + let output: Val<::bevy_ui::prelude::GridPlacement> = <::bevy_ui::prelude::GridPlacement as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "end", + |end: i16| { + let output: Val<::bevy_ui::prelude::GridPlacement> = { + { + let output: Val<::bevy_ui::prelude::GridPlacement> = ::bevy_ui::prelude::GridPlacement::end( + end, + ) + .into(); + output + } + }; + output + }, + " Place the grid item specifying the `end` grid line (letting the `span` default to `1`).\n # Panics\n Panics if `end` is `0`.", + &["end"], + ) + .register_documented( + "end_span", + |end: i16, span: u16| { + let output: Val<::bevy_ui::prelude::GridPlacement> = { + { + let output: Val<::bevy_ui::prelude::GridPlacement> = ::bevy_ui::prelude::GridPlacement::end_span( + end, + span, + ) + .into(); + output + } + }; + output + }, + " Place the grid item specifying the `end` grid line and how many tracks it should `span`.\n # Panics\n Panics if `end` or `span` is `0`.", + &["end", "span"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::GridPlacement>, + other: Ref<::bevy_ui::prelude::GridPlacement>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::GridPlacement as ::std::cmp::PartialEq< + ::bevy_ui::prelude::GridPlacement, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "get_end", + |_self: Val<::bevy_ui::prelude::GridPlacement>| { + let output: ::std::option::Option = { + { + let output: ::std::option::Option = ::bevy_ui::prelude::GridPlacement::get_end( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the grid line at which the item should end, or `None` if not set.", + &["_self"], + ) + .register_documented( + "get_span", + |_self: Val<::bevy_ui::prelude::GridPlacement>| { + let output: ::std::option::Option = { + { + let output: ::std::option::Option = ::bevy_ui::prelude::GridPlacement::get_span( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns span for this grid item, or `None` if not set.", + &["_self"], + ) + .register_documented( + "get_start", + |_self: Val<::bevy_ui::prelude::GridPlacement>| { + let output: ::std::option::Option = { + { + let output: ::std::option::Option = ::bevy_ui::prelude::GridPlacement::get_start( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the grid line at which the item should start, or `None` if not set.", + &["_self"], + ) + .register_documented( + "set_end", + |_self: Val<::bevy_ui::prelude::GridPlacement>, end: i16| { + let output: Val<::bevy_ui::prelude::GridPlacement> = { + { + let output: Val<::bevy_ui::prelude::GridPlacement> = ::bevy_ui::prelude::GridPlacement::set_end( + _self.into_inner(), + end, + ) + .into(); + output + } + }; + output + }, + " Mutate the item, setting the `end` grid line\n # Panics\n Panics if `end` is `0`.", + &["_self", "end"], + ) + .register_documented( + "set_span", + |_self: Val<::bevy_ui::prelude::GridPlacement>, span: u16| { + let output: Val<::bevy_ui::prelude::GridPlacement> = { + { + let output: Val<::bevy_ui::prelude::GridPlacement> = ::bevy_ui::prelude::GridPlacement::set_span( + _self.into_inner(), + span, + ) + .into(); + output + } + }; + output + }, + " Mutate the item, setting the number of tracks the item should `span`\n # Panics\n Panics if `span` is `0`.", + &["_self", "span"], + ) + .register_documented( + "set_start", + |_self: Val<::bevy_ui::prelude::GridPlacement>, start: i16| { + let output: Val<::bevy_ui::prelude::GridPlacement> = { + { + let output: Val<::bevy_ui::prelude::GridPlacement> = ::bevy_ui::prelude::GridPlacement::set_start( + _self.into_inner(), + start, + ) + .into(); + output + } + }; + output + }, + " Mutate the item, setting the `start` grid line\n # Panics\n Panics if `start` is `0`.", + &["_self", "start"], + ) + .register_documented( + "span", + |span: u16| { + let output: Val<::bevy_ui::prelude::GridPlacement> = { + { + let output: Val<::bevy_ui::prelude::GridPlacement> = ::bevy_ui::prelude::GridPlacement::span( + span, + ) + .into(); + output + } + }; + output + }, + " Place the grid item automatically, specifying how many tracks it should `span`.\n # Panics\n Panics if `span` is `0`.", + &["span"], + ) + .register_documented( + "start", + |start: i16| { + let output: Val<::bevy_ui::prelude::GridPlacement> = { + { + let output: Val<::bevy_ui::prelude::GridPlacement> = ::bevy_ui::prelude::GridPlacement::start( + start, + ) + .into(); + output + } + }; + output + }, + " Place the grid item specifying the `start` grid line (letting the `span` default to `1`).\n # Panics\n Panics if `start` is `0`.", + &["start"], + ) + .register_documented( + "start_end", + |start: i16, end: i16| { + let output: Val<::bevy_ui::prelude::GridPlacement> = { + { + let output: Val<::bevy_ui::prelude::GridPlacement> = ::bevy_ui::prelude::GridPlacement::start_end( + start, + end, + ) + .into(); + output + } + }; + output + }, + " Place the grid item specifying `start` and `end` grid lines (`span` will be inferred)\n # Panics\n Panics if `start` or `end` is `0`.", + &["start", "end"], + ) + .register_documented( + "start_span", + |start: i16, span: u16| { + let output: Val<::bevy_ui::prelude::GridPlacement> = { + { + let output: Val<::bevy_ui::prelude::GridPlacement> = ::bevy_ui::prelude::GridPlacement::start_span( + start, + span, + ) + .into(); + output + } + }; + output + }, + " Place the grid item specifying the `start` grid line and how many tracks it should `span`.\n # Panics\n Panics if `start` or `span` is `0`.", + &["start", "span"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::GridPlacement, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_grid_track_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::GridTrack, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::GridTrack>| { + let output: Val<::bevy_ui::prelude::GridTrack> = { + { + let output: Val<::bevy_ui::prelude::GridTrack> = + <::bevy_ui::prelude::GridTrack as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::prelude::GridTrack>, other: Ref<::bevy_ui::prelude::GridTrack>| { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::GridTrack as ::std::cmp::PartialEq< + ::bevy_ui::prelude::GridTrack, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::GridTrack, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_grid_track_repetition_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::GridTrackRepetition, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::GridTrackRepetition>| { + let output: Val<::bevy_ui::prelude::GridTrackRepetition> = { + { + let output: Val<::bevy_ui::prelude::GridTrackRepetition> = + <::bevy_ui::prelude::GridTrackRepetition as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::prelude::GridTrackRepetition>, + other: Ref<::bevy_ui::prelude::GridTrackRepetition>| { + let output: bool = { + { + let output: bool = + <::bevy_ui::prelude::GridTrackRepetition as ::std::cmp::PartialEq< + ::bevy_ui::prelude::GridTrackRepetition, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::GridTrackRepetition, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_justify_content_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::JustifyContent, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::prelude::JustifyContent>| { + let output: () = { + { + let output: () = <::bevy_ui::prelude::JustifyContent as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::JustifyContent>| { + let output: Val<::bevy_ui::prelude::JustifyContent> = { + { + let output: Val<::bevy_ui::prelude::JustifyContent> = <::bevy_ui::prelude::JustifyContent as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::JustifyContent>, + other: Ref<::bevy_ui::prelude::JustifyContent>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::JustifyContent as ::std::cmp::PartialEq< + ::bevy_ui::prelude::JustifyContent, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::JustifyContent, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_justify_items_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::JustifyItems, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::prelude::JustifyItems>| { + let output: () = { + { + let output: () = <::bevy_ui::prelude::JustifyItems as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::JustifyItems>| { + let output: Val<::bevy_ui::prelude::JustifyItems> = { + { + let output: Val<::bevy_ui::prelude::JustifyItems> = <::bevy_ui::prelude::JustifyItems as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::JustifyItems>, + other: Ref<::bevy_ui::prelude::JustifyItems>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::JustifyItems as ::std::cmp::PartialEq< + ::bevy_ui::prelude::JustifyItems, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::JustifyItems, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_justify_self_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::JustifySelf, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::prelude::JustifySelf>| { + let output: () = { + { + let output: () = <::bevy_ui::prelude::JustifySelf as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::JustifySelf>| { + let output: Val<::bevy_ui::prelude::JustifySelf> = { + { + let output: Val<::bevy_ui::prelude::JustifySelf> = <::bevy_ui::prelude::JustifySelf as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::JustifySelf>, + other: Ref<::bevy_ui::prelude::JustifySelf>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::JustifySelf as ::std::cmp::PartialEq< + ::bevy_ui::prelude::JustifySelf, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::JustifySelf, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_max_track_sizing_function_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::MaxTrackSizingFunction, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::MaxTrackSizingFunction>| { + let output: Val<::bevy_ui::prelude::MaxTrackSizingFunction> = { + { + let output: Val<::bevy_ui::prelude::MaxTrackSizingFunction> = + <::bevy_ui::prelude::MaxTrackSizingFunction as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::prelude::MaxTrackSizingFunction>, + other: Ref<::bevy_ui::prelude::MaxTrackSizingFunction>| { + let output: bool = { + { + let output: bool = + <::bevy_ui::prelude::MaxTrackSizingFunction as ::std::cmp::PartialEq< + ::bevy_ui::prelude::MaxTrackSizingFunction, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::MaxTrackSizingFunction, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_min_track_sizing_function_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::MinTrackSizingFunction, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::MinTrackSizingFunction>| { + let output: Val<::bevy_ui::prelude::MinTrackSizingFunction> = { + { + let output: Val<::bevy_ui::prelude::MinTrackSizingFunction> = + <::bevy_ui::prelude::MinTrackSizingFunction as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::prelude::MinTrackSizingFunction>, + other: Ref<::bevy_ui::prelude::MinTrackSizingFunction>| { + let output: bool = { + { + let output: bool = + <::bevy_ui::prelude::MinTrackSizingFunction as ::std::cmp::PartialEq< + ::bevy_ui::prelude::MinTrackSizingFunction, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::MinTrackSizingFunction, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_overflow_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::Overflow, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::prelude::Overflow>| { + let output: () = { + { + let output: () = <::bevy_ui::prelude::Overflow as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clip", + || { + let output: Val<::bevy_ui::prelude::Overflow> = { + { + let output: Val<::bevy_ui::prelude::Overflow> = ::bevy_ui::prelude::Overflow::clip() + .into(); + output + } + }; + output + }, + " Clip overflowing items on both axes", + &[], + ) + .register_documented( + "clip_x", + || { + let output: Val<::bevy_ui::prelude::Overflow> = { + { + let output: Val<::bevy_ui::prelude::Overflow> = ::bevy_ui::prelude::Overflow::clip_x() + .into(); + output + } + }; + output + }, + " Clip overflowing items on the x axis", + &[], + ) + .register_documented( + "clip_y", + || { + let output: Val<::bevy_ui::prelude::Overflow> = { + { + let output: Val<::bevy_ui::prelude::Overflow> = ::bevy_ui::prelude::Overflow::clip_y() + .into(); + output + } + }; + output + }, + " Clip overflowing items on the y axis", + &[], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::Overflow>| { + let output: Val<::bevy_ui::prelude::Overflow> = { + { + let output: Val<::bevy_ui::prelude::Overflow> = <::bevy_ui::prelude::Overflow as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::Overflow>, + other: Ref<::bevy_ui::prelude::Overflow>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::Overflow as ::std::cmp::PartialEq< + ::bevy_ui::prelude::Overflow, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "hidden", + || { + let output: Val<::bevy_ui::prelude::Overflow> = { + { + let output: Val<::bevy_ui::prelude::Overflow> = ::bevy_ui::prelude::Overflow::hidden() + .into(); + output + } + }; + output + }, + " Hide overflowing items on both axes by influencing layout and then clipping", + &[], + ) + .register_documented( + "hidden_x", + || { + let output: Val<::bevy_ui::prelude::Overflow> = { + { + let output: Val<::bevy_ui::prelude::Overflow> = ::bevy_ui::prelude::Overflow::hidden_x() + .into(); + output + } + }; + output + }, + " Hide overflowing items on the x axis by influencing layout and then clipping", + &[], + ) + .register_documented( + "hidden_y", + || { + let output: Val<::bevy_ui::prelude::Overflow> = { + { + let output: Val<::bevy_ui::prelude::Overflow> = ::bevy_ui::prelude::Overflow::hidden_y() + .into(); + output + } + }; + output + }, + " Hide overflowing items on the y axis by influencing layout and then clipping", + &[], + ) + .register_documented( + "is_visible", + |_self: Ref<::bevy_ui::prelude::Overflow>| { + let output: bool = { + { + let output: bool = ::bevy_ui::prelude::Overflow::is_visible( + &_self, + ) + .into(); + output + } + }; + output + }, + " Overflow is visible on both axes", + &["_self"], + ) + .register_documented( + "scroll", + || { + let output: Val<::bevy_ui::prelude::Overflow> = { + { + let output: Val<::bevy_ui::prelude::Overflow> = ::bevy_ui::prelude::Overflow::scroll() + .into(); + output + } + }; + output + }, + "", + &[], + ) + .register_documented( + "scroll_x", + || { + let output: Val<::bevy_ui::prelude::Overflow> = { + { + let output: Val<::bevy_ui::prelude::Overflow> = ::bevy_ui::prelude::Overflow::scroll_x() + .into(); + output + } + }; + output + }, + " Scroll overflowing items on the x axis", + &[], + ) + .register_documented( + "scroll_y", + || { + let output: Val<::bevy_ui::prelude::Overflow> = { + { + let output: Val<::bevy_ui::prelude::Overflow> = ::bevy_ui::prelude::Overflow::scroll_y() + .into(); + output + } + }; + output + }, + " Scroll overflowing items on the y axis", + &[], + ) + .register_documented( + "visible", + || { + let output: Val<::bevy_ui::prelude::Overflow> = { + { + let output: Val<::bevy_ui::prelude::Overflow> = ::bevy_ui::prelude::Overflow::visible() + .into(); + output + } + }; + output + }, + " Show overflowing items on both axes", + &[], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::Overflow, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_overflow_clip_margin_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::OverflowClipMargin, + >::new(world) + .register_documented( + "border_box", + || { + let output: Val<::bevy_ui::prelude::OverflowClipMargin> = { + { + let output: Val<::bevy_ui::prelude::OverflowClipMargin> = ::bevy_ui::prelude::OverflowClipMargin::border_box() + .into(); + output + } + }; + output + }, + " Clip any content that overflows outside the border box", + &[], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::OverflowClipMargin>| { + let output: Val<::bevy_ui::prelude::OverflowClipMargin> = { + { + let output: Val<::bevy_ui::prelude::OverflowClipMargin> = <::bevy_ui::prelude::OverflowClipMargin as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "content_box", + || { + let output: Val<::bevy_ui::prelude::OverflowClipMargin> = { + { + let output: Val<::bevy_ui::prelude::OverflowClipMargin> = ::bevy_ui::prelude::OverflowClipMargin::content_box() + .into(); + output + } + }; + output + }, + " Clip any content that overflows outside the content box", + &[], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::OverflowClipMargin>, + other: Ref<::bevy_ui::prelude::OverflowClipMargin>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::OverflowClipMargin as ::std::cmp::PartialEq< + ::bevy_ui::prelude::OverflowClipMargin, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "padding_box", + || { + let output: Val<::bevy_ui::prelude::OverflowClipMargin> = { + { + let output: Val<::bevy_ui::prelude::OverflowClipMargin> = ::bevy_ui::prelude::OverflowClipMargin::padding_box() + .into(); + output + } + }; + output + }, + " Clip any content that overflows outside the padding box", + &[], + ) + .register_documented( + "with_margin", + |_self: Val<::bevy_ui::prelude::OverflowClipMargin>, margin: f32| { + let output: Val<::bevy_ui::prelude::OverflowClipMargin> = { + { + let output: Val<::bevy_ui::prelude::OverflowClipMargin> = ::bevy_ui::prelude::OverflowClipMargin::with_margin( + _self.into_inner(), + margin, + ) + .into(); + output + } + }; + output + }, + " Add a margin on each edge of the visual box in logical pixels.\n The width of the margin will be zero if a negative value is set.", + &["_self", "margin"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::OverflowClipMargin, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_global_z_index_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::GlobalZIndex, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::prelude::GlobalZIndex>| { + let output: () = { + { + let output: () = <::bevy_ui::prelude::GlobalZIndex as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::GlobalZIndex>| { + let output: Val<::bevy_ui::prelude::GlobalZIndex> = { + { + let output: Val<::bevy_ui::prelude::GlobalZIndex> = <::bevy_ui::prelude::GlobalZIndex as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::GlobalZIndex>, + other: Ref<::bevy_ui::prelude::GlobalZIndex>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::GlobalZIndex as ::std::cmp::PartialEq< + ::bevy_ui::prelude::GlobalZIndex, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::GlobalZIndex, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_z_index_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::ZIndex, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::prelude::ZIndex>| { + let output: () = { + { + let output: () = <::bevy_ui::prelude::ZIndex as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::ZIndex>| { + let output: Val<::bevy_ui::prelude::ZIndex> = { + { + let output: Val<::bevy_ui::prelude::ZIndex> = <::bevy_ui::prelude::ZIndex as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::prelude::ZIndex>, + other: Ref<::bevy_ui::prelude::ZIndex>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::ZIndex as ::std::cmp::PartialEq< + ::bevy_ui::prelude::ZIndex, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::ZIndex, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_resolved_border_radius_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::ResolvedBorderRadius, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::ResolvedBorderRadius>| { + let output: Val<::bevy_ui::prelude::ResolvedBorderRadius> = { + { + let output: Val<::bevy_ui::prelude::ResolvedBorderRadius> = + <::bevy_ui::prelude::ResolvedBorderRadius as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::prelude::ResolvedBorderRadius>, + other: Ref<::bevy_ui::prelude::ResolvedBorderRadius>| { + let output: bool = { + { + let output: bool = + <::bevy_ui::prelude::ResolvedBorderRadius as ::std::cmp::PartialEq< + ::bevy_ui::prelude::ResolvedBorderRadius, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::ResolvedBorderRadius, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_background_color_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::BackgroundColor, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::BackgroundColor>| { + let output: Val<::bevy_ui::prelude::BackgroundColor> = { + { + let output: Val<::bevy_ui::prelude::BackgroundColor> = + <::bevy_ui::prelude::BackgroundColor as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::prelude::BackgroundColor>, + other: Ref<::bevy_ui::prelude::BackgroundColor>| { + let output: bool = { + { + let output: bool = + <::bevy_ui::prelude::BackgroundColor as ::std::cmp::PartialEq< + ::bevy_ui::prelude::BackgroundColor, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::BackgroundColor, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_border_color_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::BorderColor, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::BorderColor>| { + let output: Val<::bevy_ui::prelude::BorderColor> = { + { + let output: Val<::bevy_ui::prelude::BorderColor> = + <::bevy_ui::prelude::BorderColor as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::prelude::BorderColor>, + other: Ref<::bevy_ui::prelude::BorderColor>| { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::BorderColor as ::std::cmp::PartialEq< + ::bevy_ui::prelude::BorderColor, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "is_fully_transparent", + |_self: Ref<::bevy_ui::prelude::BorderColor>| { + let output: bool = { + { + let output: bool = + ::bevy_ui::prelude::BorderColor::is_fully_transparent(&_self).into(); + output + } + }; + output + }, + " Check if all contained border colors are transparent", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::BorderColor, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_box_shadow_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::BoxShadow, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::BoxShadow>| { + let output: Val<::bevy_ui::prelude::BoxShadow> = { + { + let output: Val<::bevy_ui::prelude::BoxShadow> = + <::bevy_ui::prelude::BoxShadow as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::prelude::BoxShadow>, other: Ref<::bevy_ui::prelude::BoxShadow>| { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::BoxShadow as ::std::cmp::PartialEq< + ::bevy_ui::prelude::BoxShadow, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "new", + |color: Val<::bevy_color::Color>, + x_offset: Val<::bevy_ui::prelude::Val>, + y_offset: Val<::bevy_ui::prelude::Val>, + spread_radius: Val<::bevy_ui::prelude::Val>, + blur_radius: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::prelude::BoxShadow> = { + { + let output: Val<::bevy_ui::prelude::BoxShadow> = + ::bevy_ui::prelude::BoxShadow::new( + color.into_inner(), + x_offset.into_inner(), + y_offset.into_inner(), + spread_radius.into_inner(), + blur_radius.into_inner(), + ) + .into(); + output + } + }; + output + }, + " A single drop shadow", + &[ + "color", + "x_offset", + "y_offset", + "spread_radius", + "blur_radius", + ], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::BoxShadow, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_shadow_style_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::prelude::ShadowStyle, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::prelude::ShadowStyle>| { + let output: Val<::bevy_ui::prelude::ShadowStyle> = { + { + let output: Val<::bevy_ui::prelude::ShadowStyle> = + <::bevy_ui::prelude::ShadowStyle as ::std::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::prelude::ShadowStyle>, + other: Ref<::bevy_ui::prelude::ShadowStyle>| { + let output: bool = { + { + let output: bool = <::bevy_ui::prelude::ShadowStyle as ::std::cmp::PartialEq< + ::bevy_ui::prelude::ShadowStyle, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::prelude::ShadowStyle, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +impl Plugin for BevyUiScriptingPlugin { + fn build(&self, app: &mut App) { + let mut world = app.world_mut(); + register_display_functions(&mut world); + register_ui_picking_camera_functions(&mut world); + register_ui_picking_settings_functions(&mut world); + register_text_functions(&mut world); + register_text_shadow_functions(&mut world); + register_button_functions(&mut world); + register_image_node_functions(&mut world); + register_label_functions(&mut world); + register_node_image_mode_functions(&mut world); + register_viewport_node_functions(&mut world); + register_interaction_functions(&mut world); + register_ui_scale_functions(&mut world); + register_computed_ui_target_camera_functions(&mut world); + register_computed_ui_render_target_info_functions(&mut world); + register_content_size_functions(&mut world); + register_ui_global_transform_functions(&mut world); + register_calculated_clip_functions(&mut world); + register_node_functions(&mut world); + register_overflow_axis_functions(&mut world); + register_ui_target_camera_functions(&mut world); + register_computed_node_functions(&mut world); + register_overflow_clip_box_functions(&mut world); + register_focus_policy_functions(&mut world); + register_image_node_size_functions(&mut world); + register_text_node_flags_functions(&mut world); + register_ui_position_functions(&mut world); + register_val_functions(&mut world); + register_color_stop_functions(&mut world); + register_angular_color_stop_functions(&mut world); + register_linear_gradient_functions(&mut world); + register_interpolation_color_space_functions(&mut world); + register_radial_gradient_functions(&mut world); + register_radial_gradient_shape_functions(&mut world); + register_conic_gradient_functions(&mut world); + register_gradient_functions(&mut world); + register_background_gradient_functions(&mut world); + register_border_gradient_functions(&mut world); + register_val_2_functions(&mut world); + register_ui_transform_functions(&mut world); + register_relative_cursor_position_functions(&mut world); + register_ui_rect_functions(&mut world); + register_border_radius_functions(&mut world); + register_layout_config_functions(&mut world); + register_outline_functions(&mut world); + register_scroll_position_functions(&mut world); + register_position_type_functions(&mut world); + register_align_self_functions(&mut world); + register_repeated_grid_track_functions(&mut world); + register_align_content_functions(&mut world); + register_align_items_functions(&mut world); + register_box_sizing_functions(&mut world); + register_flex_direction_functions(&mut world); + register_flex_wrap_functions(&mut world); + register_grid_auto_flow_functions(&mut world); + register_grid_placement_functions(&mut world); + register_grid_track_functions(&mut world); + register_grid_track_repetition_functions(&mut world); + register_justify_content_functions(&mut world); + register_justify_items_functions(&mut world); + register_justify_self_functions(&mut world); + register_max_track_sizing_function_functions(&mut world); + register_min_track_sizing_function_functions(&mut world); + register_overflow_functions(&mut world); + register_overflow_clip_margin_functions(&mut world); + register_global_z_index_functions(&mut world); + register_z_index_functions(&mut world); + register_resolved_border_radius_functions(&mut world); + register_background_color_functions(&mut world); + register_border_color_functions(&mut world); + register_box_shadow_functions(&mut world); + register_shadow_style_functions(&mut world); + } +} diff --git a/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml b/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml new file mode 100644 index 0000000000..a6c9fd3f62 --- /dev/null +++ b/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml @@ -0,0 +1,63 @@ +[package] +name = "bevy_ui_render_bms_bindings" +description = "Automatically generated bindings for bevy_ui_render crate" +readme = "README.md" +version.workspace = true +edition.workspace = true +authors.workspace = true +license.workspace = true +homepage.workspace = true +repository.workspace = true +keywords.workspace = true +categories.workspace = true + +[dependencies] + + +bevy_mod_scripting_core = { workspace = true } +bevy_mod_scripting_bindings = { workspace = true } +bevy_mod_scripting_derive = { workspace = true } +bevy_ui_render = { version = "0.17.2", features = [], default-features = true} + + +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} + +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} + +bevy_camera = { version = "^0.17.2", features = [], default-features = true} + +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} + +bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} + +bevy_derive = { version = "^0.17.2", features = [], default-features = true} + +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} + +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} + +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} + +bevy_mesh = { version = "^0.17.2", features = [], default-features = true} + +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} + +bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} + +bevy_shader = { version = "^0.17.2", features = [], default-features = true} + +bevy_sprite = { version = "^0.17.2", features = ["bevy_picking", "bevy_window", "bevy_sprite_picking_backend", "bevy_text"], default-features = true} + +bevy_sprite_render = { version = "^0.17.2", features = ["bevy_text", "webgl"], default-features = true} + +bevy_text = { version = "^0.17.2", features = ["default_font"], default-features = true} + +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} + +bevy_ui = { version = "^0.17.2", features = ["bevy_picking", "bevy_ui_picking_backend"], default-features = true} + +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} + +bytemuck = { version = "^1.5", features = [], default-features = true} + + diff --git a/crates/bindings/bevy_ui_render_bms_bindings/README.md b/crates/bindings/bevy_ui_render_bms_bindings/README.md new file mode 100644 index 0000000000..e8b83f801e --- /dev/null +++ b/crates/bindings/bevy_ui_render_bms_bindings/README.md @@ -0,0 +1,4 @@ +# bevy_ui_render bindings +This crate is part of the [bevy_mod_scripting](http://github.com/makspll/bevy_mod_scripting) project. + +The code inside is fully generated via a custom rustc plugin. \ No newline at end of file diff --git a/crates/bindings/bevy_ui_render_bms_bindings/src/lib.rs b/crates/bindings/bevy_ui_render_bms_bindings/src/lib.rs new file mode 100644 index 0000000000..abe7a127c1 --- /dev/null +++ b/crates/bindings/bevy_ui_render_bms_bindings/src/lib.rs @@ -0,0 +1,153 @@ +#![allow(clippy::all)] +#![allow(unused, deprecated, dead_code)] + +use bevy_app::{App, Plugin}; +use bevy_ecs::prelude::*; +use bevy_mod_scripting_bindings::{ + ReflectReference, + function::{ + from::{Mut, Ref, Val}, + namespace::NamespaceBuilder, + }, +}; +use bevy_mod_scripting_derive::script_bindings; +pub struct BevyUiRenderScriptingPlugin; +pub(crate) fn register_box_shadow_samples_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui_render::prelude::BoxShadowSamples, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui_render::prelude::BoxShadowSamples>| { + let output: () = { + { + let output: () = <::bevy_ui_render::prelude::BoxShadowSamples as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui_render::prelude::BoxShadowSamples>| { + let output: Val<::bevy_ui_render::prelude::BoxShadowSamples> = { + { + let output: Val<::bevy_ui_render::prelude::BoxShadowSamples> = <::bevy_ui_render::prelude::BoxShadowSamples as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui_render::prelude::BoxShadowSamples>, + other: Ref<::bevy_ui_render::prelude::BoxShadowSamples>| + { + let output: bool = { + { + let output: bool = <::bevy_ui_render::prelude::BoxShadowSamples as ::std::cmp::PartialEq< + ::bevy_ui_render::prelude::BoxShadowSamples, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui_render::prelude::BoxShadowSamples, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_ui_anti_alias_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui_render::prelude::UiAntiAlias, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui_render::prelude::UiAntiAlias>| { + let output: () = { + { + let output: () = <::bevy_ui_render::prelude::UiAntiAlias as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui_render::prelude::UiAntiAlias>| { + let output: Val<::bevy_ui_render::prelude::UiAntiAlias> = { + { + let output: Val<::bevy_ui_render::prelude::UiAntiAlias> = <::bevy_ui_render::prelude::UiAntiAlias as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui_render::prelude::UiAntiAlias>, + other: Ref<::bevy_ui_render::prelude::UiAntiAlias>| + { + let output: bool = { + { + let output: bool = <::bevy_ui_render::prelude::UiAntiAlias as ::std::cmp::PartialEq< + ::bevy_ui_render::prelude::UiAntiAlias, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui_render::prelude::UiAntiAlias, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +impl Plugin for BevyUiRenderScriptingPlugin { + fn build(&self, app: &mut App) { + let mut world = app.world_mut(); + register_box_shadow_samples_functions(&mut world); + register_ui_anti_alias_functions(&mut world); + } +} From 791daa990f058173572b3e3e54be8ac25d665756 Mon Sep 17 00:00:00 2001 From: makspll Date: Sun, 9 Nov 2025 18:03:09 +0000 Subject: [PATCH 08/22] make sure not to include unstable items from newer nightlies --- codegen/src/args.rs | 38 ++++++ codegen/src/passes/find_methods_and_fields.rs | 25 +++- codegen/templates/footer.tera | 1 - .../bevy_animation_bms_bindings/Cargo.toml | 2 +- .../bevy_camera_bms_bindings/Cargo.toml | 2 +- .../Cargo.toml | 2 +- .../bevy_gizmos_bms_bindings/Cargo.toml | 2 +- .../bevy_image_bms_bindings/Cargo.toml | 2 +- .../bevy_light_bms_bindings/Cargo.toml | 2 +- .../bindings/bevy_pbr_bms_bindings/Cargo.toml | 2 +- .../bevy_post_process_bms_bindings/Cargo.toml | 2 +- .../bevy_reflect_bms_bindings/src/lib.rs | 112 ++++++++++++------ .../bevy_render_bms_bindings/Cargo.toml | 2 +- .../bevy_scene_bms_bindings/Cargo.toml | 2 +- .../Cargo.toml | 2 +- .../bevy_text_bms_bindings/Cargo.toml | 2 +- .../bindings/bevy_ui_bms_bindings/Cargo.toml | 2 +- .../bevy_ui_render_bms_bindings/Cargo.toml | 2 +- 18 files changed, 152 insertions(+), 52 deletions(-) diff --git a/codegen/src/args.rs b/codegen/src/args.rs index 9380af33f4..361fed8eb4 100644 --- a/codegen/src/args.rs +++ b/codegen/src/args.rs @@ -1,5 +1,6 @@ use cargo_metadata::camino::Utf8PathBuf; use clap::{Parser, Subcommand}; +use rustc_hir::RustcVersion; use serde::{Deserialize, Serialize}; #[derive(Parser, Deserialize, Serialize)] @@ -74,6 +75,43 @@ pub struct Args { value_delimiter = ',' )] pub exclude_crates: Option>, + + #[arg( + global = true, + short, + long, + help = "The rust version to consider when looking at stability tags etc", + default_value = "1.88.0" + )] + pub minimum_supported_rust_version_target: Option, +} + +impl Args { + /// Returns false if the minimum rustc target is not specified, or specified but smaller than the given version + pub fn rustc_version_is_greater_than_mrsv_target(&self, version: RustcVersion) -> bool { + match self.mrsv_target() { + Some(mrsv) => version > mrsv, + None => false, + } + } + + pub fn mrsv_target(&self) -> Option { + match &self.minimum_supported_rust_version_target { + Some(ver) => { + // Ignore any suffixes such as "-dev" or "-nightly". + let mut components = ver.split('-').next().unwrap().splitn(3, '.'); + let major = components.next()?.parse().ok()?; + let minor = components.next()?.parse().ok()?; + let patch = components.next().unwrap_or("0").parse().ok()?; + Some(RustcVersion { + major, + minor, + patch, + }) + } + None => None, + } + } } #[derive(clap::Args, Debug, Clone, Default, Serialize, Deserialize)] diff --git a/codegen/src/passes/find_methods_and_fields.rs b/codegen/src/passes/find_methods_and_fields.rs index b277f15b2d..38ffc4ec8e 100644 --- a/codegen/src/passes/find_methods_and_fields.rs +++ b/codegen/src/passes/find_methods_and_fields.rs @@ -16,7 +16,7 @@ use crate::{ }; /// Finds all methods and fields which can be wrapped on a proxy, stores them in sorted order. -pub(crate) fn find_methods_and_fields(ctxt: &mut BevyCtxt<'_>, _args: &Args) -> bool { +pub(crate) fn find_methods_and_fields(ctxt: &mut BevyCtxt<'_>, args: &Args) -> bool { // we need to find all the methods and fields for which we want to generate lua bindings // we have to filter some out // go through all impls on the types (traits and non-traits) and pick signatures we're happy with @@ -192,19 +192,36 @@ pub(crate) fn find_methods_and_fields(ctxt: &mut BevyCtxt<'_>, _args: &Args) -> } if let Some(unstability) = ctxt.tcx.lookup_stability(fn_did) - && unstability.is_unstable() + && let Some(stable_since) = unstability.stable_since() + && match stable_since { + rustc_hir::StableSince::Version(rustc_version) => { + args.rustc_version_is_greater_than_mrsv_target(rustc_version) + } + rustc_hir::StableSince::Current => true, + rustc_hir::StableSince::Err(_) => true, + } { log::debug!( - "Skipping unstable function: `{}` on type: `{}` feature: {:?}", + "Skipping unstable function: `{}` on type: `{}` feature: {:?}, msrv target: {:?}", ctxt.tcx.item_name(fn_did), ctxt.tcx.item_name(def_id), - unstability.feature.as_str() + unstability.feature.as_str(), + args.mrsv_target() ); return None; }; let is_unsafe = sig.safety == Safety::Unsafe; + if is_unsafe { + log::debug!( + "Skipping unsafe function: `{}` on type: `{}`", + ctxt.tcx.item_name(fn_did), + ctxt.tcx.item_name(def_id), + ); + return None; + } + if trait_did.is_none() && !ctxt.tcx.visibility(fn_did).is_public() { log::info!( "Skipping non-public function: `{}` on type: `{}`", diff --git a/codegen/templates/footer.tera b/codegen/templates/footer.tera index a9d37435e7..c6c068767d 100644 --- a/codegen/templates/footer.tera +++ b/codegen/templates/footer.tera @@ -16,7 +16,6 @@ pub struct {{ "ScriptingPlugin" | prefix_cratename | convert_case(case="upper_ca )] impl {{item.import_path}} { {% for function in item.functions %} - {% for docstring in function.docstrings %} /// {{ docstring }} {% endfor %} diff --git a/crates/bindings/bevy_animation_bms_bindings/Cargo.toml b/crates/bindings/bevy_animation_bms_bindings/Cargo.toml index 0ed8acccf8..963f919372 100644 --- a/crates/bindings/bevy_animation_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_animation_bms_bindings/Cargo.toml @@ -42,7 +42,7 @@ bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-f bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} blake3 = { version = "^1.0", features = [], default-features = true} diff --git a/crates/bindings/bevy_camera_bms_bindings/Cargo.toml b/crates/bindings/bevy_camera_bms_bindings/Cargo.toml index 02a6a2dbe6..c631798d71 100644 --- a/crates/bindings/bevy_camera_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_camera_bms_bindings/Cargo.toml @@ -40,7 +40,7 @@ bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "a bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} diff --git a/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml b/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml index eaded9f4c7..92449ed963 100644 --- a/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml @@ -44,7 +44,7 @@ bevy_shader = { version = "^0.17.2", features = [], default-features = true} bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} diff --git a/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml b/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml index f357a033e7..bbc8ec2312 100644 --- a/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml @@ -56,7 +56,7 @@ bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-f bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} bytemuck = { version = "^1.0", features = [], default-features = true} diff --git a/crates/bindings/bevy_image_bms_bindings/Cargo.toml b/crates/bindings/bevy_image_bms_bindings/Cargo.toml index 5dfdefa293..2f28a5b232 100644 --- a/crates/bindings/bevy_image_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_image_bms_bindings/Cargo.toml @@ -30,7 +30,7 @@ bevy_math = { version = "^0.17.2", features = ["bevy_reflect", "alloc", "std", " bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_light_bms_bindings/Cargo.toml b/crates/bindings/bevy_light_bms_bindings/Cargo.toml index bdcddafacb..31118f9dc7 100644 --- a/crates/bindings/bevy_light_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_light_bms_bindings/Cargo.toml @@ -42,6 +42,6 @@ bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "a bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} diff --git a/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml b/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml index 0fe487789d..63b006de77 100644 --- a/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml @@ -52,7 +52,7 @@ bevy_shader = { version = "^0.17.2", features = [], default-features = true} bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml b/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml index a694159e18..7430aec1de 100644 --- a/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml @@ -46,7 +46,7 @@ bevy_shader = { version = "^0.17.2", features = [], default-features = true} bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} diff --git a/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs b/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs index f750820671..4d55a323d4 100644 --- a/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs @@ -709,6 +709,48 @@ pub(crate) fn register_duration_functions(world: &mut World) { " Returns the total number of whole milliseconds contained by this `Duration`.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::new(5, 730_023_852);\n assert_eq!(duration.as_millis(), 5_730);\n ```", &["_self"], ) + .register_documented( + "as_millis_f32", + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: f32 = { + { + let output: f32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_millis_f32( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the number of milliseconds contained by this `Duration` as `f32`.\n The returned value includes the fractional (nanosecond) part of the duration.\n # Examples\n ```\n #![feature(duration_millis_float)]\n use std::time::Duration;\n let dur = Duration::new(2, 345_678_000);\n assert_eq!(dur.as_millis_f32(), 2_345.678);\n ```", + &["_self"], + ) + .register_documented( + "as_millis_f64", + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: f64 = { + { + let output: f64 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_millis_f64( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the number of milliseconds contained by this `Duration` as `f64`.\n The returned value includes the fractional (nanosecond) part of the duration.\n # Examples\n ```\n #![feature(duration_millis_float)]\n use std::time::Duration;\n let dur = Duration::new(2, 345_678_000);\n assert_eq!(dur.as_millis_f64(), 2_345.678);\n ```", + &["_self"], + ) .register_documented( "as_nanos", | @@ -994,16 +1036,16 @@ pub(crate) fn register_duration_functions(world: &mut World) { &["_self", "other"], ) .register_documented( - "from_hours", - |hours: u64| { + "from_days", + |days: u64| { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, > = { { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_hours( - hours, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_days( + days, ) .into(); output @@ -1011,8 +1053,8 @@ pub(crate) fn register_duration_functions(world: &mut World) { }; output }, - " Creates a new `Duration` from the specified number of hours.\n # Panics\n Panics if the given number of hours overflows the `Duration` size.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_hours(6);\n assert_eq!(6 * 60 * 60, duration.as_secs());\n assert_eq!(0, duration.subsec_nanos());\n ```", - &["hours"], + " Creates a new `Duration` from the specified number of days.\n # Panics\n Panics if the given number of days overflows the `Duration` size.\n # Examples\n ```\n #![feature(duration_constructors)]\n use std::time::Duration;\n let duration = Duration::from_days(7);\n assert_eq!(7 * 24 * 60 * 60, duration.as_secs());\n assert_eq!(0, duration.subsec_nanos());\n ```", + &["days"], ) .register_documented( "from_micros", @@ -1057,16 +1099,16 @@ pub(crate) fn register_duration_functions(world: &mut World) { &["millis"], ) .register_documented( - "from_mins", - |mins: u64| { + "from_nanos", + |nanos: u64| { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, > = { { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_mins( - mins, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_nanos( + nanos, ) .into(); output @@ -1074,19 +1116,19 @@ pub(crate) fn register_duration_functions(world: &mut World) { }; output }, - " Creates a new `Duration` from the specified number of minutes.\n # Panics\n Panics if the given number of minutes overflows the `Duration` size.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_mins(10);\n assert_eq!(10 * 60, duration.as_secs());\n assert_eq!(0, duration.subsec_nanos());\n ```", - &["mins"], + " Creates a new `Duration` from the specified number of nanoseconds.\n Note: Using this on the return value of `as_nanos()` might cause unexpected behavior:\n `as_nanos()` returns a u128, and can return values that do not fit in u64, e.g. 585 years.\n Instead, consider using the pattern `Duration::new(d.as_secs(), d.subsec_nanos())`\n if you cannot copy/clone the Duration directly.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_nanos(1_000_000_123);\n assert_eq!(1, duration.as_secs());\n assert_eq!(123, duration.subsec_nanos());\n ```", + &["nanos"], ) .register_documented( - "from_nanos", - |nanos: u64| { + "from_nanos_u128", + |nanos: u128| { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, > = { { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_nanos( + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_nanos_u128( nanos, ) .into(); @@ -1095,7 +1137,7 @@ pub(crate) fn register_duration_functions(world: &mut World) { }; output }, - " Creates a new `Duration` from the specified number of nanoseconds.\n Note: Using this on the return value of `as_nanos()` might cause unexpected behavior:\n `as_nanos()` returns a u128, and can return values that do not fit in u64, e.g. 585 years.\n Instead, consider using the pattern `Duration::new(d.as_secs(), d.subsec_nanos())`\n if you cannot copy/clone the Duration directly.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_nanos(1_000_000_123);\n assert_eq!(1, duration.as_secs());\n assert_eq!(123, duration.subsec_nanos());\n ```", + " Creates a new `Duration` from the specified number of nanoseconds.\n # Panics\n Panics if the given number of nanoseconds is greater than [`Duration::MAX`].\n # Examples\n ```\n #![feature(duration_from_nanos_u128)]\n use std::time::Duration;\n let nanos = 10_u128.pow(24) + 321;\n let duration = Duration::from_nanos_u128(nanos);\n assert_eq!(10_u64.pow(15), duration.as_secs());\n assert_eq!(321, duration.subsec_nanos());\n ```", &["nanos"], ) .register_documented( @@ -1161,6 +1203,27 @@ pub(crate) fn register_duration_functions(world: &mut World) { " Creates a new `Duration` from the specified number of seconds represented\n as `f64`.\n # Panics\n This constructor will panic if `secs` is negative, overflows `Duration` or not finite.\n # Examples\n ```\n use std::time::Duration;\n let res = Duration::from_secs_f64(0.0);\n assert_eq!(res, Duration::new(0, 0));\n let res = Duration::from_secs_f64(1e-20);\n assert_eq!(res, Duration::new(0, 0));\n let res = Duration::from_secs_f64(4.2e-7);\n assert_eq!(res, Duration::new(0, 420));\n let res = Duration::from_secs_f64(2.7);\n assert_eq!(res, Duration::new(2, 700_000_000));\n let res = Duration::from_secs_f64(3e10);\n assert_eq!(res, Duration::new(30_000_000_000, 0));\n // subnormal float\n let res = Duration::from_secs_f64(f64::from_bits(1));\n assert_eq!(res, Duration::new(0, 0));\n // conversion uses rounding\n let res = Duration::from_secs_f64(0.999e-9);\n assert_eq!(res, Duration::new(0, 1));\n ```", &["secs"], ) + .register_documented( + "from_weeks", + |weeks: u64| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_weeks( + weeks, + ) + .into(); + output + } + }; + output + }, + " Creates a new `Duration` from the specified number of weeks.\n # Panics\n Panics if the given number of weeks overflows the `Duration` size.\n # Examples\n ```\n #![feature(duration_constructors)]\n use std::time::Duration;\n let duration = Duration::from_weeks(4);\n assert_eq!(4 * 7 * 24 * 60 * 60, duration.as_secs());\n assert_eq!(0, duration.subsec_nanos());\n ```", + &["weeks"], + ) .register_documented( "is_zero", | @@ -57433,23 +57496,6 @@ pub(crate) fn register_non_nil_uuid_functions(world: &mut World) { }, " Get the underlying [`Uuid`] value.", &["_self"], - ) - .register_documented( - "new_unchecked", - |uuid: Val<::uuid::Uuid>| { - let output: Val<::uuid::NonNilUuid> = { - { - let output: Val<::uuid::NonNilUuid> = ::uuid::NonNilUuid::new_unchecked( - uuid.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Creates a non-nil without checking whether the value is non-nil. This results in undefined behavior if the value is nil.\n # Safety\n The value must not be nil.", - &["uuid"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); diff --git a/crates/bindings/bevy_render_bms_bindings/Cargo.toml b/crates/bindings/bevy_render_bms_bindings/Cargo.toml index 00a707b93a..2f5dcf3226 100644 --- a/crates/bindings/bevy_render_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_render_bms_bindings/Cargo.toml @@ -56,7 +56,7 @@ bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-f bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} diff --git a/crates/bindings/bevy_scene_bms_bindings/Cargo.toml b/crates/bindings/bevy_scene_bms_bindings/Cargo.toml index 334a1766ff..16d3bd9906 100644 --- a/crates/bindings/bevy_scene_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_scene_bms_bindings/Cargo.toml @@ -36,7 +36,7 @@ bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "a bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} serde = { version = "^1.0", features = [], default-features = true} diff --git a/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml b/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml index c037728a5f..c8f098bf41 100644 --- a/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml @@ -52,7 +52,7 @@ bevy_text = { version = "^0.17.2", features = ["default_font"], default-features bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_text_bms_bindings/Cargo.toml b/crates/bindings/bevy_text_bms_bindings/Cargo.toml index 1fab9a0ad3..5f2b1ef284 100644 --- a/crates/bindings/bevy_text_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_text_bms_bindings/Cargo.toml @@ -38,7 +38,7 @@ bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} cosmic-text = { version = "^0.14", features = [], default-features = true} diff --git a/crates/bindings/bevy_ui_bms_bindings/Cargo.toml b/crates/bindings/bevy_ui_bms_bindings/Cargo.toml index 80a8023ab6..6d45864df4 100644 --- a/crates/bindings/bevy_ui_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_ui_bms_bindings/Cargo.toml @@ -52,7 +52,7 @@ bevy_text = { version = "^0.17.2", features = ["default_font"], default-features bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} diff --git a/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml b/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml index a6c9fd3f62..7adb245adf 100644 --- a/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml @@ -56,7 +56,7 @@ bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "al bevy_ui = { version = "^0.17.2", features = ["bevy_picking", "bevy_ui_picking_backend"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} bytemuck = { version = "^1.5", features = [], default-features = true} From a88a70849f03c25ad145d6e4733d0d7be031f81c Mon Sep 17 00:00:00 2001 From: makspll Date: Sun, 9 Nov 2025 18:14:57 +0000 Subject: [PATCH 09/22] fix bug --- codegen/src/passes/find_methods_and_fields.rs | 23 +- .../bevy_a11y_bms_bindings/Cargo.toml | 6 +- .../bevy_animation_bms_bindings/Cargo.toml | 14 +- .../bevy_asset_bms_bindings/Cargo.toml | 2 +- .../bevy_camera_bms_bindings/Cargo.toml | 18 +- .../bevy_color_bms_bindings/Cargo.toml | 6 +- .../Cargo.toml | 18 +- .../bindings/bevy_ecs_bms_bindings/Cargo.toml | 4 +- .../bevy_gizmos_bms_bindings/Cargo.toml | 16 +- .../bevy_gltf_bms_bindings/Cargo.toml | 16 +- .../bevy_image_bms_bindings/Cargo.toml | 12 +- .../bevy_input_bms_bindings/Cargo.toml | 8 +- .../bevy_input_focus_bms_bindings/Cargo.toml | 8 +- .../bevy_light_bms_bindings/Cargo.toml | 16 +- .../bevy_math_bms_bindings/Cargo.toml | 10 +- .../bevy_mesh_bms_bindings/Cargo.toml | 12 +- .../bindings/bevy_pbr_bms_bindings/Cargo.toml | 16 +- .../bevy_picking_bms_bindings/Cargo.toml | 12 +- .../bevy_post_process_bms_bindings/Cargo.toml | 18 +- .../bevy_reflect_bms_bindings/Cargo.toml | 2 +- .../bevy_reflect_bms_bindings/src/lib.rs | 1436 +---------------- .../bevy_render_bms_bindings/Cargo.toml | 20 +- .../bevy_scene_bms_bindings/Cargo.toml | 10 +- .../bevy_sprite_bms_bindings/Cargo.toml | 16 +- .../Cargo.toml | 16 +- .../bevy_text_bms_bindings/Cargo.toml | 14 +- .../bevy_time_bms_bindings/Cargo.toml | 6 +- .../bevy_transform_bms_bindings/Cargo.toml | 10 +- .../bindings/bevy_ui_bms_bindings/Cargo.toml | 18 +- .../bevy_ui_render_bms_bindings/Cargo.toml | 16 +- 30 files changed, 241 insertions(+), 1558 deletions(-) diff --git a/codegen/src/passes/find_methods_and_fields.rs b/codegen/src/passes/find_methods_and_fields.rs index 38ffc4ec8e..c28f28fa9f 100644 --- a/codegen/src/passes/find_methods_and_fields.rs +++ b/codegen/src/passes/find_methods_and_fields.rs @@ -1,7 +1,7 @@ use indexmap::IndexMap; use log::{info, trace}; use rustc_hir::{ - Safety, + Safety, StableSince, def_id::{DefId, LOCAL_CRATE}, }; use rustc_infer::infer::TyCtxtInferExt; @@ -191,21 +191,22 @@ pub(crate) fn find_methods_and_fields(ctxt: &mut BevyCtxt<'_>, args: &Args) -> b return None; } - if let Some(unstability) = ctxt.tcx.lookup_stability(fn_did) - && let Some(stable_since) = unstability.stable_since() - && match stable_since { - rustc_hir::StableSince::Version(rustc_version) => { + let is_stable_for_target = ctxt + .tcx + .lookup_stability(fn_did) + .map(|stability| match stability.stable_since() { + Some(StableSince::Version(rustc_version)) => { args.rustc_version_is_greater_than_mrsv_target(rustc_version) } - rustc_hir::StableSince::Current => true, - rustc_hir::StableSince::Err(_) => true, - } - { + _ => false, + }) + .unwrap_or(true); + + if !is_stable_for_target { log::debug!( - "Skipping unstable function: `{}` on type: `{}` feature: {:?}, msrv target: {:?}", + "Skipping unstable function: `{}` on type: `{}`, msrv target: {:?}", ctxt.tcx.item_name(fn_did), ctxt.tcx.item_name(def_id), - unstability.feature.as_str(), args.mrsv_target() ); return None; diff --git a/crates/bindings/bevy_a11y_bms_bindings/Cargo.toml b/crates/bindings/bevy_a11y_bms_bindings/Cargo.toml index 3fbc89a7cf..a7b8f0a7f7 100644 --- a/crates/bindings/bevy_a11y_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_a11y_bms_bindings/Cargo.toml @@ -20,12 +20,12 @@ bevy_mod_scripting_derive = { workspace = true } bevy_a11y = { version = "0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "reflect_auto_register", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "multi_threaded", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} diff --git a/crates/bindings/bevy_animation_bms_bindings/Cargo.toml b/crates/bindings/bevy_animation_bms_bindings/Cargo.toml index 963f919372..96ad701028 100644 --- a/crates/bindings/bevy_animation_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_animation_bms_bindings/Cargo.toml @@ -22,27 +22,27 @@ bevy_animation = { version = "0.17.2", features = [], default-features = true} bevy_animation_macros = { version = "^0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} blake3 = { version = "^1.0", features = [], default-features = true} diff --git a/crates/bindings/bevy_asset_bms_bindings/Cargo.toml b/crates/bindings/bevy_asset_bms_bindings/Cargo.toml index bfd7abf50d..b88d738efc 100644 --- a/crates/bindings/bevy_asset_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_asset_bms_bindings/Cargo.toml @@ -22,7 +22,7 @@ bevy_asset = { version = "0.17.2", features = ["notify-debouncer-full", "watch", bevy_asset_macros = { version = "^0.17.2", features = [], default-features = true} -bevy_tasks = { version = "^0.17.2", features = ["multi_threaded", "async_executor", "futures-lite"], default-features = true} +bevy_tasks = { version = "^0.17.2", features = ["multi_threaded", "futures-lite", "async_executor"], default-features = true} js-sys = { version = "^0.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_camera_bms_bindings/Cargo.toml b/crates/bindings/bevy_camera_bms_bindings/Cargo.toml index c631798d71..8855c5ea82 100644 --- a/crates/bindings/bevy_camera_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_camera_bms_bindings/Cargo.toml @@ -20,28 +20,28 @@ bevy_mod_scripting_derive = { workspace = true } bevy_camera = { version = "0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["std", "bevy_reflect", "bevy_image", "bevy_asset", "custom_cursor"], default-features = true} diff --git a/crates/bindings/bevy_color_bms_bindings/Cargo.toml b/crates/bindings/bevy_color_bms_bindings/Cargo.toml index 27c1e36e3b..84f4b59f7e 100644 --- a/crates/bindings/bevy_color_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_color_bms_bindings/Cargo.toml @@ -17,12 +17,12 @@ bevy_app = { workspace = true, features = ["std"] } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_color = { version = "0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "alloc", "rand", "curve", "bevy_reflect"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} bytemuck = { version = "^1", features = [], default-features = true} diff --git a/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml b/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml index 92449ed963..f3aa36ded9 100644 --- a/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml @@ -20,33 +20,33 @@ bevy_mod_scripting_derive = { workspace = true } bevy_core_pipeline = { version = "0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["ktx2", "zstd", "hdr", "png", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["ktx2", "zstd", "bevy_reflect", "hdr", "png", "zstd_rust"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} bevy_shader = { version = "^0.17.2", features = [], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["std", "bevy_reflect", "bevy_image", "bevy_asset", "custom_cursor"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_ecs_bms_bindings/Cargo.toml b/crates/bindings/bevy_ecs_bms_bindings/Cargo.toml index caaf910f49..a308730893 100644 --- a/crates/bindings/bevy_ecs_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_ecs_bms_bindings/Cargo.toml @@ -17,7 +17,7 @@ bevy_app = { workspace = true, features = ["std"] } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_ecs = { version = "0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} arrayvec = { version = "^0.7.4", features = ["std"], default-features = false} @@ -28,7 +28,7 @@ bevy_platform = { version = "^0.17.2", features = ["std", "serialize", "alloc"], bevy_ptr = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "auto_register", "glam", "uuid", "smol_str", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["std", "auto_register", "glam", "uuid", "smol_str", "smallvec", "debug", "auto_register_inventory", "debug_stack"], default-features = true} bevy_tasks = { version = "^0.17.2", features = ["async_executor", "multi_threaded", "futures-lite"], default-features = true} diff --git a/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml b/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml index bbc8ec2312..d6fde7a971 100644 --- a/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml @@ -20,31 +20,31 @@ bevy_mod_scripting_derive = { workspace = true } bevy_gizmos = { version = "0.17.2", features = ["bevy_pbr", "bevy_core_pipeline", "bevy_render", "bevy_sprite_render", "webgl"], default-features = false} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} bevy_gizmos_macros = { version = "^0.17.2", features = [], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} bevy_light = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} bevy_pbr = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} @@ -54,9 +54,9 @@ bevy_sprite_render = { version = "^0.17.2", features = ["bevy_text", "webgl"], d bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} bytemuck = { version = "^1.0", features = [], default-features = true} diff --git a/crates/bindings/bevy_gltf_bms_bindings/Cargo.toml b/crates/bindings/bevy_gltf_bms_bindings/Cargo.toml index 465a5e174d..b6b9e11000 100644 --- a/crates/bindings/bevy_gltf_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_gltf_bms_bindings/Cargo.toml @@ -24,35 +24,35 @@ base64 = { version = "^0.22.0", features = [], default-features = true} bevy_animation = { version = "^0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} bevy_light = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} bevy_pbr = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} bevy_scene = { version = "^0.17.2", features = ["serialize"], default-features = true} -bevy_tasks = { version = "^0.17.2", features = ["async_executor", "futures-lite", "multi_threaded"], default-features = true} +bevy_tasks = { version = "^0.17.2", features = ["futures-lite", "async_executor", "multi_threaded"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} fixedbitset = { version = "^0.5", features = [], default-features = true} diff --git a/crates/bindings/bevy_image_bms_bindings/Cargo.toml b/crates/bindings/bevy_image_bms_bindings/Cargo.toml index 2f28a5b232..e0b42241c7 100644 --- a/crates/bindings/bevy_image_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_image_bms_bindings/Cargo.toml @@ -17,20 +17,20 @@ bevy_ecs = { workspace = true, features = ["std", "bevy_reflect"] } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_image = { version = "0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["bevy_reflect", "alloc", "std", "rand", "curve"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["bevy_reflect", "std", "rand", "curve", "alloc"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_input_bms_bindings/Cargo.toml b/crates/bindings/bevy_input_bms_bindings/Cargo.toml index 35c5329b27..a180a74cd6 100644 --- a/crates/bindings/bevy_input_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_input_bms_bindings/Cargo.toml @@ -20,14 +20,14 @@ bevy_mod_scripting_derive = { workspace = true } bevy_input = { version = "0.17.2", features = ["std", "bevy_reflect", "smol_str"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "reflect_auto_register", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "multi_threaded", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "alloc", "rand", "curve"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "rand", "curve", "alloc"], default-features = true} bevy_platform = { version = "^0.17.2", features = ["std", "alloc", "serialize"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "smol_str", "glam", "uuid", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["std", "smol_str", "glam", "uuid", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} diff --git a/crates/bindings/bevy_input_focus_bms_bindings/Cargo.toml b/crates/bindings/bevy_input_focus_bms_bindings/Cargo.toml index f5fe7df372..ef91bb7bc5 100644 --- a/crates/bindings/bevy_input_focus_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_input_focus_bms_bindings/Cargo.toml @@ -20,15 +20,15 @@ bevy_mod_scripting_derive = { workspace = true } bevy_input_focus = { version = "0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "reflect_auto_register", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "multi_threaded", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} bevy_input = { version = "^0.17.2", features = ["std", "bevy_reflect", "smol_str"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "alloc", "rand", "curve"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "rand", "curve", "alloc"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} bevy_window = { version = "^0.17.2", features = ["std", "bevy_reflect", "bevy_image", "bevy_asset", "custom_cursor"], default-features = true} diff --git a/crates/bindings/bevy_light_bms_bindings/Cargo.toml b/crates/bindings/bevy_light_bms_bindings/Cargo.toml index 31118f9dc7..9b5405851d 100644 --- a/crates/bindings/bevy_light_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_light_bms_bindings/Cargo.toml @@ -20,28 +20,28 @@ bevy_mod_scripting_derive = { workspace = true } bevy_light = { version = "0.17.2", features = ["webgl"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} bevy_platform = { version = "^0.17.2", features = ["alloc", "std", "serialize"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} diff --git a/crates/bindings/bevy_math_bms_bindings/Cargo.toml b/crates/bindings/bevy_math_bms_bindings/Cargo.toml index dc18f5c448..69aa9c99a8 100644 --- a/crates/bindings/bevy_math_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_math_bms_bindings/Cargo.toml @@ -17,20 +17,20 @@ bevy_app = { workspace = true, features = ["std"] } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_math = { version = "0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} derive_more = { version = "^2", features = ["std"], default-features = false} glam = { version = "^0.30.1", features = ["std", "rand"], default-features = false} -itertools = { version = "^0.14.0", features = ["use_alloc", "use_std"], default-features = false} +itertools = { version = "^0.14.0", features = ["use_std", "use_alloc"], default-features = false} -rand = { version = "^0.9", features = ["alloc", "std"], default-features = false} +rand = { version = "^0.9", features = ["std", "alloc"], default-features = false} -rand_distr = { version = "^0.5", features = ["alloc", "std"], default-features = false} +rand_distr = { version = "^0.5", features = ["std", "alloc"], default-features = false} variadics_please = { version = "^1.1", features = [], default-features = true} diff --git a/crates/bindings/bevy_mesh_bms_bindings/Cargo.toml b/crates/bindings/bevy_mesh_bms_bindings/Cargo.toml index 12a4cbd5da..51570623cc 100644 --- a/crates/bindings/bevy_mesh_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_mesh_bms_bindings/Cargo.toml @@ -20,23 +20,23 @@ bevy_mod_scripting_derive = { workspace = true } bevy_mesh = { version = "0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} bevy_mikktspace = { version = "^0.17.0-dev", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml b/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml index 63b006de77..1feac068a9 100644 --- a/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml @@ -20,13 +20,13 @@ bevy_mod_scripting_derive = { workspace = true } bevy_pbr = { version = "0.17.2", features = ["webgl"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} @@ -34,25 +34,25 @@ bevy_derive = { version = "^0.17.2", features = [], default-features = true} bevy_diagnostic = { version = "^0.17.2", features = ["std", "sysinfo", "sysinfo_plugin"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} bevy_light = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} bevy_shader = { version = "^0.17.2", features = [], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_picking_bms_bindings/Cargo.toml b/crates/bindings/bevy_picking_bms_bindings/Cargo.toml index 77612c0975..9eb00004be 100644 --- a/crates/bindings/bevy_picking_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_picking_bms_bindings/Cargo.toml @@ -20,7 +20,7 @@ bevy_mod_scripting_derive = { workspace = true } bevy_picking = { version = "0.17.2", features = ["bevy_mesh_picking_backend"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} @@ -28,21 +28,21 @@ bevy_camera = { version = "^0.17.2", features = [], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} bevy_input = { version = "^0.17.2", features = ["std", "bevy_reflect", "smol_str"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["std", "bevy_reflect", "bevy_image", "bevy_asset", "custom_cursor"], default-features = true} crossbeam-channel = { version = "^0.5", features = [], default-features = true} diff --git a/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml b/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml index 7430aec1de..49585c0190 100644 --- a/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml @@ -20,35 +20,35 @@ bevy_mod_scripting_derive = { workspace = true } bevy_post_process = { version = "0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} bevy_shader = { version = "^0.17.2", features = [], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["std", "bevy_reflect", "bevy_image", "bevy_asset", "custom_cursor"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_reflect_bms_bindings/Cargo.toml b/crates/bindings/bevy_reflect_bms_bindings/Cargo.toml index 1fb53448a4..3c7eeb6b2a 100644 --- a/crates/bindings/bevy_reflect_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_reflect_bms_bindings/Cargo.toml @@ -17,7 +17,7 @@ bevy_app = { workspace = true, features = ["std"] } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_reflect = { version = "0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} assert_type_match = { version = "^0.1.1", features = [], default-features = true} diff --git a/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs b/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs index 4d55a323d4..4fffdad76e 100644 --- a/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs @@ -15,49 +15,7 @@ pub struct BevyReflectScriptingPlugin; pub(crate) fn register_atomic_bool_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool, - >::new(world) - .register_documented( - "into_inner", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool, - >| - { - let output: bool = { - { - let output: bool = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool::into_inner( - _self.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\n use std::sync::atomic::AtomicBool;\n let some_bool = AtomicBool::new(true);\n assert_eq!(some_bool.into_inner(), true);\n ```", - &["_self"], - ) - .register_documented( - "new", - |v: bool| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool::new( - v, - ) - .into(); - output - } - }; - output - }, - " Creates a new `AtomicBool`.\n # Examples\n ```\n use std::sync::atomic::AtomicBool;\n let atomic_true = AtomicBool::new(true);\n let atomic_false = AtomicBool::new(false);\n ```", - &["v"], - ); + >::new(world); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -69,49 +27,7 @@ pub(crate) fn register_atomic_bool_functions(world: &mut World) { pub(crate) fn register_atomic_i_8_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8, - >::new(world) - .register_documented( - "into_inner", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8, - >| - { - let output: i8 = { - { - let output: i8 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8::into_inner( - _self.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicI8;\nlet some_var = AtomicI8::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", - &["_self"], - ) - .register_documented( - "new", - |v: i8| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8::new( - v, - ) - .into(); - output - } - }; - output - }, - " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicI8;\nlet atomic_forty_two = AtomicI8::new(42);\n ```", - &["v"], - ); + >::new(world); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -123,49 +39,7 @@ pub(crate) fn register_atomic_i_8_functions(world: &mut World) { pub(crate) fn register_atomic_i_16_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16, - >::new(world) - .register_documented( - "into_inner", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16, - >| - { - let output: i16 = { - { - let output: i16 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16::into_inner( - _self.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicI16;\nlet some_var = AtomicI16::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", - &["_self"], - ) - .register_documented( - "new", - |v: i16| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16::new( - v, - ) - .into(); - output - } - }; - output - }, - " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicI16;\nlet atomic_forty_two = AtomicI16::new(42);\n ```", - &["v"], - ); + >::new(world); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -177,49 +51,7 @@ pub(crate) fn register_atomic_i_16_functions(world: &mut World) { pub(crate) fn register_atomic_i_32_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32, - >::new(world) - .register_documented( - "into_inner", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32, - >| - { - let output: i32 = { - { - let output: i32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32::into_inner( - _self.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicI32;\nlet some_var = AtomicI32::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", - &["_self"], - ) - .register_documented( - "new", - |v: i32| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32::new( - v, - ) - .into(); - output - } - }; - output - }, - " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicI32;\nlet atomic_forty_two = AtomicI32::new(42);\n ```", - &["v"], - ); + >::new(world); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -231,49 +63,7 @@ pub(crate) fn register_atomic_i_32_functions(world: &mut World) { pub(crate) fn register_atomic_i_64_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64, - >::new(world) - .register_documented( - "into_inner", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64, - >| - { - let output: i64 = { - { - let output: i64 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64::into_inner( - _self.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicI64;\nlet some_var = AtomicI64::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", - &["_self"], - ) - .register_documented( - "new", - |v: i64| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64::new( - v, - ) - .into(); - output - } - }; - output - }, - " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicI64;\nlet atomic_forty_two = AtomicI64::new(42);\n ```", - &["v"], - ); + >::new(world); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -285,49 +75,7 @@ pub(crate) fn register_atomic_i_64_functions(world: &mut World) { pub(crate) fn register_atomic_isize_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize, - >::new(world) - .register_documented( - "into_inner", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize, - >| - { - let output: isize = { - { - let output: isize = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize::into_inner( - _self.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicIsize;\nlet some_var = AtomicIsize::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", - &["_self"], - ) - .register_documented( - "new", - |v: isize| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize::new( - v, - ) - .into(); - output - } - }; - output - }, - " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicIsize;\nlet atomic_forty_two = AtomicIsize::new(42);\n ```", - &["v"], - ); + >::new(world); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -339,49 +87,7 @@ pub(crate) fn register_atomic_isize_functions(world: &mut World) { pub(crate) fn register_atomic_u_8_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8, - >::new(world) - .register_documented( - "into_inner", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8, - >| - { - let output: u8 = { - { - let output: u8 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8::into_inner( - _self.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicU8;\nlet some_var = AtomicU8::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", - &["_self"], - ) - .register_documented( - "new", - |v: u8| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8::new( - v, - ) - .into(); - output - } - }; - output - }, - " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicU8;\nlet atomic_forty_two = AtomicU8::new(42);\n ```", - &["v"], - ); + >::new(world); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -393,49 +99,7 @@ pub(crate) fn register_atomic_u_8_functions(world: &mut World) { pub(crate) fn register_atomic_u_16_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16, - >::new(world) - .register_documented( - "into_inner", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16, - >| - { - let output: u16 = { - { - let output: u16 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16::into_inner( - _self.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicU16;\nlet some_var = AtomicU16::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", - &["_self"], - ) - .register_documented( - "new", - |v: u16| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16::new( - v, - ) - .into(); - output - } - }; - output - }, - " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicU16;\nlet atomic_forty_two = AtomicU16::new(42);\n ```", - &["v"], - ); + >::new(world); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -447,49 +111,7 @@ pub(crate) fn register_atomic_u_16_functions(world: &mut World) { pub(crate) fn register_atomic_u_32_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32, - >::new(world) - .register_documented( - "into_inner", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32, - >| - { - let output: u32 = { - { - let output: u32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32::into_inner( - _self.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicU32;\nlet some_var = AtomicU32::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", - &["_self"], - ) - .register_documented( - "new", - |v: u32| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32::new( - v, - ) - .into(); - output - } - }; - output - }, - " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicU32;\nlet atomic_forty_two = AtomicU32::new(42);\n ```", - &["v"], - ); + >::new(world); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -501,49 +123,7 @@ pub(crate) fn register_atomic_u_32_functions(world: &mut World) { pub(crate) fn register_atomic_u_64_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64, - >::new(world) - .register_documented( - "into_inner", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64, - >| - { - let output: u64 = { - { - let output: u64 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64::into_inner( - _self.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicU64;\nlet some_var = AtomicU64::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", - &["_self"], - ) - .register_documented( - "new", - |v: u64| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64::new( - v, - ) - .into(); - output - } - }; - output - }, - " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicU64;\nlet atomic_forty_two = AtomicU64::new(42);\n ```", - &["v"], - ); + >::new(world); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -555,49 +135,7 @@ pub(crate) fn register_atomic_u_64_functions(world: &mut World) { pub(crate) fn register_atomic_usize_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize, - >::new(world) - .register_documented( - "into_inner", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize, - >| - { - let output: usize = { - { - let output: usize = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize::into_inner( - _self.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicUsize;\nlet some_var = AtomicUsize::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", - &["_self"], - ) - .register_documented( - "new", - |v: usize| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize::new( - v, - ) - .into(); - output - } - }; - output - }, - " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicUsize;\nlet atomic_forty_two = AtomicUsize::new(42);\n ```", - &["v"], - ); + >::new(world); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -610,35 +148,6 @@ pub(crate) fn register_duration_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, >::new(world) - .register_documented( - "abs_diff", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - other: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::abs_diff( - _self.into_inner(), - other.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Computes the absolute difference between `self` and `other`.\n # Examples\n ```\n use std::time::Duration;\n assert_eq!(Duration::new(100, 0).abs_diff(Duration::new(80, 0)), Duration::new(20, 0));\n assert_eq!(Duration::new(100, 400_000_000).abs_diff(Duration::new(110, 0)), Duration::new(9, 600_000_000));\n ```", - &["_self", "other"], - ) .register_documented( "add", | @@ -668,141 +177,15 @@ pub(crate) fn register_duration_functions(world: &mut World) { &["_self", "rhs"], ) .register_documented( - "as_micros", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: u128 = { - { - let output: u128 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_micros( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the total number of whole microseconds contained by this `Duration`.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::new(5, 730_023_852);\n assert_eq!(duration.as_micros(), 5_730_023);\n ```", - &["_self"], - ) - .register_documented( - "as_millis", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: u128 = { - { - let output: u128 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_millis( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the total number of whole milliseconds contained by this `Duration`.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::new(5, 730_023_852);\n assert_eq!(duration.as_millis(), 5_730);\n ```", - &["_self"], - ) - .register_documented( - "as_millis_f32", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: f32 = { - { - let output: f32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_millis_f32( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the number of milliseconds contained by this `Duration` as `f32`.\n The returned value includes the fractional (nanosecond) part of the duration.\n # Examples\n ```\n #![feature(duration_millis_float)]\n use std::time::Duration;\n let dur = Duration::new(2, 345_678_000);\n assert_eq!(dur.as_millis_f32(), 2_345.678);\n ```", - &["_self"], - ) - .register_documented( - "as_millis_f64", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: f64 = { - { - let output: f64 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_millis_f64( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the number of milliseconds contained by this `Duration` as `f64`.\n The returned value includes the fractional (nanosecond) part of the duration.\n # Examples\n ```\n #![feature(duration_millis_float)]\n use std::time::Duration;\n let dur = Duration::new(2, 345_678_000);\n assert_eq!(dur.as_millis_f64(), 2_345.678);\n ```", - &["_self"], - ) - .register_documented( - "as_nanos", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: u128 = { - { - let output: u128 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_nanos( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the total number of nanoseconds contained by this `Duration`.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::new(5, 730_023_852);\n assert_eq!(duration.as_nanos(), 5_730_023_852);\n ```", - &["_self"], - ) - .register_documented( - "as_secs", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: u64 = { - { - let output: u64 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_secs( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the number of _whole_ seconds contained by this `Duration`.\n The returned value does not include the fractional (nanosecond) part of the\n duration, which can be obtained using [`subsec_nanos`].\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::new(5, 730_023_852);\n assert_eq!(duration.as_secs(), 5);\n ```\n To determine the total number of seconds represented by the `Duration`\n including the fractional part, use [`as_secs_f64`] or [`as_secs_f32`]\n [`as_secs_f64`]: Duration::as_secs_f64\n [`as_secs_f32`]: Duration::as_secs_f32\n [`subsec_nanos`]: Duration::subsec_nanos", - &["_self"], - ) - .register_documented( - "as_secs_f32", + "assert_receiver_is_total_eq", | _self: Ref< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, >| { - let output: f32 = { + let output: () = { { - let output: f32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_secs_f32( + let output: () = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -811,473 +194,15 @@ pub(crate) fn register_duration_functions(world: &mut World) { }; output }, - " Returns the number of seconds contained by this `Duration` as `f32`.\n The returned value includes the fractional (nanosecond) part of the duration.\n # Examples\n ```\n use std::time::Duration;\n let dur = Duration::new(2, 700_000_000);\n assert_eq!(dur.as_secs_f32(), 2.7);\n ```", + "", &["_self"], ) .register_documented( - "as_secs_f64", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: f64 = { - { - let output: f64 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_secs_f64( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the number of seconds contained by this `Duration` as `f64`.\n The returned value includes the fractional (nanosecond) part of the duration.\n # Examples\n ```\n use std::time::Duration;\n let dur = Duration::new(2, 700_000_000);\n assert_eq!(dur.as_secs_f64(), 2.7);\n ```", - &["_self"], - ) - .register_documented( - "assert_receiver_is_total_eq", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: () = { - { - let output: () = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "div", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - rhs: u32| - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< - u32, - >>::div(_self.into_inner(), rhs) - .into(); - output - } - }; - output - }, - "", - &["_self", "rhs"], - ) - .register_documented( - "div_duration_f32", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - rhs: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: f32 = { - { - let output: f32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::div_duration_f32( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Divides `Duration` by `Duration` and returns `f32`.\n # Examples\n ```\n use std::time::Duration;\n let dur1 = Duration::new(2, 700_000_000);\n let dur2 = Duration::new(5, 400_000_000);\n assert_eq!(dur1.div_duration_f32(dur2), 0.5);\n ```", - &["_self", "rhs"], - ) - .register_documented( - "div_duration_f64", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - rhs: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: f64 = { - { - let output: f64 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::div_duration_f64( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Divides `Duration` by `Duration` and returns `f64`.\n # Examples\n ```\n use std::time::Duration;\n let dur1 = Duration::new(2, 700_000_000);\n let dur2 = Duration::new(5, 400_000_000);\n assert_eq!(dur1.div_duration_f64(dur2), 0.5);\n ```", - &["_self", "rhs"], - ) - .register_documented( - "div_f32", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - rhs: f32| - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::div_f32( - _self.into_inner(), - rhs, - ) - .into(); - output - } - }; - output - }, - " Divides `Duration` by `f32`.\n # Panics\n This method will panic if result is negative, overflows `Duration` or not finite.\n # Examples\n ```\n use std::time::Duration;\n let dur = Duration::new(2, 700_000_000);\n // note that due to rounding errors result is slightly\n // different from 0.859_872_611\n assert_eq!(dur.div_f32(3.14), Duration::new(0, 859_872_580));\n assert_eq!(dur.div_f32(3.14e5), Duration::new(0, 8_599));\n ```", - &["_self", "rhs"], - ) - .register_documented( - "div_f64", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - rhs: f64| - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::div_f64( - _self.into_inner(), - rhs, - ) - .into(); - output - } - }; - output - }, - " Divides `Duration` by `f64`.\n # Panics\n This method will panic if result is negative, overflows `Duration` or not finite.\n # Examples\n ```\n use std::time::Duration;\n let dur = Duration::new(2, 700_000_000);\n assert_eq!(dur.div_f64(3.14), Duration::new(0, 859_872_611));\n assert_eq!(dur.div_f64(3.14e5), Duration::new(0, 8_599));\n ```", - &["_self", "rhs"], - ) - .register_documented( - "eq", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - other: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: bool = { - { - let output: bool = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "from_days", - |days: u64| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_days( - days, - ) - .into(); - output - } - }; - output - }, - " Creates a new `Duration` from the specified number of days.\n # Panics\n Panics if the given number of days overflows the `Duration` size.\n # Examples\n ```\n #![feature(duration_constructors)]\n use std::time::Duration;\n let duration = Duration::from_days(7);\n assert_eq!(7 * 24 * 60 * 60, duration.as_secs());\n assert_eq!(0, duration.subsec_nanos());\n ```", - &["days"], - ) - .register_documented( - "from_micros", - |micros: u64| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_micros( - micros, - ) - .into(); - output - } - }; - output - }, - " Creates a new `Duration` from the specified number of microseconds.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_micros(1_000_002);\n assert_eq!(1, duration.as_secs());\n assert_eq!(2_000, duration.subsec_nanos());\n ```", - &["micros"], - ) - .register_documented( - "from_millis", - |millis: u64| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_millis( - millis, - ) - .into(); - output - } - }; - output - }, - " Creates a new `Duration` from the specified number of milliseconds.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_millis(2_569);\n assert_eq!(2, duration.as_secs());\n assert_eq!(569_000_000, duration.subsec_nanos());\n ```", - &["millis"], - ) - .register_documented( - "from_nanos", - |nanos: u64| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_nanos( - nanos, - ) - .into(); - output - } - }; - output - }, - " Creates a new `Duration` from the specified number of nanoseconds.\n Note: Using this on the return value of `as_nanos()` might cause unexpected behavior:\n `as_nanos()` returns a u128, and can return values that do not fit in u64, e.g. 585 years.\n Instead, consider using the pattern `Duration::new(d.as_secs(), d.subsec_nanos())`\n if you cannot copy/clone the Duration directly.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_nanos(1_000_000_123);\n assert_eq!(1, duration.as_secs());\n assert_eq!(123, duration.subsec_nanos());\n ```", - &["nanos"], - ) - .register_documented( - "from_nanos_u128", - |nanos: u128| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_nanos_u128( - nanos, - ) - .into(); - output - } - }; - output - }, - " Creates a new `Duration` from the specified number of nanoseconds.\n # Panics\n Panics if the given number of nanoseconds is greater than [`Duration::MAX`].\n # Examples\n ```\n #![feature(duration_from_nanos_u128)]\n use std::time::Duration;\n let nanos = 10_u128.pow(24) + 321;\n let duration = Duration::from_nanos_u128(nanos);\n assert_eq!(10_u64.pow(15), duration.as_secs());\n assert_eq!(321, duration.subsec_nanos());\n ```", - &["nanos"], - ) - .register_documented( - "from_secs", - |secs: u64| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_secs( - secs, - ) - .into(); - output - } - }; - output - }, - " Creates a new `Duration` from the specified number of whole seconds.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_secs(5);\n assert_eq!(5, duration.as_secs());\n assert_eq!(0, duration.subsec_nanos());\n ```", - &["secs"], - ) - .register_documented( - "from_secs_f32", - |secs: f32| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_secs_f32( - secs, - ) - .into(); - output - } - }; - output - }, - " Creates a new `Duration` from the specified number of seconds represented\n as `f32`.\n # Panics\n This constructor will panic if `secs` is negative, overflows `Duration` or not finite.\n # Examples\n ```\n use std::time::Duration;\n let res = Duration::from_secs_f32(0.0);\n assert_eq!(res, Duration::new(0, 0));\n let res = Duration::from_secs_f32(1e-20);\n assert_eq!(res, Duration::new(0, 0));\n let res = Duration::from_secs_f32(4.2e-7);\n assert_eq!(res, Duration::new(0, 420));\n let res = Duration::from_secs_f32(2.7);\n assert_eq!(res, Duration::new(2, 700_000_048));\n let res = Duration::from_secs_f32(3e10);\n assert_eq!(res, Duration::new(30_000_001_024, 0));\n // subnormal float\n let res = Duration::from_secs_f32(f32::from_bits(1));\n assert_eq!(res, Duration::new(0, 0));\n // conversion uses rounding\n let res = Duration::from_secs_f32(0.999e-9);\n assert_eq!(res, Duration::new(0, 1));\n ```", - &["secs"], - ) - .register_documented( - "from_secs_f64", - |secs: f64| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_secs_f64( - secs, - ) - .into(); - output - } - }; - output - }, - " Creates a new `Duration` from the specified number of seconds represented\n as `f64`.\n # Panics\n This constructor will panic if `secs` is negative, overflows `Duration` or not finite.\n # Examples\n ```\n use std::time::Duration;\n let res = Duration::from_secs_f64(0.0);\n assert_eq!(res, Duration::new(0, 0));\n let res = Duration::from_secs_f64(1e-20);\n assert_eq!(res, Duration::new(0, 0));\n let res = Duration::from_secs_f64(4.2e-7);\n assert_eq!(res, Duration::new(0, 420));\n let res = Duration::from_secs_f64(2.7);\n assert_eq!(res, Duration::new(2, 700_000_000));\n let res = Duration::from_secs_f64(3e10);\n assert_eq!(res, Duration::new(30_000_000_000, 0));\n // subnormal float\n let res = Duration::from_secs_f64(f64::from_bits(1));\n assert_eq!(res, Duration::new(0, 0));\n // conversion uses rounding\n let res = Duration::from_secs_f64(0.999e-9);\n assert_eq!(res, Duration::new(0, 1));\n ```", - &["secs"], - ) - .register_documented( - "from_weeks", - |weeks: u64| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_weeks( - weeks, - ) - .into(); - output - } - }; - output - }, - " Creates a new `Duration` from the specified number of weeks.\n # Panics\n Panics if the given number of weeks overflows the `Duration` size.\n # Examples\n ```\n #![feature(duration_constructors)]\n use std::time::Duration;\n let duration = Duration::from_weeks(4);\n assert_eq!(4 * 7 * 24 * 60 * 60, duration.as_secs());\n assert_eq!(0, duration.subsec_nanos());\n ```", - &["weeks"], - ) - .register_documented( - "is_zero", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: bool = { - { - let output: bool = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::is_zero( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns true if this `Duration` spans no time.\n # Examples\n ```\n use std::time::Duration;\n assert!(Duration::ZERO.is_zero());\n assert!(Duration::new(0, 0).is_zero());\n assert!(Duration::from_nanos(0).is_zero());\n assert!(Duration::from_secs(0).is_zero());\n assert!(!Duration::new(1, 1).is_zero());\n assert!(!Duration::from_nanos(1).is_zero());\n assert!(!Duration::from_secs(1).is_zero());\n ```", - &["_self"], - ) - .register_documented( - "mul", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - rhs: u32| - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< - u32, - >>::mul(_self.into_inner(), rhs) - .into(); - output - } - }; - output - }, - "", - &["_self", "rhs"], - ) - .register_documented( - "mul_f32", + "clone", | - _self: Val< + _self: Ref< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - rhs: f32| + >| { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, @@ -1285,9 +210,8 @@ pub(crate) fn register_duration_functions(world: &mut World) { { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::mul_f32( - _self.into_inner(), - rhs, + > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + &_self, ) .into(); output @@ -1295,16 +219,16 @@ pub(crate) fn register_duration_functions(world: &mut World) { }; output }, - " Multiplies `Duration` by `f32`.\n # Panics\n This method will panic if result is negative, overflows `Duration` or not finite.\n # Examples\n ```\n use std::time::Duration;\n let dur = Duration::new(2, 700_000_000);\n assert_eq!(dur.mul_f32(3.14), Duration::new(8, 478_000_641));\n assert_eq!(dur.mul_f32(3.14e5), Duration::new(847_800, 0));\n ```", - &["_self", "rhs"], + "", + &["_self"], ) .register_documented( - "mul_f64", + "div", | _self: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, >, - rhs: f64| + rhs: u32| { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, @@ -1312,60 +236,53 @@ pub(crate) fn register_duration_functions(world: &mut World) { { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::mul_f64( - _self.into_inner(), - rhs, - ) + > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + u32, + >>::div(_self.into_inner(), rhs) .into(); output } }; output }, - " Multiplies `Duration` by `f64`.\n # Panics\n This method will panic if result is negative, overflows `Duration` or not finite.\n # Examples\n ```\n use std::time::Duration;\n let dur = Duration::new(2, 700_000_000);\n assert_eq!(dur.mul_f64(3.14), Duration::new(8, 478_000_000));\n assert_eq!(dur.mul_f64(3.14e5), Duration::new(847_800, 0));\n ```", + "", &["_self", "rhs"], ) .register_documented( - "new", - |secs: u64, nanos: u32| { - let output: Val< + "eq", + | + _self: Ref< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { + >, + other: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: bool = { { - let output: Val< + let output: bool = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::new( - secs, - nanos, - ) + >>::eq(&_self, &other) .into(); output } }; output }, - " Creates a new `Duration` from the specified number of whole seconds and\n additional nanoseconds.\n If the number of nanoseconds is greater than 1 billion (the number of\n nanoseconds in a second), then it will carry over into the seconds provided.\n # Panics\n This constructor will panic if the carry from the nanoseconds overflows\n the seconds counter.\n # Examples\n ```\n use std::time::Duration;\n let five_seconds = Duration::new(5, 0);\n ```", - &["secs", "nanos"], + "", + &["_self", "other"], ) .register_documented( - "saturating_add", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - rhs: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { + "from_hours", + |hours: u64| { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, > = { { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::saturating_add( - _self.into_inner(), - rhs.into_inner(), + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_hours( + hours, ) .into(); output @@ -1373,26 +290,20 @@ pub(crate) fn register_duration_functions(world: &mut World) { }; output }, - " Saturating `Duration` addition. Computes `self + other`, returning [`Duration::MAX`]\n if overflow occurred.\n # Examples\n ```\n #![feature(duration_constants)]\n use std::time::Duration;\n assert_eq!(Duration::new(0, 0).saturating_add(Duration::new(0, 1)), Duration::new(0, 1));\n assert_eq!(Duration::new(1, 0).saturating_add(Duration::new(u64::MAX, 0)), Duration::MAX);\n ```", - &["_self", "rhs"], + " Creates a new `Duration` from the specified number of hours.\n # Panics\n Panics if the given number of hours overflows the `Duration` size.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_hours(6);\n assert_eq!(6 * 60 * 60, duration.as_secs());\n assert_eq!(0, duration.subsec_nanos());\n ```", + &["hours"], ) .register_documented( - "saturating_mul", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - rhs: u32| - { + "from_mins", + |mins: u64| { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, > = { { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::saturating_mul( - _self.into_inner(), - rhs, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_mins( + mins, ) .into(); output @@ -1400,18 +311,16 @@ pub(crate) fn register_duration_functions(world: &mut World) { }; output }, - " Saturating `Duration` multiplication. Computes `self * other`, returning\n [`Duration::MAX`] if overflow occurred.\n # Examples\n ```\n #![feature(duration_constants)]\n use std::time::Duration;\n assert_eq!(Duration::new(0, 500_000_001).saturating_mul(2), Duration::new(1, 2));\n assert_eq!(Duration::new(u64::MAX - 1, 0).saturating_mul(2), Duration::MAX);\n ```", - &["_self", "rhs"], + " Creates a new `Duration` from the specified number of minutes.\n # Panics\n Panics if the given number of minutes overflows the `Duration` size.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_mins(10);\n assert_eq!(10 * 60, duration.as_secs());\n assert_eq!(0, duration.subsec_nanos());\n ```", + &["mins"], ) .register_documented( - "saturating_sub", + "mul", | _self: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, >, - rhs: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| + rhs: u32| { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, @@ -1419,17 +328,16 @@ pub(crate) fn register_duration_functions(world: &mut World) { { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) + > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + u32, + >>::mul(_self.into_inner(), rhs) .into(); output } }; output }, - " Saturating `Duration` subtraction. Computes `self - other`, returning [`Duration::ZERO`]\n if the result would be negative or if overflow occurred.\n # Examples\n ```\n use std::time::Duration;\n assert_eq!(Duration::new(0, 1).saturating_sub(Duration::new(0, 0)), Duration::new(0, 1));\n assert_eq!(Duration::new(0, 0).saturating_sub(Duration::new(0, 1)), Duration::ZERO);\n ```", + "", &["_self", "rhs"], ) .register_documented( @@ -1459,69 +367,6 @@ pub(crate) fn register_duration_functions(world: &mut World) { }, "", &["_self", "rhs"], - ) - .register_documented( - "subsec_micros", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: u32 = { - { - let output: u32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::subsec_micros( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the fractional part of this `Duration`, in whole microseconds.\n This method does **not** return the length of the duration when\n represented by microseconds. The returned number always represents a\n fractional portion of a second (i.e., it is less than one million).\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_micros(1_234_567);\n assert_eq!(duration.as_secs(), 1);\n assert_eq!(duration.subsec_micros(), 234_567);\n ```", - &["_self"], - ) - .register_documented( - "subsec_millis", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: u32 = { - { - let output: u32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::subsec_millis( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the fractional part of this `Duration`, in whole milliseconds.\n This method does **not** return the length of the duration when\n represented by milliseconds. The returned number always represents a\n fractional portion of a second (i.e., it is less than one thousand).\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_millis(5_432);\n assert_eq!(duration.as_secs(), 5);\n assert_eq!(duration.subsec_millis(), 432);\n ```", - &["_self"], - ) - .register_documented( - "subsec_nanos", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: u32 = { - { - let output: u32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::subsec_nanos( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the fractional part of this `Duration`, in nanoseconds.\n This method does **not** return the length of the duration when\n represented by nanoseconds. The returned number always represents a\n fractional portion of a second (i.e., it is less than one billion).\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_millis(5_010);\n assert_eq!(duration.as_secs(), 5);\n assert_eq!(duration.subsec_nanos(), 10_000_000);\n ```", - &["_self"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -1591,46 +436,6 @@ pub(crate) fn register_instant_functions(world: &mut World) { "", &["_self"], ) - .register_documented( - "duration_since", - |_self: Ref<::std::time::Instant>, earlier: Val<::std::time::Instant>| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::std::time::Instant::duration_since( - &_self, - earlier.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Returns the amount of time elapsed from another instant to this one,\n or zero duration if that instant is later than this one.\n # Panics\n Previous Rust versions panicked when `earlier` was later than `self`. Currently this\n method saturates. Future versions may reintroduce the panic in some circumstances.\n See [Monotonicity].\n [Monotonicity]: Instant#monotonicity\n # Examples\n ```no_run\n use std::time::{Duration, Instant};\n use std::thread::sleep;\n let now = Instant::now();\n sleep(Duration::new(1, 0));\n let new_now = Instant::now();\n println!(\"{:?}\", new_now.duration_since(now));\n println!(\"{:?}\", now.duration_since(new_now)); // 0ns\n ```", - &["_self", "earlier"], - ) - .register_documented( - "elapsed", - |_self: Ref<::std::time::Instant>| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::std::time::Instant::elapsed(&_self).into(); - output - } - }; - output - }, - " Returns the amount of time elapsed since this instant.\n # Panics\n Previous Rust versions panicked when the current time was earlier than self. Currently this\n method returns a Duration of zero in that case. Future versions may reintroduce the panic.\n See [Monotonicity].\n [Monotonicity]: Instant#monotonicity\n # Examples\n ```no_run\n use std::thread::sleep;\n use std::time::{Duration, Instant};\n let instant = Instant::now();\n let three_secs = Duration::from_secs(3);\n sleep(three_secs);\n assert!(instant.elapsed() >= three_secs);\n ```", - &["_self"], - ) .register_documented( "eq", |_self: Ref<::std::time::Instant>, other: Ref<::std::time::Instant>| { @@ -1648,43 +453,6 @@ pub(crate) fn register_instant_functions(world: &mut World) { "", &["_self", "other"], ) - .register_documented( - "now", - || { - let output: Val<::std::time::Instant> = { - { - let output: Val<::std::time::Instant> = ::std::time::Instant::now() - .into(); - output - } - }; - output - }, - " Returns an instant corresponding to \"now\".\n # Examples\n ```\n use std::time::Instant;\n let now = Instant::now();\n ```", - &[], - ) - .register_documented( - "saturating_duration_since", - |_self: Ref<::std::time::Instant>, earlier: Val<::std::time::Instant>| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::std::time::Instant::saturating_duration_since( - &_self, - earlier.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Returns the amount of time elapsed from another instant to this one,\n or zero duration if that instant is later than this one.\n # Examples\n ```no_run\n use std::time::{Duration, Instant};\n use std::thread::sleep;\n let now = Instant::now();\n sleep(Duration::new(1, 0));\n let new_now = Instant::now();\n println!(\"{:?}\", new_now.saturating_duration_since(now));\n println!(\"{:?}\", now.saturating_duration_since(new_now)); // 0ns\n ```", - &["_self", "earlier"], - ) .register_documented( "sub", | @@ -4843,92 +3611,6 @@ pub(crate) fn register_socket_addr_functions(world: &mut World) { }, "", &["_self", "other"], - ) - .register_documented( - "is_ipv4", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, - >| - { - let output: bool = { - { - let output: bool = ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr::is_ipv4( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns [`true`] if the [IP address] in this `SocketAddr` is an\n [`IPv4` address], and [`false`] otherwise.\n [IP address]: IpAddr\n [`IPv4` address]: IpAddr::V4\n # Examples\n ```\n use std::net::{IpAddr, Ipv4Addr, SocketAddr};\n let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);\n assert_eq!(socket.is_ipv4(), true);\n assert_eq!(socket.is_ipv6(), false);\n ```", - &["_self"], - ) - .register_documented( - "is_ipv6", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, - >| - { - let output: bool = { - { - let output: bool = ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr::is_ipv6( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns [`true`] if the [IP address] in this `SocketAddr` is an\n [`IPv6` address], and [`false`] otherwise.\n [IP address]: IpAddr\n [`IPv6` address]: IpAddr::V6\n # Examples\n ```\n use std::net::{IpAddr, Ipv6Addr, SocketAddr};\n let socket = SocketAddr::new(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 65535, 0, 1)), 8080);\n assert_eq!(socket.is_ipv4(), false);\n assert_eq!(socket.is_ipv6(), true);\n ```", - &["_self"], - ) - .register_documented( - "port", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, - >| - { - let output: u16 = { - { - let output: u16 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr::port( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the port number associated with this socket address.\n # Examples\n ```\n use std::net::{IpAddr, Ipv4Addr, SocketAddr};\n let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);\n assert_eq!(socket.port(), 8080);\n ```", - &["_self"], - ) - .register_documented( - "set_port", - | - mut _self: Mut< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, - >, - new_port: u16| - { - let output: () = { - { - let output: () = ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr::set_port( - &mut _self, - new_port, - ) - .into(); - output - } - }; - output - }, - " Changes the port number associated with this socket address.\n # Examples\n ```\n use std::net::{IpAddr, Ipv4Addr, SocketAddr};\n let mut socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);\n socket.set_port(1025);\n assert_eq!(socket.port(), 1025);\n ```", - &["_self", "new_port"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); diff --git a/crates/bindings/bevy_render_bms_bindings/Cargo.toml b/crates/bindings/bevy_render_bms_bindings/Cargo.toml index 2f5dcf3226..e3cd268e5d 100644 --- a/crates/bindings/bevy_render_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_render_bms_bindings/Cargo.toml @@ -22,43 +22,43 @@ bevy_render = { version = "0.17.2", features = ["multi_threaded", "webgl"], defa async-channel = { version = "^2.3.0", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} bevy_diagnostic = { version = "^0.17.2", features = ["std", "sysinfo", "sysinfo_plugin"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} bevy_encase_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} bevy_render_macros = { version = "^0.17.2", features = [], default-features = true} bevy_shader = { version = "^0.17.2", features = [], default-features = true} -bevy_tasks = { version = "^0.17.2", features = ["multi_threaded", "async_executor", "futures-lite"], default-features = true} +bevy_tasks = { version = "^0.17.2", features = ["multi_threaded", "futures-lite", "async_executor"], default-features = true} bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["std", "bevy_reflect", "bevy_image", "bevy_asset", "custom_cursor"], default-features = true} bitflags = { version = "^2", features = [], default-features = true} diff --git a/crates/bindings/bevy_scene_bms_bindings/Cargo.toml b/crates/bindings/bevy_scene_bms_bindings/Cargo.toml index 16d3bd9906..5c45136b29 100644 --- a/crates/bindings/bevy_scene_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_scene_bms_bindings/Cargo.toml @@ -20,7 +20,7 @@ bevy_mod_scripting_derive = { workspace = true } bevy_scene = { version = "0.17.2", features = ["serialize"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} @@ -28,15 +28,15 @@ bevy_camera = { version = "^0.17.2", features = [], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["serialize", "std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["serialize", "std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register"], default-features = true} bevy_platform = { version = "^0.17.2", features = ["serialize", "alloc", "std"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} serde = { version = "^1.0", features = [], default-features = true} diff --git a/crates/bindings/bevy_sprite_bms_bindings/Cargo.toml b/crates/bindings/bevy_sprite_bms_bindings/Cargo.toml index 6603309374..99bf6254c9 100644 --- a/crates/bindings/bevy_sprite_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_sprite_bms_bindings/Cargo.toml @@ -20,33 +20,33 @@ bevy_mod_scripting_derive = { workspace = true } bevy_sprite = { version = "0.17.2", features = ["bevy_picking", "bevy_window", "bevy_sprite_picking_backend", "bevy_text"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} bevy_picking = { version = "^0.17.2", features = ["bevy_mesh_picking_backend"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} bevy_text = { version = "^0.17.2", features = ["default_font"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["std", "bevy_reflect", "bevy_image", "bevy_asset", "custom_cursor"], default-features = true} radsort = { version = "^0.1", features = [], default-features = true} diff --git a/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml b/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml index c8f098bf41..ad427cc594 100644 --- a/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml @@ -20,27 +20,27 @@ bevy_mod_scripting_derive = { workspace = true } bevy_sprite_render = { version = "0.17.2", features = ["bevy_text", "webgl"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} @@ -50,9 +50,9 @@ bevy_sprite = { version = "^0.17.2", features = ["bevy_text", "bevy_picking", "b bevy_text = { version = "^0.17.2", features = ["default_font"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_text_bms_bindings/Cargo.toml b/crates/bindings/bevy_text_bms_bindings/Cargo.toml index 5f2b1ef284..2757a37ab5 100644 --- a/crates/bindings/bevy_text_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_text_bms_bindings/Cargo.toml @@ -20,25 +20,25 @@ bevy_mod_scripting_derive = { workspace = true } bevy_text = { version = "0.17.2", features = ["default_font"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} bevy_log = { version = "^0.17.2", features = [], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} cosmic-text = { version = "^0.14", features = [], default-features = true} diff --git a/crates/bindings/bevy_time_bms_bindings/Cargo.toml b/crates/bindings/bevy_time_bms_bindings/Cargo.toml index c5c2c83399..e0c30b60a7 100644 --- a/crates/bindings/bevy_time_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_time_bms_bindings/Cargo.toml @@ -20,12 +20,12 @@ bevy_mod_scripting_derive = { workspace = true } bevy_time = { version = "0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "reflect_auto_register", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "multi_threaded", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} bevy_platform = { version = "^0.17.2", features = ["std", "alloc", "serialize"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} diff --git a/crates/bindings/bevy_transform_bms_bindings/Cargo.toml b/crates/bindings/bevy_transform_bms_bindings/Cargo.toml index 1dea392fa8..b51ad8f480 100644 --- a/crates/bindings/bevy_transform_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_transform_bms_bindings/Cargo.toml @@ -17,16 +17,16 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_transform = { version = "0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "reflect_auto_register", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "multi_threaded", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "alloc", "rand", "curve"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "rand", "curve", "alloc"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} bevy_tasks = { version = "^0.17.2", features = ["async_executor", "futures-lite", "multi_threaded"], default-features = true} diff --git a/crates/bindings/bevy_ui_bms_bindings/Cargo.toml b/crates/bindings/bevy_ui_bms_bindings/Cargo.toml index 6d45864df4..0fb5c12643 100644 --- a/crates/bindings/bevy_ui_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_ui_bms_bindings/Cargo.toml @@ -24,37 +24,37 @@ accesskit = { version = "^0.21", features = [], default-features = true} bevy_a11y = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} bevy_input = { version = "^0.17.2", features = ["std", "bevy_reflect", "smol_str"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} bevy_picking = { version = "^0.17.2", features = ["bevy_mesh_picking_backend"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} bevy_sprite = { version = "^0.17.2", features = ["bevy_picking", "bevy_window", "bevy_sprite_picking_backend", "bevy_text"], default-features = true} bevy_text = { version = "^0.17.2", features = ["default_font"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["std", "bevy_reflect", "bevy_image", "bevy_asset", "custom_cursor"], default-features = true} taffy = { version = "^0.7", features = [], default-features = true} diff --git a/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml b/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml index 7adb245adf..d29b7cce84 100644 --- a/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml @@ -20,27 +20,27 @@ bevy_mod_scripting_derive = { workspace = true } bevy_ui_render = { version = "0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} @@ -52,11 +52,11 @@ bevy_sprite_render = { version = "^0.17.2", features = ["bevy_text", "webgl"], d bevy_text = { version = "^0.17.2", features = ["default_font"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} bevy_ui = { version = "^0.17.2", features = ["bevy_picking", "bevy_ui_picking_backend"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} bytemuck = { version = "^1.5", features = [], default-features = true} From 6fd0664fc175983883a8af6af935bb55cd881e4e Mon Sep 17 00:00:00 2001 From: makspll Date: Sun, 9 Nov 2025 21:18:20 +0000 Subject: [PATCH 10/22] get it right --- Cargo.toml | 7 + codegen/src/bin/main.rs | 7 + codegen/src/passes/find_methods_and_fields.rs | 6 +- .../bevy_a11y_bms_bindings/Cargo.toml | 6 +- .../bevy_animation_bms_bindings/Cargo.toml | 14 +- .../bevy_asset_bms_bindings/Cargo.toml | 2 +- .../bevy_camera_bms_bindings/Cargo.toml | 18 +- .../bevy_color_bms_bindings/Cargo.toml | 6 +- .../Cargo.toml | 18 +- .../bindings/bevy_ecs_bms_bindings/Cargo.toml | 4 +- .../bevy_gizmos_bms_bindings/Cargo.toml | 16 +- .../bevy_gltf_bms_bindings/Cargo.toml | 16 +- .../bevy_image_bms_bindings/Cargo.toml | 12 +- .../bevy_input_bms_bindings/Cargo.toml | 8 +- .../bevy_input_focus_bms_bindings/Cargo.toml | 8 +- .../bevy_light_bms_bindings/Cargo.toml | 16 +- .../bevy_math_bms_bindings/Cargo.toml | 10 +- .../bevy_mesh_bms_bindings/Cargo.toml | 12 +- .../bindings/bevy_pbr_bms_bindings/Cargo.toml | 16 +- .../bevy_picking_bms_bindings/Cargo.toml | 12 +- .../bevy_post_process_bms_bindings/Cargo.toml | 18 +- .../bevy_reflect_bms_bindings/Cargo.toml | 2 +- .../bevy_reflect_bms_bindings/src/lib.rs | 1371 ++++++++++++++++- .../bevy_render_bms_bindings/Cargo.toml | 20 +- .../bevy_scene_bms_bindings/Cargo.toml | 10 +- .../bevy_sprite_bms_bindings/Cargo.toml | 16 +- .../Cargo.toml | 16 +- .../bevy_text_bms_bindings/Cargo.toml | 14 +- .../bevy_time_bms_bindings/Cargo.toml | 6 +- .../bevy_transform_bms_bindings/Cargo.toml | 10 +- .../bindings/bevy_ui_bms_bindings/Cargo.toml | 18 +- .../bevy_ui_render_bms_bindings/Cargo.toml | 16 +- 32 files changed, 1481 insertions(+), 250 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 013daf1893..2bb9d9762e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -66,6 +66,7 @@ core_functions = ["bevy_mod_scripting_functions/core_functions"] bevy_a11y_bindings = ["bevy_mod_scripting_functions/bevy_a11y"] bevy_animation_bindings = ["bevy_mod_scripting_functions/bevy_animation"] bevy_asset_bindings = ["bevy_mod_scripting_functions/bevy_asset"] +# bevy_camera bevy_color_bindings = ["bevy_mod_scripting_functions/bevy_color"] bevy_core_pipeline_bindings = [ "bevy_mod_scripting_functions/bevy_core_pipeline", @@ -76,17 +77,22 @@ bevy_gltf_bindings = ["bevy_mod_scripting_functions/bevy_gltf"] bevy_image_bindings = ["bevy_mod_scripting_functions/bevy_image"] bevy_input_bindings = ["bevy_mod_scripting_functions/bevy_input"] bevy_input_focus_bindings = ["bevy_mod_scripting_functions/bevy_input_focus"] +# bevy_light bevy_math_bindings = ["bevy_mod_scripting_functions/bevy_math"] bevy_mesh_bindings = ["bevy_mod_scripting_functions/bevy_mesh"] bevy_pbr_bindings = ["bevy_mod_scripting_functions/bevy_pbr"] bevy_picking_bindings = ["bevy_mod_scripting_functions/bevy_picking"] +# bevy_post_process bevy_reflect_bindings = ["bevy_mod_scripting_functions/bevy_reflect"] bevy_render_bindings = ["bevy_mod_scripting_functions/bevy_render"] bevy_scene_bindings = ["bevy_mod_scripting_functions/bevy_scene"] bevy_sprite_bindings = ["bevy_mod_scripting_functions/bevy_sprite"] +# bevy_sprite_renderer bevy_text_bindings = ["bevy_mod_scripting_functions/bevy_text"] bevy_time_bindings = ["bevy_mod_scripting_functions/bevy_time"] bevy_transform_bindings = ["bevy_mod_scripting_functions/bevy_transform"] +# bevy_ui +# bevy_ui_render # optional unsafe_lua_modules = ["bevy_mod_scripting_lua?/unsafe_lua_modules"] @@ -244,6 +250,7 @@ bevy = { workspace = true, features = [ "x11", "bevy_ui", "default_font", + "custom_cursor", ] } bevy_platform = { workspace = true } clap = { workspace = true, features = ["derive"] } diff --git a/codegen/src/bin/main.rs b/codegen/src/bin/main.rs index 9481a18d0b..b952a6a276 100644 --- a/codegen/src/bin/main.rs +++ b/codegen/src/bin/main.rs @@ -29,6 +29,13 @@ fn main() { info!("Using RUST_LOG: {:?}", env::var("RUST_LOG")); + info!( + "MSRV target: {}", + args.mrsv_target() + .map(|t| t.to_string()) + .unwrap_or(String::from("unset")) + ); + info!("Computing crate metadata"); let metadata = cargo_metadata::MetadataCommand::new() .no_deps() diff --git a/codegen/src/passes/find_methods_and_fields.rs b/codegen/src/passes/find_methods_and_fields.rs index c28f28fa9f..39cc1c5bb1 100644 --- a/codegen/src/passes/find_methods_and_fields.rs +++ b/codegen/src/passes/find_methods_and_fields.rs @@ -196,12 +196,16 @@ pub(crate) fn find_methods_and_fields(ctxt: &mut BevyCtxt<'_>, args: &Args) -> b .lookup_stability(fn_did) .map(|stability| match stability.stable_since() { Some(StableSince::Version(rustc_version)) => { - args.rustc_version_is_greater_than_mrsv_target(rustc_version) + !args.rustc_version_is_greater_than_mrsv_target(rustc_version) } _ => false, }) .unwrap_or(true); + log::info!("function: {}, is_stable_for_target: {is_stable_for_target}, stability: {:?}", ctxt.tcx.item_name(def_id), ctxt + .tcx + .lookup_stability(fn_did)); + if !is_stable_for_target { log::debug!( "Skipping unstable function: `{}` on type: `{}`, msrv target: {:?}", diff --git a/crates/bindings/bevy_a11y_bms_bindings/Cargo.toml b/crates/bindings/bevy_a11y_bms_bindings/Cargo.toml index a7b8f0a7f7..3fbc89a7cf 100644 --- a/crates/bindings/bevy_a11y_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_a11y_bms_bindings/Cargo.toml @@ -20,12 +20,12 @@ bevy_mod_scripting_derive = { workspace = true } bevy_a11y = { version = "0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "reflect_auto_register", "error_panic_hook"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "multi_threaded", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} diff --git a/crates/bindings/bevy_animation_bms_bindings/Cargo.toml b/crates/bindings/bevy_animation_bms_bindings/Cargo.toml index 96ad701028..963f919372 100644 --- a/crates/bindings/bevy_animation_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_animation_bms_bindings/Cargo.toml @@ -22,27 +22,27 @@ bevy_animation = { version = "0.17.2", features = [], default-features = true} bevy_animation_macros = { version = "^0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} -bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} blake3 = { version = "^1.0", features = [], default-features = true} diff --git a/crates/bindings/bevy_asset_bms_bindings/Cargo.toml b/crates/bindings/bevy_asset_bms_bindings/Cargo.toml index b88d738efc..bfd7abf50d 100644 --- a/crates/bindings/bevy_asset_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_asset_bms_bindings/Cargo.toml @@ -22,7 +22,7 @@ bevy_asset = { version = "0.17.2", features = ["notify-debouncer-full", "watch", bevy_asset_macros = { version = "^0.17.2", features = [], default-features = true} -bevy_tasks = { version = "^0.17.2", features = ["multi_threaded", "futures-lite", "async_executor"], default-features = true} +bevy_tasks = { version = "^0.17.2", features = ["multi_threaded", "async_executor", "futures-lite"], default-features = true} js-sys = { version = "^0.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_camera_bms_bindings/Cargo.toml b/crates/bindings/bevy_camera_bms_bindings/Cargo.toml index 8855c5ea82..c631798d71 100644 --- a/crates/bindings/bevy_camera_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_camera_bms_bindings/Cargo.toml @@ -20,28 +20,28 @@ bevy_mod_scripting_derive = { workspace = true } bevy_camera = { version = "0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} -bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["std", "bevy_reflect", "bevy_image", "bevy_asset", "custom_cursor"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} diff --git a/crates/bindings/bevy_color_bms_bindings/Cargo.toml b/crates/bindings/bevy_color_bms_bindings/Cargo.toml index 84f4b59f7e..27c1e36e3b 100644 --- a/crates/bindings/bevy_color_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_color_bms_bindings/Cargo.toml @@ -17,12 +17,12 @@ bevy_app = { workspace = true, features = ["std"] } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_color = { version = "0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} +bevy_color = { version = "0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "alloc", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} bytemuck = { version = "^1", features = [], default-features = true} diff --git a/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml b/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml index f3aa36ded9..92449ed963 100644 --- a/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml @@ -20,33 +20,33 @@ bevy_mod_scripting_derive = { workspace = true } bevy_core_pipeline = { version = "0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["ktx2", "zstd", "bevy_reflect", "hdr", "png", "zstd_rust"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["ktx2", "zstd", "hdr", "png", "zstd_rust", "bevy_reflect"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} bevy_shader = { version = "^0.17.2", features = [], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["std", "bevy_reflect", "bevy_image", "bevy_asset", "custom_cursor"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_ecs_bms_bindings/Cargo.toml b/crates/bindings/bevy_ecs_bms_bindings/Cargo.toml index a308730893..caaf910f49 100644 --- a/crates/bindings/bevy_ecs_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_ecs_bms_bindings/Cargo.toml @@ -17,7 +17,7 @@ bevy_app = { workspace = true, features = ["std"] } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_ecs = { version = "0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} +bevy_ecs = { version = "0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} arrayvec = { version = "^0.7.4", features = ["std"], default-features = false} @@ -28,7 +28,7 @@ bevy_platform = { version = "^0.17.2", features = ["std", "serialize", "alloc"], bevy_ptr = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "auto_register", "glam", "uuid", "smol_str", "smallvec", "debug", "auto_register_inventory", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["std", "auto_register", "glam", "uuid", "smol_str", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} bevy_tasks = { version = "^0.17.2", features = ["async_executor", "multi_threaded", "futures-lite"], default-features = true} diff --git a/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml b/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml index d6fde7a971..bbc8ec2312 100644 --- a/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml @@ -20,31 +20,31 @@ bevy_mod_scripting_derive = { workspace = true } bevy_gizmos = { version = "0.17.2", features = ["bevy_pbr", "bevy_core_pipeline", "bevy_render", "bevy_sprite_render", "webgl"], default-features = false} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} bevy_gizmos_macros = { version = "^0.17.2", features = [], default-features = true} -bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} bevy_light = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} bevy_pbr = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} @@ -54,9 +54,9 @@ bevy_sprite_render = { version = "^0.17.2", features = ["bevy_text", "webgl"], d bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} bytemuck = { version = "^1.0", features = [], default-features = true} diff --git a/crates/bindings/bevy_gltf_bms_bindings/Cargo.toml b/crates/bindings/bevy_gltf_bms_bindings/Cargo.toml index b6b9e11000..465a5e174d 100644 --- a/crates/bindings/bevy_gltf_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_gltf_bms_bindings/Cargo.toml @@ -24,35 +24,35 @@ base64 = { version = "^0.22.0", features = [], default-features = true} bevy_animation = { version = "^0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} bevy_light = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} bevy_pbr = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} bevy_scene = { version = "^0.17.2", features = ["serialize"], default-features = true} -bevy_tasks = { version = "^0.17.2", features = ["futures-lite", "async_executor", "multi_threaded"], default-features = true} +bevy_tasks = { version = "^0.17.2", features = ["async_executor", "futures-lite", "multi_threaded"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} fixedbitset = { version = "^0.5", features = [], default-features = true} diff --git a/crates/bindings/bevy_image_bms_bindings/Cargo.toml b/crates/bindings/bevy_image_bms_bindings/Cargo.toml index e0b42241c7..2f28a5b232 100644 --- a/crates/bindings/bevy_image_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_image_bms_bindings/Cargo.toml @@ -17,20 +17,20 @@ bevy_ecs = { workspace = true, features = ["std", "bevy_reflect"] } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_image = { version = "0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} +bevy_image = { version = "0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} -bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["bevy_reflect", "std", "rand", "curve", "alloc"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["bevy_reflect", "alloc", "std", "rand", "curve"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_input_bms_bindings/Cargo.toml b/crates/bindings/bevy_input_bms_bindings/Cargo.toml index a180a74cd6..35c5329b27 100644 --- a/crates/bindings/bevy_input_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_input_bms_bindings/Cargo.toml @@ -20,14 +20,14 @@ bevy_mod_scripting_derive = { workspace = true } bevy_input = { version = "0.17.2", features = ["std", "bevy_reflect", "smol_str"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "reflect_auto_register", "error_panic_hook"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "multi_threaded", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "rand", "curve", "alloc"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "alloc", "rand", "curve"], default-features = true} bevy_platform = { version = "^0.17.2", features = ["std", "alloc", "serialize"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "smol_str", "glam", "uuid", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["std", "smol_str", "glam", "uuid", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} diff --git a/crates/bindings/bevy_input_focus_bms_bindings/Cargo.toml b/crates/bindings/bevy_input_focus_bms_bindings/Cargo.toml index ef91bb7bc5..f5fe7df372 100644 --- a/crates/bindings/bevy_input_focus_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_input_focus_bms_bindings/Cargo.toml @@ -20,15 +20,15 @@ bevy_mod_scripting_derive = { workspace = true } bevy_input_focus = { version = "0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "reflect_auto_register", "error_panic_hook"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "multi_threaded", "reflect_auto_register", "backtrace", "serialize"], default-features = true} bevy_input = { version = "^0.17.2", features = ["std", "bevy_reflect", "smol_str"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "rand", "curve", "alloc"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "alloc", "rand", "curve"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} bevy_window = { version = "^0.17.2", features = ["std", "bevy_reflect", "bevy_image", "bevy_asset", "custom_cursor"], default-features = true} diff --git a/crates/bindings/bevy_light_bms_bindings/Cargo.toml b/crates/bindings/bevy_light_bms_bindings/Cargo.toml index 9b5405851d..31118f9dc7 100644 --- a/crates/bindings/bevy_light_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_light_bms_bindings/Cargo.toml @@ -20,28 +20,28 @@ bevy_mod_scripting_derive = { workspace = true } bevy_light = { version = "0.17.2", features = ["webgl"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} bevy_platform = { version = "^0.17.2", features = ["alloc", "std", "serialize"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} diff --git a/crates/bindings/bevy_math_bms_bindings/Cargo.toml b/crates/bindings/bevy_math_bms_bindings/Cargo.toml index 69aa9c99a8..dc18f5c448 100644 --- a/crates/bindings/bevy_math_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_math_bms_bindings/Cargo.toml @@ -17,20 +17,20 @@ bevy_app = { workspace = true, features = ["std"] } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_math = { version = "0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} +bevy_math = { version = "0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} derive_more = { version = "^2", features = ["std"], default-features = false} glam = { version = "^0.30.1", features = ["std", "rand"], default-features = false} -itertools = { version = "^0.14.0", features = ["use_std", "use_alloc"], default-features = false} +itertools = { version = "^0.14.0", features = ["use_alloc", "use_std"], default-features = false} -rand = { version = "^0.9", features = ["std", "alloc"], default-features = false} +rand = { version = "^0.9", features = ["alloc", "std"], default-features = false} -rand_distr = { version = "^0.5", features = ["std", "alloc"], default-features = false} +rand_distr = { version = "^0.5", features = ["alloc", "std"], default-features = false} variadics_please = { version = "^1.1", features = [], default-features = true} diff --git a/crates/bindings/bevy_mesh_bms_bindings/Cargo.toml b/crates/bindings/bevy_mesh_bms_bindings/Cargo.toml index 51570623cc..12a4cbd5da 100644 --- a/crates/bindings/bevy_mesh_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_mesh_bms_bindings/Cargo.toml @@ -20,23 +20,23 @@ bevy_mod_scripting_derive = { workspace = true } bevy_mesh = { version = "0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} bevy_mikktspace = { version = "^0.17.0-dev", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml b/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml index 1feac068a9..63b006de77 100644 --- a/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml @@ -20,13 +20,13 @@ bevy_mod_scripting_derive = { workspace = true } bevy_pbr = { version = "0.17.2", features = ["webgl"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} @@ -34,25 +34,25 @@ bevy_derive = { version = "^0.17.2", features = [], default-features = true} bevy_diagnostic = { version = "^0.17.2", features = ["std", "sysinfo", "sysinfo_plugin"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} bevy_light = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} bevy_shader = { version = "^0.17.2", features = [], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_picking_bms_bindings/Cargo.toml b/crates/bindings/bevy_picking_bms_bindings/Cargo.toml index 9eb00004be..77612c0975 100644 --- a/crates/bindings/bevy_picking_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_picking_bms_bindings/Cargo.toml @@ -20,7 +20,7 @@ bevy_mod_scripting_derive = { workspace = true } bevy_picking = { version = "0.17.2", features = ["bevy_mesh_picking_backend"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} @@ -28,21 +28,21 @@ bevy_camera = { version = "^0.17.2", features = [], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} bevy_input = { version = "^0.17.2", features = ["std", "bevy_reflect", "smol_str"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["std", "bevy_reflect", "bevy_image", "bevy_asset", "custom_cursor"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} crossbeam-channel = { version = "^0.5", features = [], default-features = true} diff --git a/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml b/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml index 49585c0190..7430aec1de 100644 --- a/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml @@ -20,35 +20,35 @@ bevy_mod_scripting_derive = { workspace = true } bevy_post_process = { version = "0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} bevy_shader = { version = "^0.17.2", features = [], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["std", "bevy_reflect", "bevy_image", "bevy_asset", "custom_cursor"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_reflect_bms_bindings/Cargo.toml b/crates/bindings/bevy_reflect_bms_bindings/Cargo.toml index 3c7eeb6b2a..1fb53448a4 100644 --- a/crates/bindings/bevy_reflect_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_reflect_bms_bindings/Cargo.toml @@ -17,7 +17,7 @@ bevy_app = { workspace = true, features = ["std"] } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_reflect = { version = "0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} assert_type_match = { version = "^0.1.1", features = [], default-features = true} diff --git a/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs b/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs index 4fffdad76e..f19b963038 100644 --- a/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs @@ -15,7 +15,49 @@ pub struct BevyReflectScriptingPlugin; pub(crate) fn register_atomic_bool_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool, - >::new(world); + >::new(world) + .register_documented( + "into_inner", + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool, + >| + { + let output: bool = { + { + let output: bool = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool::into_inner( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\n use std::sync::atomic::AtomicBool;\n let some_bool = AtomicBool::new(true);\n assert_eq!(some_bool.into_inner(), true);\n ```", + &["_self"], + ) + .register_documented( + "new", + |v: bool| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool::new( + v, + ) + .into(); + output + } + }; + output + }, + " Creates a new `AtomicBool`.\n # Examples\n ```\n use std::sync::atomic::AtomicBool;\n let atomic_true = AtomicBool::new(true);\n let atomic_false = AtomicBool::new(false);\n ```", + &["v"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -27,7 +69,49 @@ pub(crate) fn register_atomic_bool_functions(world: &mut World) { pub(crate) fn register_atomic_i_8_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8, - >::new(world); + >::new(world) + .register_documented( + "into_inner", + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8, + >| + { + let output: i8 = { + { + let output: i8 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8::into_inner( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicI8;\nlet some_var = AtomicI8::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", + &["_self"], + ) + .register_documented( + "new", + |v: i8| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8::new( + v, + ) + .into(); + output + } + }; + output + }, + " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicI8;\nlet atomic_forty_two = AtomicI8::new(42);\n ```", + &["v"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -39,7 +123,49 @@ pub(crate) fn register_atomic_i_8_functions(world: &mut World) { pub(crate) fn register_atomic_i_16_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16, - >::new(world); + >::new(world) + .register_documented( + "into_inner", + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16, + >| + { + let output: i16 = { + { + let output: i16 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16::into_inner( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicI16;\nlet some_var = AtomicI16::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", + &["_self"], + ) + .register_documented( + "new", + |v: i16| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16::new( + v, + ) + .into(); + output + } + }; + output + }, + " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicI16;\nlet atomic_forty_two = AtomicI16::new(42);\n ```", + &["v"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -51,7 +177,49 @@ pub(crate) fn register_atomic_i_16_functions(world: &mut World) { pub(crate) fn register_atomic_i_32_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32, - >::new(world); + >::new(world) + .register_documented( + "into_inner", + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32, + >| + { + let output: i32 = { + { + let output: i32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32::into_inner( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicI32;\nlet some_var = AtomicI32::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", + &["_self"], + ) + .register_documented( + "new", + |v: i32| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32::new( + v, + ) + .into(); + output + } + }; + output + }, + " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicI32;\nlet atomic_forty_two = AtomicI32::new(42);\n ```", + &["v"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -63,7 +231,49 @@ pub(crate) fn register_atomic_i_32_functions(world: &mut World) { pub(crate) fn register_atomic_i_64_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64, - >::new(world); + >::new(world) + .register_documented( + "into_inner", + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64, + >| + { + let output: i64 = { + { + let output: i64 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64::into_inner( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicI64;\nlet some_var = AtomicI64::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", + &["_self"], + ) + .register_documented( + "new", + |v: i64| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64::new( + v, + ) + .into(); + output + } + }; + output + }, + " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicI64;\nlet atomic_forty_two = AtomicI64::new(42);\n ```", + &["v"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -75,7 +285,49 @@ pub(crate) fn register_atomic_i_64_functions(world: &mut World) { pub(crate) fn register_atomic_isize_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize, - >::new(world); + >::new(world) + .register_documented( + "into_inner", + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize, + >| + { + let output: isize = { + { + let output: isize = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize::into_inner( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicIsize;\nlet some_var = AtomicIsize::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", + &["_self"], + ) + .register_documented( + "new", + |v: isize| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize::new( + v, + ) + .into(); + output + } + }; + output + }, + " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicIsize;\nlet atomic_forty_two = AtomicIsize::new(42);\n ```", + &["v"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -87,7 +339,49 @@ pub(crate) fn register_atomic_isize_functions(world: &mut World) { pub(crate) fn register_atomic_u_8_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8, - >::new(world); + >::new(world) + .register_documented( + "into_inner", + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8, + >| + { + let output: u8 = { + { + let output: u8 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8::into_inner( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicU8;\nlet some_var = AtomicU8::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", + &["_self"], + ) + .register_documented( + "new", + |v: u8| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8::new( + v, + ) + .into(); + output + } + }; + output + }, + " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicU8;\nlet atomic_forty_two = AtomicU8::new(42);\n ```", + &["v"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -99,31 +393,157 @@ pub(crate) fn register_atomic_u_8_functions(world: &mut World) { pub(crate) fn register_atomic_u_16_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16, - >::new(world); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_atomic_u_32_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32, - >::new(world); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_atomic_u_64_functions(world: &mut World) { + >::new(world) + .register_documented( + "into_inner", + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16, + >| + { + let output: u16 = { + { + let output: u16 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16::into_inner( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicU16;\nlet some_var = AtomicU16::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", + &["_self"], + ) + .register_documented( + "new", + |v: u16| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16::new( + v, + ) + .into(); + output + } + }; + output + }, + " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicU16;\nlet atomic_forty_two = AtomicU16::new(42);\n ```", + &["v"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_atomic_u_32_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32, + >::new(world) + .register_documented( + "into_inner", + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32, + >| + { + let output: u32 = { + { + let output: u32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32::into_inner( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicU32;\nlet some_var = AtomicU32::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", + &["_self"], + ) + .register_documented( + "new", + |v: u32| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32::new( + v, + ) + .into(); + output + } + }; + output + }, + " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicU32;\nlet atomic_forty_two = AtomicU32::new(42);\n ```", + &["v"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_atomic_u_64_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64, - >::new(world); + >::new(world) + .register_documented( + "into_inner", + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64, + >| + { + let output: u64 = { + { + let output: u64 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64::into_inner( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicU64;\nlet some_var = AtomicU64::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", + &["_self"], + ) + .register_documented( + "new", + |v: u64| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64::new( + v, + ) + .into(); + output + } + }; + output + }, + " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicU64;\nlet atomic_forty_two = AtomicU64::new(42);\n ```", + &["v"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -135,7 +555,49 @@ pub(crate) fn register_atomic_u_64_functions(world: &mut World) { pub(crate) fn register_atomic_usize_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize, - >::new(world); + >::new(world) + .register_documented( + "into_inner", + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize, + >| + { + let output: usize = { + { + let output: usize = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize::into_inner( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Consumes the atomic and returns the contained value.\n This is safe because passing `self` by value guarantees that no other threads are\n concurrently accessing the atomic data.\n # Examples\n ```\nuse std::sync::atomic::AtomicUsize;\nlet some_var = AtomicUsize::new(5);\n assert_eq!(some_var.into_inner(), 5);\n ```", + &["_self"], + ) + .register_documented( + "new", + |v: usize| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize::new( + v, + ) + .into(); + output + } + }; + output + }, + " Creates a new atomic integer.\n # Examples\n ```\nuse std::sync::atomic::AtomicUsize;\nlet atomic_forty_two = AtomicUsize::new(42);\n ```", + &["v"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -148,6 +610,35 @@ pub(crate) fn register_duration_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, >::new(world) + .register_documented( + "abs_diff", + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + other: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::abs_diff( + _self.into_inner(), + other.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes the absolute difference between `self` and `other`.\n # Examples\n ```\n use std::time::Duration;\n assert_eq!(Duration::new(100, 0).abs_diff(Duration::new(80, 0)), Duration::new(20, 0));\n assert_eq!(Duration::new(100, 400_000_000).abs_diff(Duration::new(110, 0)), Duration::new(9, 600_000_000));\n ```", + &["_self", "other"], + ) .register_documented( "add", | @@ -177,15 +668,15 @@ pub(crate) fn register_duration_functions(world: &mut World) { &["_self", "rhs"], ) .register_documented( - "assert_receiver_is_total_eq", + "as_micros", | _self: Ref< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, >| { - let output: () = { + let output: u128 = { { - let output: () = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: u128 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_micros( &_self, ) .into(); @@ -194,15 +685,494 @@ pub(crate) fn register_duration_functions(world: &mut World) { }; output }, - "", + " Returns the total number of whole microseconds contained by this `Duration`.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::new(5, 730_023_852);\n assert_eq!(duration.as_micros(), 5_730_023);\n ```", + &["_self"], + ) + .register_documented( + "as_millis", + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: u128 = { + { + let output: u128 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_millis( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the total number of whole milliseconds contained by this `Duration`.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::new(5, 730_023_852);\n assert_eq!(duration.as_millis(), 5_730);\n ```", + &["_self"], + ) + .register_documented( + "as_nanos", + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: u128 = { + { + let output: u128 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_nanos( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the total number of nanoseconds contained by this `Duration`.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::new(5, 730_023_852);\n assert_eq!(duration.as_nanos(), 5_730_023_852);\n ```", + &["_self"], + ) + .register_documented( + "as_secs", + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: u64 = { + { + let output: u64 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_secs( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the number of _whole_ seconds contained by this `Duration`.\n The returned value does not include the fractional (nanosecond) part of the\n duration, which can be obtained using [`subsec_nanos`].\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::new(5, 730_023_852);\n assert_eq!(duration.as_secs(), 5);\n ```\n To determine the total number of seconds represented by the `Duration`\n including the fractional part, use [`as_secs_f64`] or [`as_secs_f32`]\n [`as_secs_f64`]: Duration::as_secs_f64\n [`as_secs_f32`]: Duration::as_secs_f32\n [`subsec_nanos`]: Duration::subsec_nanos", &["_self"], ) .register_documented( - "clone", + "as_secs_f32", + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: f32 = { + { + let output: f32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_secs_f32( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the number of seconds contained by this `Duration` as `f32`.\n The returned value includes the fractional (nanosecond) part of the duration.\n # Examples\n ```\n use std::time::Duration;\n let dur = Duration::new(2, 700_000_000);\n assert_eq!(dur.as_secs_f32(), 2.7);\n ```", + &["_self"], + ) + .register_documented( + "as_secs_f64", + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: f64 = { + { + let output: f64 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_secs_f64( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the number of seconds contained by this `Duration` as `f64`.\n The returned value includes the fractional (nanosecond) part of the duration.\n # Examples\n ```\n use std::time::Duration;\n let dur = Duration::new(2, 700_000_000);\n assert_eq!(dur.as_secs_f64(), 2.7);\n ```", + &["_self"], + ) + .register_documented( + "assert_receiver_is_total_eq", + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: () = { + { + let output: () = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "div", + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + rhs: u32| + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + u32, + >>::div(_self.into_inner(), rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "div_duration_f32", + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + rhs: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: f32 = { + { + let output: f32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::div_duration_f32( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Divides `Duration` by `Duration` and returns `f32`.\n # Examples\n ```\n use std::time::Duration;\n let dur1 = Duration::new(2, 700_000_000);\n let dur2 = Duration::new(5, 400_000_000);\n assert_eq!(dur1.div_duration_f32(dur2), 0.5);\n ```", + &["_self", "rhs"], + ) + .register_documented( + "div_duration_f64", + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + rhs: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: f64 = { + { + let output: f64 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::div_duration_f64( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Divides `Duration` by `Duration` and returns `f64`.\n # Examples\n ```\n use std::time::Duration;\n let dur1 = Duration::new(2, 700_000_000);\n let dur2 = Duration::new(5, 400_000_000);\n assert_eq!(dur1.div_duration_f64(dur2), 0.5);\n ```", + &["_self", "rhs"], + ) + .register_documented( + "div_f32", + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + rhs: f32| + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::div_f32( + _self.into_inner(), + rhs, + ) + .into(); + output + } + }; + output + }, + " Divides `Duration` by `f32`.\n # Panics\n This method will panic if result is negative, overflows `Duration` or not finite.\n # Examples\n ```\n use std::time::Duration;\n let dur = Duration::new(2, 700_000_000);\n // note that due to rounding errors result is slightly\n // different from 0.859_872_611\n assert_eq!(dur.div_f32(3.14), Duration::new(0, 859_872_580));\n assert_eq!(dur.div_f32(3.14e5), Duration::new(0, 8_599));\n ```", + &["_self", "rhs"], + ) + .register_documented( + "div_f64", + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + rhs: f64| + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::div_f64( + _self.into_inner(), + rhs, + ) + .into(); + output + } + }; + output + }, + " Divides `Duration` by `f64`.\n # Panics\n This method will panic if result is negative, overflows `Duration` or not finite.\n # Examples\n ```\n use std::time::Duration;\n let dur = Duration::new(2, 700_000_000);\n assert_eq!(dur.div_f64(3.14), Duration::new(0, 859_872_611));\n assert_eq!(dur.div_f64(3.14e5), Duration::new(0, 8_599));\n ```", + &["_self", "rhs"], + ) + .register_documented( + "eq", + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + other: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: bool = { + { + let output: bool = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "from_micros", + |micros: u64| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_micros( + micros, + ) + .into(); + output + } + }; + output + }, + " Creates a new `Duration` from the specified number of microseconds.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_micros(1_000_002);\n assert_eq!(1, duration.as_secs());\n assert_eq!(2_000, duration.subsec_nanos());\n ```", + &["micros"], + ) + .register_documented( + "from_millis", + |millis: u64| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_millis( + millis, + ) + .into(); + output + } + }; + output + }, + " Creates a new `Duration` from the specified number of milliseconds.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_millis(2_569);\n assert_eq!(2, duration.as_secs());\n assert_eq!(569_000_000, duration.subsec_nanos());\n ```", + &["millis"], + ) + .register_documented( + "from_nanos", + |nanos: u64| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_nanos( + nanos, + ) + .into(); + output + } + }; + output + }, + " Creates a new `Duration` from the specified number of nanoseconds.\n Note: Using this on the return value of `as_nanos()` might cause unexpected behavior:\n `as_nanos()` returns a u128, and can return values that do not fit in u64, e.g. 585 years.\n Instead, consider using the pattern `Duration::new(d.as_secs(), d.subsec_nanos())`\n if you cannot copy/clone the Duration directly.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_nanos(1_000_000_123);\n assert_eq!(1, duration.as_secs());\n assert_eq!(123, duration.subsec_nanos());\n ```", + &["nanos"], + ) + .register_documented( + "from_secs", + |secs: u64| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_secs( + secs, + ) + .into(); + output + } + }; + output + }, + " Creates a new `Duration` from the specified number of whole seconds.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_secs(5);\n assert_eq!(5, duration.as_secs());\n assert_eq!(0, duration.subsec_nanos());\n ```", + &["secs"], + ) + .register_documented( + "from_secs_f32", + |secs: f32| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_secs_f32( + secs, + ) + .into(); + output + } + }; + output + }, + " Creates a new `Duration` from the specified number of seconds represented\n as `f32`.\n # Panics\n This constructor will panic if `secs` is negative, overflows `Duration` or not finite.\n # Examples\n ```\n use std::time::Duration;\n let res = Duration::from_secs_f32(0.0);\n assert_eq!(res, Duration::new(0, 0));\n let res = Duration::from_secs_f32(1e-20);\n assert_eq!(res, Duration::new(0, 0));\n let res = Duration::from_secs_f32(4.2e-7);\n assert_eq!(res, Duration::new(0, 420));\n let res = Duration::from_secs_f32(2.7);\n assert_eq!(res, Duration::new(2, 700_000_048));\n let res = Duration::from_secs_f32(3e10);\n assert_eq!(res, Duration::new(30_000_001_024, 0));\n // subnormal float\n let res = Duration::from_secs_f32(f32::from_bits(1));\n assert_eq!(res, Duration::new(0, 0));\n // conversion uses rounding\n let res = Duration::from_secs_f32(0.999e-9);\n assert_eq!(res, Duration::new(0, 1));\n ```", + &["secs"], + ) + .register_documented( + "from_secs_f64", + |secs: f64| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_secs_f64( + secs, + ) + .into(); + output + } + }; + output + }, + " Creates a new `Duration` from the specified number of seconds represented\n as `f64`.\n # Panics\n This constructor will panic if `secs` is negative, overflows `Duration` or not finite.\n # Examples\n ```\n use std::time::Duration;\n let res = Duration::from_secs_f64(0.0);\n assert_eq!(res, Duration::new(0, 0));\n let res = Duration::from_secs_f64(1e-20);\n assert_eq!(res, Duration::new(0, 0));\n let res = Duration::from_secs_f64(4.2e-7);\n assert_eq!(res, Duration::new(0, 420));\n let res = Duration::from_secs_f64(2.7);\n assert_eq!(res, Duration::new(2, 700_000_000));\n let res = Duration::from_secs_f64(3e10);\n assert_eq!(res, Duration::new(30_000_000_000, 0));\n // subnormal float\n let res = Duration::from_secs_f64(f64::from_bits(1));\n assert_eq!(res, Duration::new(0, 0));\n // conversion uses rounding\n let res = Duration::from_secs_f64(0.999e-9);\n assert_eq!(res, Duration::new(0, 1));\n ```", + &["secs"], + ) + .register_documented( + "is_zero", + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: bool = { + { + let output: bool = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::is_zero( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns true if this `Duration` spans no time.\n # Examples\n ```\n use std::time::Duration;\n assert!(Duration::ZERO.is_zero());\n assert!(Duration::new(0, 0).is_zero());\n assert!(Duration::from_nanos(0).is_zero());\n assert!(Duration::from_secs(0).is_zero());\n assert!(!Duration::new(1, 1).is_zero());\n assert!(!Duration::from_nanos(1).is_zero());\n assert!(!Duration::from_secs(1).is_zero());\n ```", + &["_self"], + ) + .register_documented( + "mul", + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + rhs: u32| + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + u32, + >>::mul(_self.into_inner(), rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul_f32", | - _self: Ref< + _self: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| + >, + rhs: f32| { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, @@ -210,8 +1180,9 @@ pub(crate) fn register_duration_functions(world: &mut World) { { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( - &_self, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::mul_f32( + _self.into_inner(), + rhs, ) .into(); output @@ -219,16 +1190,16 @@ pub(crate) fn register_duration_functions(world: &mut World) { }; output }, - "", - &["_self"], + " Multiplies `Duration` by `f32`.\n # Panics\n This method will panic if result is negative, overflows `Duration` or not finite.\n # Examples\n ```\n use std::time::Duration;\n let dur = Duration::new(2, 700_000_000);\n assert_eq!(dur.mul_f32(3.14), Duration::new(8, 478_000_641));\n assert_eq!(dur.mul_f32(3.14e5), Duration::new(847_800, 0));\n ```", + &["_self", "rhs"], ) .register_documented( - "div", + "mul_f64", | _self: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, >, - rhs: u32| + rhs: f64| { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, @@ -236,53 +1207,60 @@ pub(crate) fn register_duration_functions(world: &mut World) { { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< - u32, - >>::div(_self.into_inner(), rhs) + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::mul_f64( + _self.into_inner(), + rhs, + ) .into(); output } }; output }, - "", + " Multiplies `Duration` by `f64`.\n # Panics\n This method will panic if result is negative, overflows `Duration` or not finite.\n # Examples\n ```\n use std::time::Duration;\n let dur = Duration::new(2, 700_000_000);\n assert_eq!(dur.mul_f64(3.14), Duration::new(8, 478_000_000));\n assert_eq!(dur.mul_f64(3.14e5), Duration::new(847_800, 0));\n ```", &["_self", "rhs"], ) .register_documented( - "eq", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - other: Ref< + "new", + |secs: u64, nanos: u32| { + let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: bool = { + > = { { - let output: bool = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >>::eq(&_self, &other) + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::new( + secs, + nanos, + ) .into(); output } }; output }, - "", - &["_self", "other"], + " Creates a new `Duration` from the specified number of whole seconds and\n additional nanoseconds.\n If the number of nanoseconds is greater than 1 billion (the number of\n nanoseconds in a second), then it will carry over into the seconds provided.\n # Panics\n This constructor will panic if the carry from the nanoseconds overflows\n the seconds counter.\n # Examples\n ```\n use std::time::Duration;\n let five_seconds = Duration::new(5, 0);\n ```", + &["secs", "nanos"], ) .register_documented( - "from_hours", - |hours: u64| { + "saturating_add", + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + rhs: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, > = { { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_hours( - hours, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::saturating_add( + _self.into_inner(), + rhs.into_inner(), ) .into(); output @@ -290,20 +1268,26 @@ pub(crate) fn register_duration_functions(world: &mut World) { }; output }, - " Creates a new `Duration` from the specified number of hours.\n # Panics\n Panics if the given number of hours overflows the `Duration` size.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_hours(6);\n assert_eq!(6 * 60 * 60, duration.as_secs());\n assert_eq!(0, duration.subsec_nanos());\n ```", - &["hours"], + " Saturating `Duration` addition. Computes `self + other`, returning [`Duration::MAX`]\n if overflow occurred.\n # Examples\n ```\n #![feature(duration_constants)]\n use std::time::Duration;\n assert_eq!(Duration::new(0, 0).saturating_add(Duration::new(0, 1)), Duration::new(0, 1));\n assert_eq!(Duration::new(1, 0).saturating_add(Duration::new(u64::MAX, 0)), Duration::MAX);\n ```", + &["_self", "rhs"], ) .register_documented( - "from_mins", - |mins: u64| { + "saturating_mul", + | + _self: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >, + rhs: u32| + { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, > = { { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_mins( - mins, + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::saturating_mul( + _self.into_inner(), + rhs, ) .into(); output @@ -311,16 +1295,18 @@ pub(crate) fn register_duration_functions(world: &mut World) { }; output }, - " Creates a new `Duration` from the specified number of minutes.\n # Panics\n Panics if the given number of minutes overflows the `Duration` size.\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_mins(10);\n assert_eq!(10 * 60, duration.as_secs());\n assert_eq!(0, duration.subsec_nanos());\n ```", - &["mins"], + " Saturating `Duration` multiplication. Computes `self * other`, returning\n [`Duration::MAX`] if overflow occurred.\n # Examples\n ```\n #![feature(duration_constants)]\n use std::time::Duration;\n assert_eq!(Duration::new(0, 500_000_001).saturating_mul(2), Duration::new(1, 2));\n assert_eq!(Duration::new(u64::MAX - 1, 0).saturating_mul(2), Duration::MAX);\n ```", + &["_self", "rhs"], ) .register_documented( - "mul", + "saturating_sub", | _self: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, >, - rhs: u32| + rhs: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, @@ -328,16 +1314,17 @@ pub(crate) fn register_duration_functions(world: &mut World) { { let output: Val< ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< - u32, - >>::mul(_self.into_inner(), rhs) + > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::saturating_sub( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output } }; output }, - "", + " Saturating `Duration` subtraction. Computes `self - other`, returning [`Duration::ZERO`]\n if the result would be negative or if overflow occurred.\n # Examples\n ```\n use std::time::Duration;\n assert_eq!(Duration::new(0, 1).saturating_sub(Duration::new(0, 0)), Duration::new(0, 1));\n assert_eq!(Duration::new(0, 0).saturating_sub(Duration::new(0, 1)), Duration::ZERO);\n ```", &["_self", "rhs"], ) .register_documented( @@ -367,6 +1354,69 @@ pub(crate) fn register_duration_functions(world: &mut World) { }, "", &["_self", "rhs"], + ) + .register_documented( + "subsec_micros", + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: u32 = { + { + let output: u32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::subsec_micros( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the fractional part of this `Duration`, in whole microseconds.\n This method does **not** return the length of the duration when\n represented by microseconds. The returned number always represents a\n fractional portion of a second (i.e., it is less than one million).\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_micros(1_234_567);\n assert_eq!(duration.as_secs(), 1);\n assert_eq!(duration.subsec_micros(), 234_567);\n ```", + &["_self"], + ) + .register_documented( + "subsec_millis", + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: u32 = { + { + let output: u32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::subsec_millis( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the fractional part of this `Duration`, in whole milliseconds.\n This method does **not** return the length of the duration when\n represented by milliseconds. The returned number always represents a\n fractional portion of a second (i.e., it is less than one thousand).\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_millis(5_432);\n assert_eq!(duration.as_secs(), 5);\n assert_eq!(duration.subsec_millis(), 432);\n ```", + &["_self"], + ) + .register_documented( + "subsec_nanos", + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + >| + { + let output: u32 = { + { + let output: u32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::subsec_nanos( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the fractional part of this `Duration`, in nanoseconds.\n This method does **not** return the length of the duration when\n represented by nanoseconds. The returned number always represents a\n fractional portion of a second (i.e., it is less than one billion).\n # Examples\n ```\n use std::time::Duration;\n let duration = Duration::from_millis(5_010);\n assert_eq!(duration.as_secs(), 5);\n assert_eq!(duration.subsec_nanos(), 10_000_000);\n ```", + &["_self"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -436,6 +1486,46 @@ pub(crate) fn register_instant_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "duration_since", + |_self: Ref<::std::time::Instant>, earlier: Val<::std::time::Instant>| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::std::time::Instant::duration_since( + &_self, + earlier.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the amount of time elapsed from another instant to this one,\n or zero duration if that instant is later than this one.\n # Panics\n Previous Rust versions panicked when `earlier` was later than `self`. Currently this\n method saturates. Future versions may reintroduce the panic in some circumstances.\n See [Monotonicity].\n [Monotonicity]: Instant#monotonicity\n # Examples\n ```no_run\n use std::time::{Duration, Instant};\n use std::thread::sleep;\n let now = Instant::now();\n sleep(Duration::new(1, 0));\n let new_now = Instant::now();\n println!(\"{:?}\", new_now.duration_since(now));\n println!(\"{:?}\", now.duration_since(new_now)); // 0ns\n ```", + &["_self", "earlier"], + ) + .register_documented( + "elapsed", + |_self: Ref<::std::time::Instant>| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::std::time::Instant::elapsed(&_self).into(); + output + } + }; + output + }, + " Returns the amount of time elapsed since this instant.\n # Panics\n Previous Rust versions panicked when the current time was earlier than self. Currently this\n method returns a Duration of zero in that case. Future versions may reintroduce the panic.\n See [Monotonicity].\n [Monotonicity]: Instant#monotonicity\n # Examples\n ```no_run\n use std::thread::sleep;\n use std::time::{Duration, Instant};\n let instant = Instant::now();\n let three_secs = Duration::from_secs(3);\n sleep(three_secs);\n assert!(instant.elapsed() >= three_secs);\n ```", + &["_self"], + ) .register_documented( "eq", |_self: Ref<::std::time::Instant>, other: Ref<::std::time::Instant>| { @@ -453,6 +1543,43 @@ pub(crate) fn register_instant_functions(world: &mut World) { "", &["_self", "other"], ) + .register_documented( + "now", + || { + let output: Val<::std::time::Instant> = { + { + let output: Val<::std::time::Instant> = ::std::time::Instant::now() + .into(); + output + } + }; + output + }, + " Returns an instant corresponding to \"now\".\n # Examples\n ```\n use std::time::Instant;\n let now = Instant::now();\n ```", + &[], + ) + .register_documented( + "saturating_duration_since", + |_self: Ref<::std::time::Instant>, earlier: Val<::std::time::Instant>| { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = { + { + let output: Val< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + > = ::std::time::Instant::saturating_duration_since( + &_self, + earlier.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the amount of time elapsed from another instant to this one,\n or zero duration if that instant is later than this one.\n # Examples\n ```no_run\n use std::time::{Duration, Instant};\n use std::thread::sleep;\n let now = Instant::now();\n sleep(Duration::new(1, 0));\n let new_now = Instant::now();\n println!(\"{:?}\", new_now.saturating_duration_since(now));\n println!(\"{:?}\", now.saturating_duration_since(new_now)); // 0ns\n ```", + &["_self", "earlier"], + ) .register_documented( "sub", | @@ -3611,6 +4738,92 @@ pub(crate) fn register_socket_addr_functions(world: &mut World) { }, "", &["_self", "other"], + ) + .register_documented( + "is_ipv4", + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, + >| + { + let output: bool = { + { + let output: bool = ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr::is_ipv4( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns [`true`] if the [IP address] in this `SocketAddr` is an\n [`IPv4` address], and [`false`] otherwise.\n [IP address]: IpAddr\n [`IPv4` address]: IpAddr::V4\n # Examples\n ```\n use std::net::{IpAddr, Ipv4Addr, SocketAddr};\n let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);\n assert_eq!(socket.is_ipv4(), true);\n assert_eq!(socket.is_ipv6(), false);\n ```", + &["_self"], + ) + .register_documented( + "is_ipv6", + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, + >| + { + let output: bool = { + { + let output: bool = ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr::is_ipv6( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns [`true`] if the [IP address] in this `SocketAddr` is an\n [`IPv6` address], and [`false`] otherwise.\n [IP address]: IpAddr\n [`IPv6` address]: IpAddr::V6\n # Examples\n ```\n use std::net::{IpAddr, Ipv6Addr, SocketAddr};\n let socket = SocketAddr::new(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 65535, 0, 1)), 8080);\n assert_eq!(socket.is_ipv4(), false);\n assert_eq!(socket.is_ipv6(), true);\n ```", + &["_self"], + ) + .register_documented( + "port", + | + _self: Ref< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, + >| + { + let output: u16 = { + { + let output: u16 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr::port( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the port number associated with this socket address.\n # Examples\n ```\n use std::net::{IpAddr, Ipv4Addr, SocketAddr};\n let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);\n assert_eq!(socket.port(), 8080);\n ```", + &["_self"], + ) + .register_documented( + "set_port", + | + mut _self: Mut< + ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, + >, + new_port: u16| + { + let output: () = { + { + let output: () = ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr::set_port( + &mut _self, + new_port, + ) + .into(); + output + } + }; + output + }, + " Changes the port number associated with this socket address.\n # Examples\n ```\n use std::net::{IpAddr, Ipv4Addr, SocketAddr};\n let mut socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);\n socket.set_port(1025);\n assert_eq!(socket.port(), 1025);\n ```", + &["_self", "new_port"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); diff --git a/crates/bindings/bevy_render_bms_bindings/Cargo.toml b/crates/bindings/bevy_render_bms_bindings/Cargo.toml index e3cd268e5d..2f5dcf3226 100644 --- a/crates/bindings/bevy_render_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_render_bms_bindings/Cargo.toml @@ -22,43 +22,43 @@ bevy_render = { version = "0.17.2", features = ["multi_threaded", "webgl"], defa async-channel = { version = "^2.3.0", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} bevy_diagnostic = { version = "^0.17.2", features = ["std", "sysinfo", "sysinfo_plugin"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} bevy_encase_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} bevy_render_macros = { version = "^0.17.2", features = [], default-features = true} bevy_shader = { version = "^0.17.2", features = [], default-features = true} -bevy_tasks = { version = "^0.17.2", features = ["multi_threaded", "futures-lite", "async_executor"], default-features = true} +bevy_tasks = { version = "^0.17.2", features = ["multi_threaded", "async_executor", "futures-lite"], default-features = true} bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["std", "bevy_reflect", "bevy_image", "bevy_asset", "custom_cursor"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} bitflags = { version = "^2", features = [], default-features = true} diff --git a/crates/bindings/bevy_scene_bms_bindings/Cargo.toml b/crates/bindings/bevy_scene_bms_bindings/Cargo.toml index 5c45136b29..16d3bd9906 100644 --- a/crates/bindings/bevy_scene_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_scene_bms_bindings/Cargo.toml @@ -20,7 +20,7 @@ bevy_mod_scripting_derive = { workspace = true } bevy_scene = { version = "0.17.2", features = ["serialize"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} @@ -28,15 +28,15 @@ bevy_camera = { version = "^0.17.2", features = [], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["serialize", "std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["serialize", "std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace"], default-features = true} bevy_platform = { version = "^0.17.2", features = ["serialize", "alloc", "std"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} serde = { version = "^1.0", features = [], default-features = true} diff --git a/crates/bindings/bevy_sprite_bms_bindings/Cargo.toml b/crates/bindings/bevy_sprite_bms_bindings/Cargo.toml index 99bf6254c9..6603309374 100644 --- a/crates/bindings/bevy_sprite_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_sprite_bms_bindings/Cargo.toml @@ -20,33 +20,33 @@ bevy_mod_scripting_derive = { workspace = true } bevy_sprite = { version = "0.17.2", features = ["bevy_picking", "bevy_window", "bevy_sprite_picking_backend", "bevy_text"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} bevy_picking = { version = "^0.17.2", features = ["bevy_mesh_picking_backend"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} bevy_text = { version = "^0.17.2", features = ["default_font"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["std", "bevy_reflect", "bevy_image", "bevy_asset", "custom_cursor"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} radsort = { version = "^0.1", features = [], default-features = true} diff --git a/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml b/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml index ad427cc594..c8f098bf41 100644 --- a/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml @@ -20,27 +20,27 @@ bevy_mod_scripting_derive = { workspace = true } bevy_sprite_render = { version = "0.17.2", features = ["bevy_text", "webgl"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} @@ -50,9 +50,9 @@ bevy_sprite = { version = "^0.17.2", features = ["bevy_text", "bevy_picking", "b bevy_text = { version = "^0.17.2", features = ["default_font"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_text_bms_bindings/Cargo.toml b/crates/bindings/bevy_text_bms_bindings/Cargo.toml index 2757a37ab5..5f2b1ef284 100644 --- a/crates/bindings/bevy_text_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_text_bms_bindings/Cargo.toml @@ -20,25 +20,25 @@ bevy_mod_scripting_derive = { workspace = true } bevy_text = { version = "0.17.2", features = ["default_font"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} -bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} bevy_log = { version = "^0.17.2", features = [], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} cosmic-text = { version = "^0.14", features = [], default-features = true} diff --git a/crates/bindings/bevy_time_bms_bindings/Cargo.toml b/crates/bindings/bevy_time_bms_bindings/Cargo.toml index e0c30b60a7..c5c2c83399 100644 --- a/crates/bindings/bevy_time_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_time_bms_bindings/Cargo.toml @@ -20,12 +20,12 @@ bevy_mod_scripting_derive = { workspace = true } bevy_time = { version = "0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "reflect_auto_register", "error_panic_hook"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "multi_threaded", "reflect_auto_register", "backtrace", "serialize"], default-features = true} bevy_platform = { version = "^0.17.2", features = ["std", "alloc", "serialize"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} diff --git a/crates/bindings/bevy_transform_bms_bindings/Cargo.toml b/crates/bindings/bevy_transform_bms_bindings/Cargo.toml index b51ad8f480..1dea392fa8 100644 --- a/crates/bindings/bevy_transform_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_transform_bms_bindings/Cargo.toml @@ -17,16 +17,16 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_transform = { version = "0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} +bevy_transform = { version = "0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "reflect_auto_register", "error_panic_hook"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "multi_threaded", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "rand", "curve", "alloc"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "alloc", "rand", "curve"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} bevy_tasks = { version = "^0.17.2", features = ["async_executor", "futures-lite", "multi_threaded"], default-features = true} diff --git a/crates/bindings/bevy_ui_bms_bindings/Cargo.toml b/crates/bindings/bevy_ui_bms_bindings/Cargo.toml index 0fb5c12643..6d45864df4 100644 --- a/crates/bindings/bevy_ui_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_ui_bms_bindings/Cargo.toml @@ -24,37 +24,37 @@ accesskit = { version = "^0.21", features = [], default-features = true} bevy_a11y = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} bevy_input = { version = "^0.17.2", features = ["std", "bevy_reflect", "smol_str"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} bevy_picking = { version = "^0.17.2", features = ["bevy_mesh_picking_backend"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} bevy_sprite = { version = "^0.17.2", features = ["bevy_picking", "bevy_window", "bevy_sprite_picking_backend", "bevy_text"], default-features = true} bevy_text = { version = "^0.17.2", features = ["default_font"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["std", "bevy_reflect", "bevy_image", "bevy_asset", "custom_cursor"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} taffy = { version = "^0.7", features = [], default-features = true} diff --git a/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml b/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml index d29b7cce84..7adb245adf 100644 --- a/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml @@ -20,27 +20,27 @@ bevy_mod_scripting_derive = { workspace = true } bevy_ui_render = { version = "0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "alloc", "wgpu-types"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "backtrace", "multi_threaded", "reflect_auto_register", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "alloc", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} @@ -52,11 +52,11 @@ bevy_sprite_render = { version = "^0.17.2", features = ["bevy_text", "webgl"], d bevy_text = { version = "^0.17.2", features = ["default_font"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "bevy_reflect", "async_executor", "alloc", "bevy_log"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} bevy_ui = { version = "^0.17.2", features = ["bevy_picking", "bevy_ui_picking_backend"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} bytemuck = { version = "^1.5", features = [], default-features = true} From 357c2feaac80f689db174686c4302be65006672a Mon Sep 17 00:00:00 2001 From: makspll Date: Mon, 10 Nov 2025 21:28:59 +0000 Subject: [PATCH 11/22] fix all errors, bump bevy console, improve some path crawling stuff --- Cargo.toml | 2 +- codegen/src/import_path.rs | 129 +- codegen/src/passes/find_reflect_types.rs | 8 + codegen/src/passes/mod.rs | 2 +- codegen/templates/footer.tera | 12 +- .../bevy_animation_bms_bindings/Cargo.toml | 2 +- .../bevy_asset_bms_bindings/src/lib.rs | 30 - .../bevy_camera_bms_bindings/Cargo.toml | 2 +- .../bevy_camera_bms_bindings/src/lib.rs | 306 +- .../Cargo.toml | 2 +- .../bevy_gizmos_bms_bindings/Cargo.toml | 2 +- .../bevy_image_bms_bindings/Cargo.toml | 2 +- .../bevy_image_bms_bindings/src/lib.rs | 69 - .../bevy_input_bms_bindings/src/lib.rs | 51 - .../bevy_light_bms_bindings/Cargo.toml | 2 +- .../bevy_math_bms_bindings/src/lib.rs | 4585 +++++------------ .../bevy_mesh_bms_bindings/src/lib.rs | 241 - .../bindings/bevy_pbr_bms_bindings/Cargo.toml | 2 +- .../bevy_post_process_bms_bindings/Cargo.toml | 2 +- .../bevy_reflect_bms_bindings/Cargo.toml | 2 +- .../bevy_reflect_bms_bindings/src/lib.rs | 3118 +++++------ .../bevy_render_bms_bindings/Cargo.toml | 2 +- .../bevy_render_bms_bindings/src/lib.rs | 21 - .../bevy_scene_bms_bindings/Cargo.toml | 2 +- .../bevy_sprite_bms_bindings/src/lib.rs | 32 - .../Cargo.toml | 2 +- .../src/lib.rs | 19 - .../bevy_text_bms_bindings/Cargo.toml | 2 +- .../bevy_time_bms_bindings/src/lib.rs | 149 - .../bevy_transform_bms_bindings/src/lib.rs | 509 -- .../bindings/bevy_ui_bms_bindings/Cargo.toml | 2 +- .../bindings/bevy_ui_bms_bindings/src/lib.rs | 711 +-- .../bevy_ui_render_bms_bindings/Cargo.toml | 2 +- .../bevy_mod_scripting_lua/src/lib.rs | 6 +- .../src/lib.rs | 10 +- .../src/parse.rs | 6 +- .../src/scenario.rs | 56 +- .../src/test_functions.rs | 2 +- .../test_utils/src/test_plugin.rs | 8 +- examples/game_of_life.rs | 15 +- examples/run_script.rs | 4 +- 41 files changed, 2813 insertions(+), 7318 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 2bb9d9762e..3b771bc3de 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -232,7 +232,7 @@ pretty_assertions = { version = "1.4", default-features = false, features = [ manifest-dir-macros = { version = "0.1.18", default-features = false } assert_cmd = { version = "2.1", default-features = false } tokio = { version = "1", default-features = false } -bevy_console = { version = "0.14", default-features = false } +bevy_console = { version = "0.16", default-features = false } tracing-tracy = { version = "0.11", default-features = false } libtest-mimic = { version = "0.8", default-features = false } criterion = { version = "0.5", default-features = false } diff --git a/codegen/src/import_path.rs b/codegen/src/import_path.rs index fc1b8d40b2..a4e05b23c5 100644 --- a/codegen/src/import_path.rs +++ b/codegen/src/import_path.rs @@ -12,14 +12,17 @@ pub(crate) enum ImportPathElement { Rename(DefId, String), /// direct import of the def id by name Item(DefId), + /// A crate root + Crate(CrateNum), } impl ImportPathElement { - pub fn def_id(&self) -> DefId { - match self { + pub fn def_id(&self) -> Option { + Some(match self { Self::Rename(did, _) => *did, Self::Item(did) => *did, - } + _ => return None, + }) } } @@ -28,6 +31,7 @@ impl std::fmt::Debug for ImportPathElement { match self { ImportPathElement::Rename(did, name) => write!(f, "{did:?} as {name}"), ImportPathElement::Item(did) => write!(f, "{did:?}"), + ImportPathElement::Crate(crate_num) => write!(f, "{crate_num:?}"), } } } @@ -58,17 +62,15 @@ impl<'tcx> ImportPathFinder<'tcx> { } pub(crate) fn crawl_crate(&mut self, crate_num: CrateNum) { - self.crawl_module(crate_num.as_def_id(), &[]) + self.crawl_module( + crate_num.as_def_id(), + &[ImportPathElement::Crate(crate_num)], + ) } fn crawl_module(&mut self, did: DefId, frontier: &[ImportPathElement]) { trace!("Crawling module {did:?}"); - // Push current module onto the path frontier - let mut new_frontier = frontier.to_vec(); - new_frontier.push(ImportPathElement::Item(did)); - let new_frontier = &new_frontier; - // Get children of the module let children = if did.is_local() { self.tcx.module_children_local(did.expect_local()) @@ -77,58 +79,87 @@ impl<'tcx> ImportPathFinder<'tcx> { }; for child in children { - let rename = child.ident.to_string(); + // Skip if the child has no DefId + let did = match child.res.opt_def_id() { + Some(did) => did, + None => { + trace!("Skipping child without did {:?}", child.ident); + continue; + } + }; // Skip private items if we don't include them if !self.include_private_paths && !child.vis.is_public() { - trace!("Skipping private child {rename:?}"); + trace!("Skipping private child {:?}", child.ident); continue; } - // Skip if the child has no DefId - let did = match child.res.opt_def_id() { - Some(did) => did, - None => continue, - }; + // skip non local items, i.e. don't go crawling serde + if !did.is_local() { + trace!("Skipping non-local child {:?}", child.ident); + continue; + } - trace!( - "Crawling item: '{:?}', of kind: '{:?}'", - did, - self.tcx.def_kind(did) - ); - - match self.tcx.def_kind(did) { - DefKind::Mod => { - // Only recurse if this DefId is not already in the current path - if new_frontier.iter().any(|el| el.def_id() == did) { - trace!("Cycle detected for {did:?}, skipping recursion"); - continue; - } - self.crawl_module(did, new_frontier) - } + let rename = (child.ident != self.tcx.item_ident(did)).then_some(child.ident.as_str()); - DefKind::Struct | DefKind::Union | DefKind::Enum | DefKind::Trait => { - // Save the rename and the DefId - let mut path_for_item = new_frontier.clone(); - path_for_item.push(ImportPathElement::Rename(did, rename)); + self.crawl_item(did, frontier, rename); + } + } - trace!("Saving import path for {did:?}: {path_for_item:?}"); - self.cache.entry(did).or_default().push(path_for_item); + fn crawl_item(&mut self, did: DefId, frontier: &[ImportPathElement], rename: Option<&str>) { + trace!( + "Crawling item: '{:?}', of kind: '{:?}'", + did, + self.tcx.def_kind(did) + ); + + match self.tcx.def_kind(did) { + DefKind::Mod => { + // Only recurse if this DefId is not already in the current path + if frontier + .iter() + .any(|el| el.def_id().is_some_and(|id| id == did)) + { + trace!("Cycle detected for {did:?}, skipping recursion"); + return; } + let mut new_frontier = frontier.to_vec(); + new_frontier.push( + rename + .map(|rename| ImportPathElement::Rename(did, rename.to_string())) + .unwrap_or(ImportPathElement::Item(did)), + ); + + self.crawl_module(did, &new_frontier) + } - _ => continue, + DefKind::Struct | DefKind::Union | DefKind::Enum | DefKind::Trait => { + // Save the rename and the DefId + let mut path_for_item = frontier.to_vec(); + + path_for_item.push(ImportPathElement::Item(did)); + + trace!("Saving import path for {did:?}: {path_for_item:?}"); + self.cache.entry(did).or_default().push(path_for_item); } + + _ => (), } } + /// Like find_import_paths but won't always return at least one path + pub(crate) fn find_import_paths_no_fallback(&self, def_id: DefId) -> Option> { + self.cache.get(&def_id).map(|v| { + v.iter() + .map(|elems| self.import_path_to_def_string(elems)) + .collect() + }) + } + + /// Finds the import path for the item if there is one given the current settings + /// or returns a fallback value based on the defID which might not be accurate pub(crate) fn find_import_paths(&self, def_id: DefId) -> Vec { - self.cache - .get(&def_id) - .map(|v| { - v.iter() - .map(|elems| self.import_path_to_def_string(elems)) - .collect() - }) + self.find_import_paths_no_fallback(def_id) .unwrap_or_else(|| { let path = self.tcx.def_path_str(def_id); if let Some(p) = &self.import_path_processor { @@ -145,6 +176,14 @@ impl<'tcx> ImportPathFinder<'tcx> { .map(|elem| match elem { ImportPathElement::Rename(_, name) => name.to_owned(), ImportPathElement::Item(did) => self.tcx.item_name(*did).to_ident_string(), + ImportPathElement::Crate(crate_num) => { + self.tcx.crate_name(*crate_num).to_ident_string() + } + }) + .inspect(|e| { + if e.is_empty() { + panic!("empty path elem: {e}") + } }) .collect::>() .join("::"); diff --git a/codegen/src/passes/find_reflect_types.rs b/codegen/src/passes/find_reflect_types.rs index 74a55642bd..8355dea34b 100644 --- a/codegen/src/passes/find_reflect_types.rs +++ b/codegen/src/passes/find_reflect_types.rs @@ -53,6 +53,14 @@ pub(crate) fn find_reflect_types(ctxt: &mut BevyCtxt<'_>, args: &Args) -> bool { })) .then(|| self_ty.def().unwrap()) }) + .filter(|t| { + if ctxt.path_finder.find_import_paths_no_fallback(*t).is_none() { + debug!("Skipping type: {t:?}, as it has no public path available"); + false + } else { + true + } + }) .inspect(|impl_| debug!("On type: {:?}", tcx.item_name(*impl_))) .map(|did| (did, ReflectType::default())); diff --git a/codegen/src/passes/mod.rs b/codegen/src/passes/mod.rs index 43dc5738a7..24549f80d7 100644 --- a/codegen/src/passes/mod.rs +++ b/codegen/src/passes/mod.rs @@ -66,11 +66,11 @@ pub(crate) const CRAWL_PATHS: Pass = Pass { pub(crate) const ALL_PASSES: [Pass; 8] = [ CACHE_TRAITS, + CRAWL_PATHS, // paths needed in the reflect type finder step FIND_REFLECT_TYPES, FIND_TRAIT_IMPLS, // we have to do this before meta as we still filter some things here WRITE_META, // the earlier this happens the better, as other crates will depend on our meta files but not the rest of the passes! FIND_METHODS_AND_FIELDS, - CRAWL_PATHS, POPULATE_TEMPLATE_DATA, CODEGEN, ]; diff --git a/codegen/templates/footer.tera b/codegen/templates/footer.tera index c6c068767d..7992020867 100644 --- a/codegen/templates/footer.tera +++ b/codegen/templates/footer.tera @@ -8,6 +8,7 @@ pub struct {{ "ScriptingPlugin" | prefix_cratename | convert_case(case="upper_camel")}}; {% for item in items %} +// {{ item.import_path }} #[script_bindings( remote, name = "{{ item.ident | convert_case(case="snake") }}_functions", @@ -36,12 +37,13 @@ impl {{item.import_path}} { ( {%- for arg in function.args -%} {%- if arg.proxy_ty is matching("Ref.*")-%} - &{% endif -%} - {%- if arg.proxy_ty is matching ("Mut.*")-%} - &mut {% endif -%} + & {{ arg.ident | to_arg_pattern() -}} + {%- elif arg.proxy_ty is matching ("Mut.*")-%} + &mut {{ arg.ident | to_arg_pattern() -}} + {%- elif arg.proxy_ty is matching("Val.*")-%} + {{- arg.ident | to_arg_pattern() -}}.into_inner() + {%- else -%} {{- arg.ident | to_arg_pattern() -}} - {%- if arg.proxy_ty is matching("Val.*")-%} - .into_inner() {%- endif -%}, {%- endfor -%} ).into(); diff --git a/crates/bindings/bevy_animation_bms_bindings/Cargo.toml b/crates/bindings/bevy_animation_bms_bindings/Cargo.toml index 963f919372..0ed8acccf8 100644 --- a/crates/bindings/bevy_animation_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_animation_bms_bindings/Cargo.toml @@ -42,7 +42,7 @@ bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-f bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} blake3 = { version = "^1.0", features = [], default-features = true} diff --git a/crates/bindings/bevy_asset_bms_bindings/src/lib.rs b/crates/bindings/bevy_asset_bms_bindings/src/lib.rs index a99e6d8e20..bb5bb0887c 100644 --- a/crates/bindings/bevy_asset_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_asset_bms_bindings/src/lib.rs @@ -67,21 +67,6 @@ pub(crate) fn register_untyped_handle_functions(world: &mut World) { }, " Returns the [`UntypedAssetId`] for the referenced asset.", &["_self"], - ) - .register_documented( - "type_id", - |_self: Ref<::bevy_asset::prelude::UntypedHandle>| { - let output: Val<::core::any::TypeId> = { - { - let output: Val<::core::any::TypeId> = - ::bevy_asset::prelude::UntypedHandle::type_id(&_self).into(); - output - } - }; - output - }, - " Returns the [`TypeId`] of the referenced [`Asset`].", - &["_self"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -127,21 +112,6 @@ pub(crate) fn register_untyped_asset_id_functions(world: &mut World) { }, "", &["_self", "other"], - ) - .register_documented( - "type_id", - |_self: Ref<::bevy_asset::UntypedAssetId>| { - let output: Val<::core::any::TypeId> = { - { - let output: Val<::core::any::TypeId> = - ::bevy_asset::UntypedAssetId::type_id(&_self).into(); - output - } - }; - output - }, - " Returns the stored [`TypeId`] of the referenced [`Asset`].", - &["_self"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); diff --git a/crates/bindings/bevy_camera_bms_bindings/Cargo.toml b/crates/bindings/bevy_camera_bms_bindings/Cargo.toml index c631798d71..02a6a2dbe6 100644 --- a/crates/bindings/bevy_camera_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_camera_bms_bindings/Cargo.toml @@ -40,7 +40,7 @@ bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "a bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} diff --git a/crates/bindings/bevy_camera_bms_bindings/src/lib.rs b/crates/bindings/bevy_camera_bms_bindings/src/lib.rs index d8b01861c7..6b441af726 100644 --- a/crates/bindings/bevy_camera_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_camera_bms_bindings/src/lib.rs @@ -346,23 +346,6 @@ pub(crate) fn register_camera_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_camera::prelude::Camera, >::new(world) - .register_documented( - "clip_from_view", - |_self: Ref<::bevy_camera::prelude::Camera>| { - let output: Val<::bevy_math::Mat4> = { - { - let output: Val<::bevy_math::Mat4> = ::bevy_camera::prelude::Camera::clip_from_view( - &_self, - ) - .into(); - output - } - }; - output - }, - " The projection matrix computed using this camera's [`Projection`](super::projection::Projection).", - &["_self"], - ) .register_documented( "clone", |_self: Ref<::bevy_camera::prelude::Camera>| { @@ -671,115 +654,22 @@ pub(crate) fn register_frustum_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_camera::primitives::Frustum, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_camera::primitives::Frustum>| { - let output: Val<::bevy_camera::primitives::Frustum> = { - { - let output: Val<::bevy_camera::primitives::Frustum> = <::bevy_camera::primitives::Frustum as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "contains_aabb", - | - _self: Ref<::bevy_camera::primitives::Frustum>, - aabb: Ref<::bevy_camera::primitives::Aabb>, - world_from_local: Ref<::bevy_math::Affine3A>| - { - let output: bool = { - { - let output: bool = ::bevy_camera::primitives::Frustum::contains_aabb( - &_self, - &aabb, - &world_from_local, - ) - .into(); - output - } - }; - output - }, - " Check if the frustum contains the Axis-Aligned Bounding Box (AABB).\n Referenced from: [Frustum Culling](https://learnopengl.com/Guest-Articles/2021/Scene/Frustum-Culling)", - &["_self", "aabb", "world_from_local"], - ) - .register_documented( - "from_clip_from_world", - |clip_from_world: Ref<::bevy_math::Mat4>| { - let output: Val<::bevy_camera::primitives::Frustum> = { - { - let output: Val<::bevy_camera::primitives::Frustum> = ::bevy_camera::primitives::Frustum::from_clip_from_world( - &clip_from_world, - ) - .into(); - output - } - }; - output - }, - " Returns a frustum derived from `clip_from_world`.", - &["clip_from_world"], - ) - .register_documented( - "from_clip_from_world_custom_far", - | - clip_from_world: Ref<::bevy_math::Mat4>, - view_translation: Ref<::bevy_math::Vec3>, - view_backward: Ref<::bevy_math::Vec3>, - far: f32| - { - let output: Val<::bevy_camera::primitives::Frustum> = { - { - let output: Val<::bevy_camera::primitives::Frustum> = ::bevy_camera::primitives::Frustum::from_clip_from_world_custom_far( - &clip_from_world, - &view_translation, - &view_backward, - far, - ) - .into(); - output - } - }; - output - }, - " Returns a frustum derived from `clip_from_world`,\n but with a custom far plane.", - &["clip_from_world", "view_translation", "view_backward", "far"], - ) - .register_documented( - "intersects_obb", - | - _self: Ref<::bevy_camera::primitives::Frustum>, - aabb: Ref<::bevy_camera::primitives::Aabb>, - world_from_local: Ref<::bevy_math::Affine3A>, - intersect_near: bool, - intersect_far: bool| - { - let output: bool = { - { - let output: bool = ::bevy_camera::primitives::Frustum::intersects_obb( - &_self, - &aabb, - &world_from_local, - intersect_near, - intersect_far, - ) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::primitives::Frustum>| { + let output: Val<::bevy_camera::primitives::Frustum> = { + { + let output: Val<::bevy_camera::primitives::Frustum> = + <::bevy_camera::primitives::Frustum as ::std::clone::Clone>::clone(&_self) .into(); - output - } - }; - output - }, - " Checks if an Oriented Bounding Box (obb) intersects the frustum.", - &["_self", "aabb", "world_from_local", "intersect_near", "intersect_far"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -792,25 +682,6 @@ pub(crate) fn register_visible_entities_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_camera::visibility::VisibleEntities, >::new(world) - .register_documented( - "clear", - |mut _self: Mut<::bevy_camera::visibility::VisibleEntities>, - type_id: Val<::std::any::TypeId>| { - let output: () = { - { - let output: () = ::bevy_camera::visibility::VisibleEntities::clear( - &mut _self, - type_id.into_inner(), - ) - .into(); - output - } - }; - output - }, - "", - &["_self", "type_id"], - ) .register_documented( "clear_all", |mut _self: Mut<::bevy_camera::visibility::VisibleEntities>| { @@ -843,65 +714,6 @@ pub(crate) fn register_visible_entities_functions(world: &mut World) { }, "", &["_self"], - ) - .register_documented( - "is_empty", - |_self: Ref<::bevy_camera::visibility::VisibleEntities>, - type_id: Val<::std::any::TypeId>| { - let output: bool = { - { - let output: bool = ::bevy_camera::visibility::VisibleEntities::is_empty( - &_self, - type_id.into_inner(), - ) - .into(); - output - } - }; - output - }, - "", - &["_self", "type_id"], - ) - .register_documented( - "len", - |_self: Ref<::bevy_camera::visibility::VisibleEntities>, - type_id: Val<::std::any::TypeId>| { - let output: usize = { - { - let output: usize = ::bevy_camera::visibility::VisibleEntities::len( - &_self, - type_id.into_inner(), - ) - .into(); - output - } - }; - output - }, - "", - &["_self", "type_id"], - ) - .register_documented( - "push", - |mut _self: Mut<::bevy_camera::visibility::VisibleEntities>, - entity: Val<::bevy_ecs::entity::Entity>, - type_id: Val<::std::any::TypeId>| { - let output: () = { - { - let output: () = ::bevy_camera::visibility::VisibleEntities::push( - &mut _self, - entity.into_inner(), - type_id.into_inner(), - ) - .into(); - output - } - }; - output - }, - "", - &["_self", "entity", "type_id"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -915,24 +727,6 @@ pub(crate) fn register_viewport_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_camera::Viewport, >::new(world) - .register_documented( - "clamp_to_size", - |mut _self: Mut<::bevy_camera::Viewport>, size: Val<::bevy_math::UVec2>| { - let output: () = { - { - let output: () = ::bevy_camera::Viewport::clamp_to_size( - &mut _self, - size.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Cut the viewport rectangle so that it lies inside a rectangle of the\n given size.\n If either of the viewport's position coordinates lies outside the given\n dimensions, it will be moved just inside first. If either of the given\n dimensions is zero, the position and size of the viewport rectangle will\n both be set to zero in that dimension.", - &["_self", "size"], - ) .register_documented( "clone", |_self: Ref<::bevy_camera::Viewport>| { @@ -1459,76 +1253,6 @@ pub(crate) fn register_aabb_functions(world: &mut World) { }, "", &["_self", "other"], - ) - .register_documented( - "from_min_max", - |minimum: Val<::bevy_math::Vec3>, maximum: Val<::bevy_math::Vec3>| { - let output: Val<::bevy_camera::primitives::Aabb> = { - { - let output: Val<::bevy_camera::primitives::Aabb> = - ::bevy_camera::primitives::Aabb::from_min_max( - minimum.into_inner(), - maximum.into_inner(), - ) - .into(); - output - } - }; - output - }, - "", - &["minimum", "maximum"], - ) - .register_documented( - "max", - |_self: Ref<::bevy_camera::primitives::Aabb>| { - let output: Val<::bevy_math::Vec3A> = { - { - let output: Val<::bevy_math::Vec3A> = - ::bevy_camera::primitives::Aabb::max(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "min", - |_self: Ref<::bevy_camera::primitives::Aabb>| { - let output: Val<::bevy_math::Vec3A> = { - { - let output: Val<::bevy_math::Vec3A> = - ::bevy_camera::primitives::Aabb::min(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "relative_radius", - |_self: Ref<::bevy_camera::primitives::Aabb>, - p_normal: Ref<::bevy_math::Vec3A>, - world_from_local: Ref<::bevy_math::Mat3A>| { - let output: f32 = { - { - let output: f32 = ::bevy_camera::primitives::Aabb::relative_radius( - &_self, - &p_normal, - &world_from_local, - ) - .into(); - output - } - }; - output - }, - " Calculate the relative radius of the AABB with respect to a plane", - &["_self", "p_normal", "world_from_local"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); diff --git a/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml b/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml index 92449ed963..eaded9f4c7 100644 --- a/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml @@ -44,7 +44,7 @@ bevy_shader = { version = "^0.17.2", features = [], default-features = true} bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} diff --git a/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml b/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml index bbc8ec2312..f357a033e7 100644 --- a/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml @@ -56,7 +56,7 @@ bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-f bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} bytemuck = { version = "^1.0", features = [], default-features = true} diff --git a/crates/bindings/bevy_image_bms_bindings/Cargo.toml b/crates/bindings/bevy_image_bms_bindings/Cargo.toml index 2f28a5b232..5dfdefa293 100644 --- a/crates/bindings/bevy_image_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_image_bms_bindings/Cargo.toml @@ -30,7 +30,7 @@ bevy_math = { version = "^0.17.2", features = ["bevy_reflect", "alloc", "std", " bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_image_bms_bindings/src/lib.rs b/crates/bindings/bevy_image_bms_bindings/src/lib.rs index 45ce2fbf62..c848cfc71c 100644 --- a/crates/bindings/bevy_image_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_image_bms_bindings/src/lib.rs @@ -208,23 +208,6 @@ pub(crate) fn register_texture_atlas_layout_functions(world: &mut World) { }, " The number of textures in the [`TextureAtlasLayout`]", &["_self"], - ) - .register_documented( - "new_empty", - |dimensions: Val<::bevy_math::UVec2>| { - let output: Val<::bevy_image::prelude::TextureAtlasLayout> = { - { - let output: Val<::bevy_image::prelude::TextureAtlasLayout> = ::bevy_image::prelude::TextureAtlasLayout::new_empty( - dimensions.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a new empty layout with custom `dimensions`", - &["dimensions"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -339,24 +322,6 @@ pub(crate) fn register_image_functions(world: &mut World) { " Whether the texture format is compressed or uncompressed", &["_self"], ) - .register_documented( - "pixel_data_offset", - |_self: Ref<::bevy_image::prelude::Image>, coords: Val<::bevy_math::UVec3>| { - let output: ::std::option::Option = { - { - let output: ::std::option::Option = ::bevy_image::prelude::Image::pixel_data_offset( - &_self, - coords.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Compute the byte offset where the data of a specific pixel is stored\n Returns None if the provided coordinates are out of bounds.\n For 2D textures, Z is the layer number. For 1D textures, Y and Z are ignored.", - &["_self", "coords"], - ) .register_documented( "reinterpret_stacked_2d_as_array", |mut _self: Mut<::bevy_image::prelude::Image>, layers: u32| { @@ -375,40 +340,6 @@ pub(crate) fn register_image_functions(world: &mut World) { " Takes a 2D image containing vertically stacked images of the same size, and reinterprets\n it as a 2D array texture, where each of the stacked images becomes one layer of the\n array. This is primarily for use with the `texture2DArray` shader uniform type.\n # Panics\n Panics if the texture is not 2D, has more than one layers or is not evenly dividable into\n the `layers`.", &["_self", "layers"], ) - .register_documented( - "size", - |_self: Ref<::bevy_image::prelude::Image>| { - let output: Val<::bevy_math::UVec2> = { - { - let output: Val<::bevy_math::UVec2> = ::bevy_image::prelude::Image::size( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the size of a 2D image.", - &["_self"], - ) - .register_documented( - "size_f32", - |_self: Ref<::bevy_image::prelude::Image>| { - let output: Val<::bevy_math::Vec2> = { - { - let output: Val<::bevy_math::Vec2> = ::bevy_image::prelude::Image::size_f32( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the size of a 2D image as f32.", - &["_self"], - ) .register_documented( "transparent", || { diff --git a/crates/bindings/bevy_input_bms_bindings/src/lib.rs b/crates/bindings/bevy_input_bms_bindings/src/lib.rs index 8129117e7e..58fc7e1fa2 100644 --- a/crates/bindings/bevy_input_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_input_bms_bindings/src/lib.rs @@ -16,23 +16,6 @@ pub(crate) fn register_gamepad_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_input::gamepad::Gamepad, >::new(world) - .register_documented( - "dpad", - |_self: Ref<::bevy_input::gamepad::Gamepad>| { - let output: Val<::bevy_math::Vec2> = { - { - let output: Val<::bevy_math::Vec2> = ::bevy_input::gamepad::Gamepad::dpad( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the directional pad as a [`Vec2`].", - &["_self"], - ) .register_documented( "just_pressed", | @@ -75,23 +58,6 @@ pub(crate) fn register_gamepad_functions(world: &mut World) { " Returns `true` if the [`GamepadButton`] has been released during the current frame.\n Note: This function does not imply information regarding the current state of [`ButtonInput::pressed`] or [`ButtonInput::just_pressed`].", &["_self", "button_type"], ) - .register_documented( - "left_stick", - |_self: Ref<::bevy_input::gamepad::Gamepad>| { - let output: Val<::bevy_math::Vec2> = { - { - let output: Val<::bevy_math::Vec2> = ::bevy_input::gamepad::Gamepad::left_stick( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the left stick as a [`Vec2`].", - &["_self"], - ) .register_documented( "pressed", | @@ -130,23 +96,6 @@ pub(crate) fn register_gamepad_functions(world: &mut World) { " Returns the USB product ID as assigned by the [vendor], if available.\n [vendor]: Self::vendor_id", &["_self"], ) - .register_documented( - "right_stick", - |_self: Ref<::bevy_input::gamepad::Gamepad>| { - let output: Val<::bevy_math::Vec2> = { - { - let output: Val<::bevy_math::Vec2> = ::bevy_input::gamepad::Gamepad::right_stick( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the right stick as a [`Vec2`].", - &["_self"], - ) .register_documented( "vendor_id", |_self: Ref<::bevy_input::gamepad::Gamepad>| { diff --git a/crates/bindings/bevy_light_bms_bindings/Cargo.toml b/crates/bindings/bevy_light_bms_bindings/Cargo.toml index 31118f9dc7..bdcddafacb 100644 --- a/crates/bindings/bevy_light_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_light_bms_bindings/Cargo.toml @@ -42,6 +42,6 @@ bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "a bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} diff --git a/crates/bindings/bevy_math_bms_bindings/src/lib.rs b/crates/bindings/bevy_math_bms_bindings/src/lib.rs index 90ba957907..924a52a34e 100644 --- a/crates/bindings/bevy_math_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_math_bms_bindings/src/lib.rs @@ -423,23 +423,6 @@ pub(crate) fn register_isometry_2_d_functions(world: &mut World) { " Create a two-dimensional isometry from a rotation.", &["rotation"], ) - .register_documented( - "from_translation", - |translation: Val<::bevy_math::prelude::Vec2>| { - let output: Val<::bevy_math::Isometry2d> = { - { - let output: Val<::bevy_math::Isometry2d> = ::bevy_math::Isometry2d::from_translation( - translation.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a two-dimensional isometry from a translation.", - &["translation"], - ) .register_documented( "from_xy", |x: f32, y: f32| { @@ -493,27 +476,6 @@ pub(crate) fn register_isometry_2_d_functions(world: &mut World) { " Compute `iso1.inverse() * iso2` in a more efficient way for one-shot cases.\n If the same isometry is used multiple times, it is more efficient to instead compute\n the inverse once and use that for each transformation.", &["_self", "rhs"], ) - .register_documented( - "inverse_transform_point", - | - _self: Ref<::bevy_math::Isometry2d>, - point: Val<::bevy_math::prelude::Vec2>| - { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::Isometry2d::inverse_transform_point( - &_self, - point.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Transform a point by rotating and translating it using the inverse of this isometry.\n This is more efficient than `iso.inverse().transform_point(point)` for one-shot cases.\n If the same isometry is used multiple times, it is more efficient to instead compute\n the inverse once and use that for each transformation.", - &["_self", "point"], - ) .register_documented( "mul", |_self: Val<::bevy_math::Isometry2d>, rhs: Val<::bevy_math::Isometry2d>| { @@ -547,65 +509,6 @@ pub(crate) fn register_isometry_2_d_functions(world: &mut World) { }, "", &["_self", "rhs"], - ) - .register_documented( - "mul", - |_self: Val<::bevy_math::Isometry2d>, rhs: Val<::bevy_math::prelude::Vec2>| { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = <::bevy_math::Isometry2d as ::core::ops::Mul< - ::bevy_math::prelude::Vec2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output - } - }; - output - }, - "", - &["_self", "rhs"], - ) - .register_documented( - "new", - | - translation: Val<::bevy_math::prelude::Vec2>, - rotation: Val<::bevy_math::Rot2>| - { - let output: Val<::bevy_math::Isometry2d> = { - { - let output: Val<::bevy_math::Isometry2d> = ::bevy_math::Isometry2d::new( - translation.into_inner(), - rotation.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a two-dimensional isometry from a rotation and a translation.", - &["translation", "rotation"], - ) - .register_documented( - "transform_point", - | - _self: Ref<::bevy_math::Isometry2d>, - point: Val<::bevy_math::prelude::Vec2>| - { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::Isometry2d::transform_point( - &_self, - point.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Transform a point by rotating and translating it using this isometry.", - &["_self", "point"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -653,23 +556,6 @@ pub(crate) fn register_isometry_3_d_functions(world: &mut World) { "", &["_self", "other"], ) - .register_documented( - "from_rotation", - |rotation: Val<::bevy_math::prelude::Quat>| { - let output: Val<::bevy_math::Isometry3d> = { - { - let output: Val<::bevy_math::Isometry3d> = ::bevy_math::Isometry3d::from_rotation( - rotation.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a three-dimensional isometry from a rotation.", - &["rotation"], - ) .register_documented( "from_xyz", |x: f32, y: f32, z: f32| { @@ -757,40 +643,6 @@ pub(crate) fn register_isometry_3_d_functions(world: &mut World) { }, "", &["_self", "rhs"], - ) - .register_documented( - "mul", - |_self: Val<::bevy_math::Isometry3d>, rhs: Val<::bevy_math::prelude::Vec3>| { - let output: Val<::bevy_math::prelude::Vec3> = { - { - let output: Val<::bevy_math::prelude::Vec3> = <::bevy_math::Isometry3d as ::core::ops::Mul< - ::bevy_math::prelude::Vec3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output - } - }; - output - }, - "", - &["_self", "rhs"], - ) - .register_documented( - "mul", - |_self: Val<::bevy_math::Isometry3d>, rhs: Val<::bevy_math::prelude::Vec3A>| { - let output: Val<::bevy_math::prelude::Vec3A> = { - { - let output: Val<::bevy_math::prelude::Vec3A> = <::bevy_math::Isometry3d as ::core::ops::Mul< - ::bevy_math::prelude::Vec3A, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output - } - }; - output - }, - "", - &["_self", "rhs"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -835,57 +687,6 @@ pub(crate) fn register_ray_2_d_functions(world: &mut World) { }, "", &["_self", "other"], - ) - .register_documented( - "get_point", - |_self: Ref<::bevy_math::Ray2d>, distance: f32| { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = - ::bevy_math::Ray2d::get_point(&_self, distance).into(); - output - } - }; - output - }, - " Get a point at a given distance along the ray", - &["_self", "distance"], - ) - .register_documented( - "intersect_plane", - |_self: Ref<::bevy_math::Ray2d>, - plane_origin: Val<::bevy_math::prelude::Vec2>, - plane: Val<::bevy_math::primitives::Plane2d>| { - let output: ::core::option::Option = { - { - let output: ::core::option::Option = ::bevy_math::Ray2d::intersect_plane( - &_self, - plane_origin.into_inner(), - plane.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Get the distance to a plane if the ray intersects it", - &["_self", "plane_origin", "plane"], - ) - .register_documented( - "new", - |origin: Val<::bevy_math::prelude::Vec2>, direction: Val<::bevy_math::prelude::Dir2>| { - let output: Val<::bevy_math::Ray2d> = { - { - let output: Val<::bevy_math::Ray2d> = - ::bevy_math::Ray2d::new(origin.into_inner(), direction.into_inner()).into(); - output - } - }; - output - }, - " Create a new `Ray2d` from a given origin and direction", - &["origin", "direction"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -927,57 +728,6 @@ pub(crate) fn register_ray_3_d_functions(world: &mut World) { }, "", &["_self", "other"], - ) - .register_documented( - "get_point", - |_self: Ref<::bevy_math::Ray3d>, distance: f32| { - let output: Val<::bevy_math::prelude::Vec3> = { - { - let output: Val<::bevy_math::prelude::Vec3> = - ::bevy_math::Ray3d::get_point(&_self, distance).into(); - output - } - }; - output - }, - " Get a point at a given distance along the ray", - &["_self", "distance"], - ) - .register_documented( - "intersect_plane", - |_self: Ref<::bevy_math::Ray3d>, - plane_origin: Val<::bevy_math::prelude::Vec3>, - plane: Val<::bevy_math::primitives::InfinitePlane3d>| { - let output: ::core::option::Option = { - { - let output: ::core::option::Option = ::bevy_math::Ray3d::intersect_plane( - &_self, - plane_origin.into_inner(), - plane.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Get the distance to a plane if the ray intersects it", - &["_self", "plane_origin", "plane"], - ) - .register_documented( - "new", - |origin: Val<::bevy_math::prelude::Vec3>, direction: Val<::bevy_math::prelude::Dir3>| { - let output: Val<::bevy_math::Ray3d> = { - { - let output: Val<::bevy_math::Ray3d> = - ::bevy_math::Ray3d::new(origin.into_inner(), direction.into_inner()).into(); - output - } - }; - output - }, - " Create a new `Ray3d` from a given origin and direction", - &["origin", "direction"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -1309,23 +1059,6 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { " Rotates the [`Dir2`] using a [`Rot2`].", &["_self", "direction"], ) - .register_documented( - "mul", - |_self: Val<::bevy_math::Rot2>, rhs: Val<::bevy_math::prelude::Vec2>| { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = <::bevy_math::Rot2 as ::core::ops::Mul< - ::bevy_math::prelude::Vec2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output - } - }; - output - }, - " Rotates a [`Vec2`] by a [`Rot2`].", - &["_self", "rhs"], - ) .register_documented( "nlerp", |_self: Val<::bevy_math::Rot2>, end: Val<::bevy_math::Rot2>, s: f32| { @@ -1441,23 +1174,6 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_math::prelude::Dir2, >::new(world) - .register_documented( - "as_vec2", - |_self: Ref<::bevy_math::prelude::Dir2>| { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::prelude::Dir2::as_vec2( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the inner [`Vec2`]", - &["_self"], - ) .register_documented( "clone", |_self: Ref<::bevy_math::prelude::Dir2>| { @@ -1530,23 +1246,6 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { " Create a direction from its `x` and `y` components, assuming the resulting vector is normalized.\n # Warning\n The vector produced from `x` and `y` must be normalized, i.e its length must be `1.0`.", &["x", "y"], ) - .register_documented( - "mul", - |_self: Val<::bevy_math::prelude::Dir2>, rhs: f32| { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = <::bevy_math::prelude::Dir2 as ::core::ops::Mul< - f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output - } - }; - output - }, - "", - &["_self", "rhs"], - ) .register_documented( "neg", |_self: Val<::bevy_math::prelude::Dir2>| { @@ -1564,23 +1263,6 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { "", &["_self"], ) - .register_documented( - "new_unchecked", - |value: Val<::bevy_math::prelude::Vec2>| { - let output: Val<::bevy_math::prelude::Dir2> = { - { - let output: Val<::bevy_math::prelude::Dir2> = ::bevy_math::prelude::Dir2::new_unchecked( - value.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a [`Dir2`] from a [`Vec2`] that is already normalized.\n # Warning\n `value` must be normalized, i.e its length must be `1.0`.", - &["value"], - ) .register_documented( "rotation_from", | @@ -1726,23 +1408,6 @@ pub(crate) fn register_dir_3_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_math::prelude::Dir3, >::new(world) - .register_documented( - "as_vec3", - |_self: Ref<::bevy_math::prelude::Dir3>| { - let output: Val<::bevy_math::prelude::Vec3> = { - { - let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::prelude::Dir3::as_vec3( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the inner [`Vec3`]", - &["_self"], - ) .register_documented( "clone", |_self: Ref<::bevy_math::prelude::Dir3>| { @@ -1816,23 +1481,6 @@ pub(crate) fn register_dir_3_functions(world: &mut World) { " Create a direction from its `x`, `y`, and `z` components, assuming the resulting vector is normalized.\n # Warning\n The vector produced from `x`, `y`, and `z` must be normalized, i.e its length must be `1.0`.", &["x", "y", "z"], ) - .register_documented( - "mul", - |_self: Val<::bevy_math::prelude::Dir3>, rhs: f32| { - let output: Val<::bevy_math::prelude::Vec3> = { - { - let output: Val<::bevy_math::prelude::Vec3> = <::bevy_math::prelude::Dir3 as ::core::ops::Mul< - f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output - } - }; - output - }, - "", - &["_self", "rhs"], - ) .register_documented( "neg", |_self: Val<::bevy_math::prelude::Dir3>| { @@ -1850,23 +1498,6 @@ pub(crate) fn register_dir_3_functions(world: &mut World) { "", &["_self"], ) - .register_documented( - "new_unchecked", - |value: Val<::bevy_math::prelude::Vec3>| { - let output: Val<::bevy_math::prelude::Dir3> = { - { - let output: Val<::bevy_math::prelude::Dir3> = ::bevy_math::prelude::Dir3::new_unchecked( - value.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a [`Dir3`] from a [`Vec3`] that is already normalized.\n # Warning\n `value` must be normalized, i.e its length must be `1.0`.", - &["value"], - ) .register_documented( "slerp", | @@ -1903,11 +1534,11 @@ pub(crate) fn register_dir_3_a_functions(world: &mut World) { ::bevy_math::prelude::Dir3A, >::new(world) .register_documented( - "as_vec3a", + "clone", |_self: Ref<::bevy_math::prelude::Dir3A>| { - let output: Val<::bevy_math::prelude::Vec3A> = { + let output: Val<::bevy_math::prelude::Dir3A> = { { - let output: Val<::bevy_math::prelude::Vec3A> = ::bevy_math::prelude::Dir3A::as_vec3a( + let output: Val<::bevy_math::prelude::Dir3A> = <::bevy_math::prelude::Dir3A as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -1916,24 +1547,7 @@ pub(crate) fn register_dir_3_a_functions(world: &mut World) { }; output }, - " Returns the inner [`Vec3A`]", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_math::prelude::Dir3A>| { - let output: Val<::bevy_math::prelude::Dir3A> = { - { - let output: Val<::bevy_math::prelude::Dir3A> = <::bevy_math::prelude::Dir3A as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", + "", &["_self"], ) .register_documented( @@ -1992,23 +1606,6 @@ pub(crate) fn register_dir_3_a_functions(world: &mut World) { " Create a direction from its `x`, `y`, and `z` components, assuming the resulting vector is normalized.\n # Warning\n The vector produced from `x`, `y`, and `z` must be normalized, i.e its length must be `1.0`.", &["x", "y", "z"], ) - .register_documented( - "mul", - |_self: Val<::bevy_math::prelude::Dir3A>, rhs: f32| { - let output: Val<::bevy_math::prelude::Vec3A> = { - { - let output: Val<::bevy_math::prelude::Vec3A> = <::bevy_math::prelude::Dir3A as ::core::ops::Mul< - f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output - } - }; - output - }, - "", - &["_self", "rhs"], - ) .register_documented( "neg", |_self: Val<::bevy_math::prelude::Dir3A>| { @@ -2026,23 +1623,6 @@ pub(crate) fn register_dir_3_a_functions(world: &mut World) { "", &["_self"], ) - .register_documented( - "new_unchecked", - |value: Val<::bevy_math::prelude::Vec3A>| { - let output: Val<::bevy_math::prelude::Dir3A> = { - { - let output: Val<::bevy_math::prelude::Dir3A> = ::bevy_math::prelude::Dir3A::new_unchecked( - value.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a [`Dir3A`] from a [`Vec3A`] that is already normalized.\n # Warning\n `value` must be normalized, i.e its length must be `1.0`.", - &["value"], - ) .register_documented( "slerp", | @@ -2129,23 +1709,6 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { "", &["_self"], ) - .register_documented( - "center", - |_self: Ref<::bevy_math::prelude::IRect>| { - let output: Val<::bevy_math::prelude::IVec2> = { - { - let output: Val<::bevy_math::prelude::IVec2> = ::bevy_math::prelude::IRect::center( - &_self, - ) - .into(); - output - } - }; - output - }, - " The center point of the rectangle.\n # Rounding Behavior\n If the (min + max) contains odd numbers they will be rounded down to the nearest whole number when calculating the center.\n # Examples\n ```\n # use bevy_math::{IRect, IVec2};\n let r = IRect::new(0, 0, 5, 2); // w=5 h=2\n assert_eq!(r.center(), IVec2::new(2, 1));\n ```", - &["_self"], - ) .register_documented( "clone", |_self: Ref<::bevy_math::prelude::IRect>| { @@ -2163,27 +1726,6 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { "", &["_self"], ) - .register_documented( - "contains", - | - _self: Ref<::bevy_math::prelude::IRect>, - point: Val<::bevy_math::prelude::IVec2>| - { - let output: bool = { - { - let output: bool = ::bevy_math::prelude::IRect::contains( - &_self, - point.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Check if a point lies within this rectangle, inclusive of its edges.\n # Examples\n ```\n # use bevy_math::IRect;\n let r = IRect::new(0, 0, 5, 1); // w=5 h=1\n assert!(r.contains(r.center()));\n assert!(r.contains(r.min));\n assert!(r.contains(r.max));\n ```", - &["_self", "point"], - ) .register_documented( "eq", | @@ -2204,83 +1746,6 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { "", &["_self", "other"], ) - .register_documented( - "from_center_half_size", - | - origin: Val<::bevy_math::prelude::IVec2>, - half_size: Val<::bevy_math::prelude::IVec2>| - { - let output: Val<::bevy_math::prelude::IRect> = { - { - let output: Val<::bevy_math::prelude::IRect> = ::bevy_math::prelude::IRect::from_center_half_size( - origin.into_inner(), - half_size.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a new rectangle from its center and half-size.\n # Panics\n This method panics if any of the components of the half-size is negative.\n # Examples\n ```\n # use bevy_math::{IRect, IVec2};\n let r = IRect::from_center_half_size(IVec2::ZERO, IVec2::ONE); // w=2 h=2\n assert_eq!(r.min, IVec2::splat(-1));\n assert_eq!(r.max, IVec2::splat(1));\n ```", - &["origin", "half_size"], - ) - .register_documented( - "from_center_size", - | - origin: Val<::bevy_math::prelude::IVec2>, - size: Val<::bevy_math::prelude::IVec2>| - { - let output: Val<::bevy_math::prelude::IRect> = { - { - let output: Val<::bevy_math::prelude::IRect> = ::bevy_math::prelude::IRect::from_center_size( - origin.into_inner(), - size.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a new rectangle from its center and size.\n # Rounding Behavior\n If the size contains odd numbers they will be rounded down to the nearest whole number.\n # Panics\n This method panics if any of the components of the size is negative.\n # Examples\n ```\n # use bevy_math::{IRect, IVec2};\n let r = IRect::from_center_size(IVec2::ZERO, IVec2::new(3, 2)); // w=2 h=2\n assert_eq!(r.min, IVec2::splat(-1));\n assert_eq!(r.max, IVec2::splat(1));\n ```", - &["origin", "size"], - ) - .register_documented( - "from_corners", - |p0: Val<::bevy_math::prelude::IVec2>, p1: Val<::bevy_math::prelude::IVec2>| { - let output: Val<::bevy_math::prelude::IRect> = { - { - let output: Val<::bevy_math::prelude::IRect> = ::bevy_math::prelude::IRect::from_corners( - p0.into_inner(), - p1.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a new rectangle from two corner points.\n The two points do not need to be the minimum and/or maximum corners.\n They only need to be two opposite corners.\n # Examples\n ```\n # use bevy_math::{IRect, IVec2};\n // Unit rect from [0,0] to [1,1]\n let r = IRect::from_corners(IVec2::ZERO, IVec2::ONE); // w=1 h=1\n // Same; the points do not need to be ordered\n let r = IRect::from_corners(IVec2::ONE, IVec2::ZERO); // w=1 h=1\n ```", - &["p0", "p1"], - ) - .register_documented( - "half_size", - |_self: Ref<::bevy_math::prelude::IRect>| { - let output: Val<::bevy_math::prelude::IVec2> = { - { - let output: Val<::bevy_math::prelude::IVec2> = ::bevy_math::prelude::IRect::half_size( - &_self, - ) - .into(); - output - } - }; - output - }, - " Rectangle half-size.\n # Rounding Behavior\n If the full size contains odd numbers they will be rounded down to the nearest whole number when calculating the half size.\n # Examples\n ```\n # use bevy_math::{IRect, IVec2};\n let r = IRect::new(0, 0, 4, 3); // w=4 h=3\n assert_eq!(r.half_size(), IVec2::new(2, 1));\n ```", - &["_self"], - ) .register_documented( "height", |_self: Ref<::bevy_math::prelude::IRect>| { @@ -2370,23 +1835,6 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { " Create a new rectangle from two corner points.\n The two points do not need to be the minimum and/or maximum corners.\n They only need to be two opposite corners.\n # Examples\n ```\n # use bevy_math::IRect;\n let r = IRect::new(0, 4, 10, 6); // w=10 h=2\n let r = IRect::new(2, 3, 5, -1); // w=3 h=4\n ```", &["x0", "y0", "x1", "y1"], ) - .register_documented( - "size", - |_self: Ref<::bevy_math::prelude::IRect>| { - let output: Val<::bevy_math::prelude::IVec2> = { - { - let output: Val<::bevy_math::prelude::IVec2> = ::bevy_math::prelude::IRect::size( - &_self, - ) - .into(); - output - } - }; - output - }, - " Rectangle size.\n # Examples\n ```\n # use bevy_math::{IRect, IVec2};\n let r = IRect::new(0, 0, 5, 1); // w=5 h=1\n assert_eq!(r.size(), IVec2::new(5, 1));\n ```", - &["_self"], - ) .register_documented( "union", | @@ -2408,27 +1856,6 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { " Build a new rectangle formed of the union of this rectangle and another rectangle.\n The union is the smallest rectangle enclosing both rectangles.\n # Examples\n ```\n # use bevy_math::{IRect, IVec2};\n let r1 = IRect::new(0, 0, 5, 1); // w=5 h=1\n let r2 = IRect::new(1, -1, 3, 3); // w=2 h=4\n let r = r1.union(r2);\n assert_eq!(r.min, IVec2::new(0, -1));\n assert_eq!(r.max, IVec2::new(5, 3));\n ```", &["_self", "other"], ) - .register_documented( - "union_point", - | - _self: Ref<::bevy_math::prelude::IRect>, - other: Val<::bevy_math::prelude::IVec2>| - { - let output: Val<::bevy_math::prelude::IRect> = { - { - let output: Val<::bevy_math::prelude::IRect> = ::bevy_math::prelude::IRect::union_point( - &_self, - other.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Build a new rectangle formed of the union of this rectangle and a point.\n The union is the smallest rectangle enclosing both the rectangle and the point. If the\n point is already inside the rectangle, this method returns a copy of the rectangle.\n # Examples\n ```\n # use bevy_math::{IRect, IVec2};\n let r = IRect::new(0, 0, 5, 1); // w=5 h=1\n let u = r.union_point(IVec2::new(3, 6));\n assert_eq!(u.min, IVec2::ZERO);\n assert_eq!(u.max, IVec2::new(5, 6));\n ```", - &["_self", "other"], - ) .register_documented( "width", |_self: Ref<::bevy_math::prelude::IRect>| { @@ -2490,23 +1917,6 @@ pub(crate) fn register_rect_functions(world: &mut World) { " Returns self as [`URect`] (u32)", &["_self"], ) - .register_documented( - "center", - |_self: Ref<::bevy_math::prelude::Rect>| { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::prelude::Rect::center( - &_self, - ) - .into(); - output - } - }; - output - }, - " The center point of the rectangle.\n # Examples\n ```\n # use bevy_math::{Rect, Vec2};\n let r = Rect::new(0., 0., 5., 1.); // w=5 h=1\n assert!(r.center().abs_diff_eq(Vec2::new(2.5, 0.5), 1e-5));\n ```", - &["_self"], - ) .register_documented( "clone", |_self: Ref<::bevy_math::prelude::Rect>| { @@ -2524,27 +1934,6 @@ pub(crate) fn register_rect_functions(world: &mut World) { "", &["_self"], ) - .register_documented( - "contains", - | - _self: Ref<::bevy_math::prelude::Rect>, - point: Val<::bevy_math::prelude::Vec2>| - { - let output: bool = { - { - let output: bool = ::bevy_math::prelude::Rect::contains( - &_self, - point.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Check if a point lies within this rectangle, inclusive of its edges.\n # Examples\n ```\n # use bevy_math::Rect;\n let r = Rect::new(0., 0., 5., 1.); // w=5 h=1\n assert!(r.contains(r.center()));\n assert!(r.contains(r.min));\n assert!(r.contains(r.max));\n ```", - &["_self", "point"], - ) .register_documented( "eq", | @@ -2565,83 +1954,6 @@ pub(crate) fn register_rect_functions(world: &mut World) { "", &["_self", "other"], ) - .register_documented( - "from_center_half_size", - | - origin: Val<::bevy_math::prelude::Vec2>, - half_size: Val<::bevy_math::prelude::Vec2>| - { - let output: Val<::bevy_math::prelude::Rect> = { - { - let output: Val<::bevy_math::prelude::Rect> = ::bevy_math::prelude::Rect::from_center_half_size( - origin.into_inner(), - half_size.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a new rectangle from its center and half-size.\n # Panics\n This method panics if any of the components of the half-size is negative.\n # Examples\n ```\n # use bevy_math::{Rect, Vec2};\n let r = Rect::from_center_half_size(Vec2::ZERO, Vec2::ONE); // w=2 h=2\n assert!(r.min.abs_diff_eq(Vec2::splat(-1.), 1e-5));\n assert!(r.max.abs_diff_eq(Vec2::splat(1.), 1e-5));\n ```", - &["origin", "half_size"], - ) - .register_documented( - "from_center_size", - | - origin: Val<::bevy_math::prelude::Vec2>, - size: Val<::bevy_math::prelude::Vec2>| - { - let output: Val<::bevy_math::prelude::Rect> = { - { - let output: Val<::bevy_math::prelude::Rect> = ::bevy_math::prelude::Rect::from_center_size( - origin.into_inner(), - size.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a new rectangle from its center and size.\n # Panics\n This method panics if any of the components of the size is negative.\n # Examples\n ```\n # use bevy_math::{Rect, Vec2};\n let r = Rect::from_center_size(Vec2::ZERO, Vec2::ONE); // w=1 h=1\n assert!(r.min.abs_diff_eq(Vec2::splat(-0.5), 1e-5));\n assert!(r.max.abs_diff_eq(Vec2::splat(0.5), 1e-5));\n ```", - &["origin", "size"], - ) - .register_documented( - "from_corners", - |p0: Val<::bevy_math::prelude::Vec2>, p1: Val<::bevy_math::prelude::Vec2>| { - let output: Val<::bevy_math::prelude::Rect> = { - { - let output: Val<::bevy_math::prelude::Rect> = ::bevy_math::prelude::Rect::from_corners( - p0.into_inner(), - p1.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a new rectangle from two corner points.\n The two points do not need to be the minimum and/or maximum corners.\n They only need to be two opposite corners.\n # Examples\n ```\n # use bevy_math::{Rect, Vec2};\n // Unit rect from [0,0] to [1,1]\n let r = Rect::from_corners(Vec2::ZERO, Vec2::ONE); // w=1 h=1\n // Same; the points do not need to be ordered\n let r = Rect::from_corners(Vec2::ONE, Vec2::ZERO); // w=1 h=1\n ```", - &["p0", "p1"], - ) - .register_documented( - "half_size", - |_self: Ref<::bevy_math::prelude::Rect>| { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::prelude::Rect::half_size( - &_self, - ) - .into(); - output - } - }; - output - }, - " Rectangle half-size.\n # Examples\n ```\n # use bevy_math::{Rect, Vec2};\n let r = Rect::new(0., 0., 5., 1.); // w=5 h=1\n assert!(r.half_size().abs_diff_eq(Vec2::new(2.5, 0.5), 1e-5));\n ```", - &["_self"], - ) .register_documented( "height", |_self: Ref<::bevy_math::prelude::Rect>| { @@ -2752,23 +2064,6 @@ pub(crate) fn register_rect_functions(world: &mut World) { " Build a new rectangle from this one with its coordinates expressed\n relative to `other` in a normalized ([0..1] x [0..1]) coordinate system.\n # Examples\n ```\n # use bevy_math::{Rect, Vec2};\n let r = Rect::new(2., 3., 4., 6.);\n let s = Rect::new(0., 0., 10., 10.);\n let n = r.normalize(s);\n assert_eq!(n.min.x, 0.2);\n assert_eq!(n.min.y, 0.3);\n assert_eq!(n.max.x, 0.4);\n assert_eq!(n.max.y, 0.6);\n ```", &["_self", "other"], ) - .register_documented( - "size", - |_self: Ref<::bevy_math::prelude::Rect>| { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::prelude::Rect::size( - &_self, - ) - .into(); - output - } - }; - output - }, - " Rectangle size.\n # Examples\n ```\n # use bevy_math::{Rect, Vec2};\n let r = Rect::new(0., 0., 5., 1.); // w=5 h=1\n assert!(r.size().abs_diff_eq(Vec2::new(5., 1.), 1e-5));\n ```", - &["_self"], - ) .register_documented( "union", | @@ -2790,27 +2085,6 @@ pub(crate) fn register_rect_functions(world: &mut World) { " Build a new rectangle formed of the union of this rectangle and another rectangle.\n The union is the smallest rectangle enclosing both rectangles.\n # Examples\n ```\n # use bevy_math::{Rect, Vec2};\n let r1 = Rect::new(0., 0., 5., 1.); // w=5 h=1\n let r2 = Rect::new(1., -1., 3., 3.); // w=2 h=4\n let r = r1.union(r2);\n assert!(r.min.abs_diff_eq(Vec2::new(0., -1.), 1e-5));\n assert!(r.max.abs_diff_eq(Vec2::new(5., 3.), 1e-5));\n ```", &["_self", "other"], ) - .register_documented( - "union_point", - | - _self: Ref<::bevy_math::prelude::Rect>, - other: Val<::bevy_math::prelude::Vec2>| - { - let output: Val<::bevy_math::prelude::Rect> = { - { - let output: Val<::bevy_math::prelude::Rect> = ::bevy_math::prelude::Rect::union_point( - &_self, - other.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Build a new rectangle formed of the union of this rectangle and a point.\n The union is the smallest rectangle enclosing both the rectangle and the point. If the\n point is already inside the rectangle, this method returns a copy of the rectangle.\n # Examples\n ```\n # use bevy_math::{Rect, Vec2};\n let r = Rect::new(0., 0., 5., 1.); // w=5 h=1\n let u = r.union_point(Vec2::new(3., 6.));\n assert!(u.min.abs_diff_eq(Vec2::ZERO, 1e-5));\n assert!(u.max.abs_diff_eq(Vec2::new(5., 6.), 1e-5));\n ```", - &["_self", "other"], - ) .register_documented( "width", |_self: Ref<::bevy_math::prelude::Rect>| { @@ -2890,26 +2164,9 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { &["_self"], ) .register_documented( - "center", + "clone", |_self: Ref<::bevy_math::prelude::URect>| { - let output: Val<::bevy_math::prelude::UVec2> = { - { - let output: Val<::bevy_math::prelude::UVec2> = ::bevy_math::prelude::URect::center( - &_self, - ) - .into(); - output - } - }; - output - }, - " The center point of the rectangle.\n # Rounding Behavior\n If the (min + max) contains odd numbers they will be rounded down to the nearest whole number when calculating the center.\n # Examples\n ```\n # use bevy_math::{URect, UVec2};\n let r = URect::new(0, 0, 4, 2); // w=4 h=2\n assert_eq!(r.center(), UVec2::new(2, 1));\n ```", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_math::prelude::URect>| { - let output: Val<::bevy_math::prelude::URect> = { + let output: Val<::bevy_math::prelude::URect> = { { let output: Val<::bevy_math::prelude::URect> = <::bevy_math::prelude::URect as ::core::clone::Clone>::clone( &_self, @@ -2923,27 +2180,6 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { "", &["_self"], ) - .register_documented( - "contains", - | - _self: Ref<::bevy_math::prelude::URect>, - point: Val<::bevy_math::prelude::UVec2>| - { - let output: bool = { - { - let output: bool = ::bevy_math::prelude::URect::contains( - &_self, - point.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Check if a point lies within this rectangle, inclusive of its edges.\n # Examples\n ```\n # use bevy_math::URect;\n let r = URect::new(0, 0, 5, 1); // w=5 h=1\n assert!(r.contains(r.center()));\n assert!(r.contains(r.min));\n assert!(r.contains(r.max));\n ```", - &["_self", "point"], - ) .register_documented( "eq", | @@ -2964,83 +2200,6 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { "", &["_self", "other"], ) - .register_documented( - "from_center_half_size", - | - origin: Val<::bevy_math::prelude::UVec2>, - half_size: Val<::bevy_math::prelude::UVec2>| - { - let output: Val<::bevy_math::prelude::URect> = { - { - let output: Val<::bevy_math::prelude::URect> = ::bevy_math::prelude::URect::from_center_half_size( - origin.into_inner(), - half_size.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a new rectangle from its center and half-size.\n # Panics\n This method panics if any of the components of the half-size is negative or if `origin - half_size` results in any negatives.\n # Examples\n ```\n # use bevy_math::{URect, UVec2};\n let r = URect::from_center_half_size(UVec2::ONE, UVec2::ONE); // w=2 h=2\n assert_eq!(r.min, UVec2::splat(0));\n assert_eq!(r.max, UVec2::splat(2));\n ```", - &["origin", "half_size"], - ) - .register_documented( - "from_center_size", - | - origin: Val<::bevy_math::prelude::UVec2>, - size: Val<::bevy_math::prelude::UVec2>| - { - let output: Val<::bevy_math::prelude::URect> = { - { - let output: Val<::bevy_math::prelude::URect> = ::bevy_math::prelude::URect::from_center_size( - origin.into_inner(), - size.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a new rectangle from its center and size.\n # Rounding Behavior\n If the size contains odd numbers they will be rounded down to the nearest whole number.\n # Panics\n This method panics if any of the components of the size is negative or if `origin - (size / 2)` results in any negatives.\n # Examples\n ```\n # use bevy_math::{URect, UVec2};\n let r = URect::from_center_size(UVec2::ONE, UVec2::splat(2)); // w=2 h=2\n assert_eq!(r.min, UVec2::splat(0));\n assert_eq!(r.max, UVec2::splat(2));\n ```", - &["origin", "size"], - ) - .register_documented( - "from_corners", - |p0: Val<::bevy_math::prelude::UVec2>, p1: Val<::bevy_math::prelude::UVec2>| { - let output: Val<::bevy_math::prelude::URect> = { - { - let output: Val<::bevy_math::prelude::URect> = ::bevy_math::prelude::URect::from_corners( - p0.into_inner(), - p1.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a new rectangle from two corner points.\n The two points do not need to be the minimum and/or maximum corners.\n They only need to be two opposite corners.\n # Examples\n ```\n # use bevy_math::{URect, UVec2};\n // Unit rect from [0,0] to [1,1]\n let r = URect::from_corners(UVec2::ZERO, UVec2::ONE); // w=1 h=1\n // Same; the points do not need to be ordered\n let r = URect::from_corners(UVec2::ONE, UVec2::ZERO); // w=1 h=1\n ```", - &["p0", "p1"], - ) - .register_documented( - "half_size", - |_self: Ref<::bevy_math::prelude::URect>| { - let output: Val<::bevy_math::prelude::UVec2> = { - { - let output: Val<::bevy_math::prelude::UVec2> = ::bevy_math::prelude::URect::half_size( - &_self, - ) - .into(); - output - } - }; - output - }, - " Rectangle half-size.\n # Rounding Behavior\n If the full size contains odd numbers they will be rounded down to the nearest whole number when calculating the half size.\n # Examples\n ```\n # use bevy_math::{URect, UVec2};\n let r = URect::new(0, 0, 4, 2); // w=4 h=2\n assert_eq!(r.half_size(), UVec2::new(2, 1));\n ```", - &["_self"], - ) .register_documented( "height", |_self: Ref<::bevy_math::prelude::URect>| { @@ -3130,23 +2289,6 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { " Create a new rectangle from two corner points.\n The two points do not need to be the minimum and/or maximum corners.\n They only need to be two opposite corners.\n # Examples\n ```\n # use bevy_math::URect;\n let r = URect::new(0, 4, 10, 6); // w=10 h=2\n let r = URect::new(2, 4, 5, 0); // w=3 h=4\n ```", &["x0", "y0", "x1", "y1"], ) - .register_documented( - "size", - |_self: Ref<::bevy_math::prelude::URect>| { - let output: Val<::bevy_math::prelude::UVec2> = { - { - let output: Val<::bevy_math::prelude::UVec2> = ::bevy_math::prelude::URect::size( - &_self, - ) - .into(); - output - } - }; - output - }, - " Rectangle size.\n # Examples\n ```\n # use bevy_math::{URect, UVec2};\n let r = URect::new(0, 0, 5, 1); // w=5 h=1\n assert_eq!(r.size(), UVec2::new(5, 1));\n ```", - &["_self"], - ) .register_documented( "union", | @@ -3168,27 +2310,6 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { " Build a new rectangle formed of the union of this rectangle and another rectangle.\n The union is the smallest rectangle enclosing both rectangles.\n # Examples\n ```\n # use bevy_math::{URect, UVec2};\n let r1 = URect::new(0, 0, 5, 1); // w=5 h=1\n let r2 = URect::new(1, 0, 3, 8); // w=2 h=4\n let r = r1.union(r2);\n assert_eq!(r.min, UVec2::new(0, 0));\n assert_eq!(r.max, UVec2::new(5, 8));\n ```", &["_self", "other"], ) - .register_documented( - "union_point", - | - _self: Ref<::bevy_math::prelude::URect>, - other: Val<::bevy_math::prelude::UVec2>| - { - let output: Val<::bevy_math::prelude::URect> = { - { - let output: Val<::bevy_math::prelude::URect> = ::bevy_math::prelude::URect::union_point( - &_self, - other.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Build a new rectangle formed of the union of this rectangle and a point.\n The union is the smallest rectangle enclosing both the rectangle and the point. If the\n point is already inside the rectangle, this method returns a copy of the rectangle.\n # Examples\n ```\n # use bevy_math::{URect, UVec2};\n let r = URect::new(0, 0, 5, 1); // w=5 h=1\n let u = r.union_point(UVec2::new(3, 6));\n assert_eq!(u.min, UVec2::ZERO);\n assert_eq!(u.max, UVec2::new(5, 6));\n ```", - &["_self", "other"], - ) .register_documented( "width", |_self: Ref<::bevy_math::prelude::URect>| { @@ -3225,102 +2346,54 @@ pub(crate) fn register_aabb_2_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_math::bounding::Aabb2d, >::new(world) - .register_documented( - "bounding_circle", - |_self: Ref<::bevy_math::bounding::Aabb2d>| { - let output: Val<::bevy_math::bounding::BoundingCircle> = { - { - let output: Val<::bevy_math::bounding::BoundingCircle> = ::bevy_math::bounding::Aabb2d::bounding_circle( - &_self, - ) - .into(); - output - } - }; - output - }, - " Computes the smallest [`BoundingCircle`] containing this [`Aabb2d`].", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_math::bounding::Aabb2d>| { - let output: Val<::bevy_math::bounding::Aabb2d> = { - { - let output: Val<::bevy_math::bounding::Aabb2d> = <::bevy_math::bounding::Aabb2d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "closest_point", - | - _self: Ref<::bevy_math::bounding::Aabb2d>, - point: Val<::bevy_math::prelude::Vec2>| - { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::bounding::Aabb2d::closest_point( - &_self, - point.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Finds the point on the AABB that is closest to the given `point`.\n If the point is outside the AABB, the returned point will be on the perimeter of the AABB.\n Otherwise, it will be inside the AABB and returned as is.", - &["_self", "point"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_math::bounding::Aabb2d>, - other: Ref<::bevy_math::bounding::Aabb2d>| - { - let output: bool = { - { - let output: bool = <::bevy_math::bounding::Aabb2d as ::core::cmp::PartialEq< - ::bevy_math::bounding::Aabb2d, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "new", - | - center: Val<::bevy_math::prelude::Vec2>, - half_size: Val<::bevy_math::prelude::Vec2>| - { - let output: Val<::bevy_math::bounding::Aabb2d> = { - { - let output: Val<::bevy_math::bounding::Aabb2d> = ::bevy_math::bounding::Aabb2d::new( - center.into_inner(), - half_size.into_inner(), - ) + .register_documented( + "bounding_circle", + |_self: Ref<::bevy_math::bounding::Aabb2d>| { + let output: Val<::bevy_math::bounding::BoundingCircle> = { + { + let output: Val<::bevy_math::bounding::BoundingCircle> = + ::bevy_math::bounding::Aabb2d::bounding_circle(&_self).into(); + output + } + }; + output + }, + " Computes the smallest [`BoundingCircle`] containing this [`Aabb2d`].", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_math::bounding::Aabb2d>| { + let output: Val<::bevy_math::bounding::Aabb2d> = { + { + let output: Val<::bevy_math::bounding::Aabb2d> = + <::bevy_math::bounding::Aabb2d as ::core::clone::Clone>::clone(&_self) .into(); - output - } - }; - output - }, - " Constructs an AABB from its center and half-size.", - &["center", "half_size"], - ); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_math::bounding::Aabb2d>, other: Ref<::bevy_math::bounding::Aabb2d>| { + let output: bool = { + { + let output: bool = <::bevy_math::bounding::Aabb2d as ::core::cmp::PartialEq< + ::bevy_math::bounding::Aabb2d, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -3333,116 +2406,72 @@ pub(crate) fn register_bounding_circle_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_math::bounding::BoundingCircle, >::new(world) - .register_documented( - "aabb_2d", - |_self: Ref<::bevy_math::bounding::BoundingCircle>| { - let output: Val<::bevy_math::bounding::Aabb2d> = { - { - let output: Val<::bevy_math::bounding::Aabb2d> = ::bevy_math::bounding::BoundingCircle::aabb_2d( - &_self, - ) - .into(); - output - } - }; - output - }, - " Computes the smallest [`Aabb2d`] containing this [`BoundingCircle`].", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_math::bounding::BoundingCircle>| { - let output: Val<::bevy_math::bounding::BoundingCircle> = { - { - let output: Val<::bevy_math::bounding::BoundingCircle> = <::bevy_math::bounding::BoundingCircle as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "closest_point", - | - _self: Ref<::bevy_math::bounding::BoundingCircle>, - point: Val<::bevy_math::prelude::Vec2>| - { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::bounding::BoundingCircle::closest_point( - &_self, - point.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Finds the point on the bounding circle that is closest to the given `point`.\n If the point is outside the circle, the returned point will be on the perimeter of the circle.\n Otherwise, it will be inside the circle and returned as is.", - &["_self", "point"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_math::bounding::BoundingCircle>, - other: Ref<::bevy_math::bounding::BoundingCircle>| - { - let output: bool = { - { - let output: bool = <::bevy_math::bounding::BoundingCircle as ::core::cmp::PartialEq< + .register_documented( + "aabb_2d", + |_self: Ref<::bevy_math::bounding::BoundingCircle>| { + let output: Val<::bevy_math::bounding::Aabb2d> = { + { + let output: Val<::bevy_math::bounding::Aabb2d> = + ::bevy_math::bounding::BoundingCircle::aabb_2d(&_self).into(); + output + } + }; + output + }, + " Computes the smallest [`Aabb2d`] containing this [`BoundingCircle`].", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_math::bounding::BoundingCircle>| { + let output: Val<::bevy_math::bounding::BoundingCircle> = { + { + let output: Val<::bevy_math::bounding::BoundingCircle> = + <::bevy_math::bounding::BoundingCircle as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_math::bounding::BoundingCircle>, + other: Ref<::bevy_math::bounding::BoundingCircle>| { + let output: bool = { + { + let output: bool = + <::bevy_math::bounding::BoundingCircle as ::core::cmp::PartialEq< ::bevy_math::bounding::BoundingCircle, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "new", - |center: Val<::bevy_math::prelude::Vec2>, radius: f32| { - let output: Val<::bevy_math::bounding::BoundingCircle> = { - { - let output: Val<::bevy_math::bounding::BoundingCircle> = ::bevy_math::bounding::BoundingCircle::new( - center.into_inner(), - radius, - ) - .into(); - output - } - }; - output - }, - " Constructs a bounding circle from its center and radius.", - &["center", "radius"], - ) - .register_documented( - "radius", - |_self: Ref<::bevy_math::bounding::BoundingCircle>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::bounding::BoundingCircle::radius( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the radius of the bounding circle", - &["_self"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "radius", + |_self: Ref<::bevy_math::bounding::BoundingCircle>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::bounding::BoundingCircle::radius(&_self).into(); + output + } + }; + output + }, + " Get the radius of the bounding circle", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -3455,556 +2484,89 @@ pub(crate) fn register_circle_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_math::primitives::Circle, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Circle>| { - let output: Val<::bevy_math::primitives::Circle> = { - { - let output: Val<::bevy_math::primitives::Circle> = <::bevy_math::primitives::Circle as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "closest_point", - | - _self: Ref<::bevy_math::primitives::Circle>, - point: Val<::bevy_math::prelude::Vec2>| - { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Circle::closest_point( - &_self, - point.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Finds the point on the circle that is closest to the given `point`.\n If the point is outside the circle, the returned point will be on the perimeter of the circle.\n Otherwise, it will be inside the circle and returned as is.", - &["_self", "point"], - ) - .register_documented( - "diameter", - |_self: Ref<::bevy_math::primitives::Circle>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::Circle::diameter( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the diameter of the circle", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_math::primitives::Circle>, - other: Ref<::bevy_math::primitives::Circle>| - { - let output: bool = { - { - let output: bool = <::bevy_math::primitives::Circle as ::core::cmp::PartialEq< - ::bevy_math::primitives::Circle, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "new", - |radius: f32| { - let output: Val<::bevy_math::primitives::Circle> = { - { - let output: Val<::bevy_math::primitives::Circle> = ::bevy_math::primitives::Circle::new( - radius, - ) - .into(); - output - } - }; - output - }, - " Create a new [`Circle`] from a `radius`", - &["radius"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::primitives::Circle, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_annulus_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Annulus, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Annulus>| { - let output: Val<::bevy_math::primitives::Annulus> = { - { - let output: Val<::bevy_math::primitives::Annulus> = <::bevy_math::primitives::Annulus as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "closest_point", - | - _self: Ref<::bevy_math::primitives::Annulus>, - point: Val<::bevy_math::prelude::Vec2>| - { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Annulus::closest_point( - &_self, - point.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Finds the point on the annulus that is closest to the given `point`:\n - If the point is outside of the annulus completely, the returned point will be on the outer perimeter.\n - If the point is inside of the inner circle (hole) of the annulus, the returned point will be on the inner perimeter.\n - Otherwise, the returned point is overlapping the annulus and returned as is.", - &["_self", "point"], - ) - .register_documented( - "diameter", - |_self: Ref<::bevy_math::primitives::Annulus>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::Annulus::diameter( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the diameter of the annulus", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_math::primitives::Annulus>, - other: Ref<::bevy_math::primitives::Annulus>| - { - let output: bool = { - { - let output: bool = <::bevy_math::primitives::Annulus as ::core::cmp::PartialEq< - ::bevy_math::primitives::Annulus, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "new", - |inner_radius: f32, outer_radius: f32| { - let output: Val<::bevy_math::primitives::Annulus> = { - { - let output: Val<::bevy_math::primitives::Annulus> = ::bevy_math::primitives::Annulus::new( - inner_radius, - outer_radius, - ) - .into(); - output - } - }; - output - }, - " Create a new [`Annulus`] from the radii of the inner and outer circle", - &["inner_radius", "outer_radius"], - ) - .register_documented( - "thickness", - |_self: Ref<::bevy_math::primitives::Annulus>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::Annulus::thickness( - &_self, - ) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Circle>| { + let output: Val<::bevy_math::primitives::Circle> = { + { + let output: Val<::bevy_math::primitives::Circle> = + <::bevy_math::primitives::Circle as ::core::clone::Clone>::clone(&_self) .into(); - output - } - }; - output - }, - " Get the thickness of the annulus", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::primitives::Annulus, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_arc_2_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Arc2d, - >::new(world) - .register_documented( - "angle", - |_self: Ref<::bevy_math::primitives::Arc2d>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::Arc2d::angle(&_self) - .into(); - output - } - }; - output - }, - " Get the angle of the arc", - &["_self"], - ) - .register_documented( - "apothem", - |_self: Ref<::bevy_math::primitives::Arc2d>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::Arc2d::apothem(&_self) - .into(); - output - } - }; - output - }, - " Get the length of the apothem of this arc, that is,\n the distance from the center of the circle to the midpoint of the chord, in the direction of the midpoint of the arc.\n Equivalently, the [`radius`](Self::radius) minus the [`sagitta`](Self::sagitta).\n Note that for a [`major`](Self::is_major) arc, the apothem will be negative.", - &["_self"], - ) - .register_documented( - "chord_length", - |_self: Ref<::bevy_math::primitives::Arc2d>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::Arc2d::chord_length( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the distance between the endpoints (the length of the chord)", - &["_self"], - ) - .register_documented( - "chord_midpoint", - |_self: Ref<::bevy_math::primitives::Arc2d>| { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Arc2d::chord_midpoint( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the midpoint of the two endpoints (the midpoint of the chord)", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Arc2d>| { - let output: Val<::bevy_math::primitives::Arc2d> = { - { - let output: Val<::bevy_math::primitives::Arc2d> = <::bevy_math::primitives::Arc2d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_math::primitives::Arc2d>, - other: Ref<::bevy_math::primitives::Arc2d>| - { - let output: bool = { - { - let output: bool = <::bevy_math::primitives::Arc2d as ::core::cmp::PartialEq< - ::bevy_math::primitives::Arc2d, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "from_degrees", - |radius: f32, angle: f32| { - let output: Val<::bevy_math::primitives::Arc2d> = { - { - let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::from_degrees( - radius, - angle, - ) - .into(); - output - } - }; - output - }, - " Create a new [`Arc2d`] from a `radius` and an `angle` in degrees.", - &["radius", "angle"], - ) - .register_documented( - "from_radians", - |radius: f32, angle: f32| { - let output: Val<::bevy_math::primitives::Arc2d> = { - { - let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::from_radians( - radius, - angle, - ) - .into(); - output - } - }; - output - }, - " Create a new [`Arc2d`] from a `radius` and an `angle` in radians", - &["radius", "angle"], - ) - .register_documented( - "from_turns", - |radius: f32, fraction: f32| { - let output: Val<::bevy_math::primitives::Arc2d> = { - { - let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::from_turns( - radius, - fraction, - ) - .into(); - output - } - }; - output - }, - " Create a new [`Arc2d`] from a `radius` and a `fraction` of a single turn.\n For instance, `0.5` turns is a semicircle.", - &["radius", "fraction"], - ) - .register_documented( - "half_chord_length", - |_self: Ref<::bevy_math::primitives::Arc2d>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::Arc2d::half_chord_length( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get half the distance between the endpoints (half the length of the chord)", - &["_self"], - ) - .register_documented( - "is_major", - |_self: Ref<::bevy_math::primitives::Arc2d>| { - let output: bool = { - { - let output: bool = ::bevy_math::primitives::Arc2d::is_major( - &_self, - ) - .into(); - output - } - }; - output - }, - " Produces true if the arc is at least half a circle.\n **Note:** This is not the negation of [`is_minor`](Self::is_minor): an exact semicircle is both major and minor.", - &["_self"], - ) - .register_documented( - "is_minor", - |_self: Ref<::bevy_math::primitives::Arc2d>| { - let output: bool = { - { - let output: bool = ::bevy_math::primitives::Arc2d::is_minor( - &_self, - ) - .into(); - output - } - }; - output - }, - " Produces true if the arc is at most half a circle.\n **Note:** This is not the negation of [`is_major`](Self::is_major): an exact semicircle is both major and minor.", - &["_self"], - ) - .register_documented( - "left_endpoint", - |_self: Ref<::bevy_math::primitives::Arc2d>| { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Arc2d::left_endpoint( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the left-hand end point of the arc", - &["_self"], - ) - .register_documented( - "length", - |_self: Ref<::bevy_math::primitives::Arc2d>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::Arc2d::length(&_self) - .into(); - output - } - }; - output - }, - " Get the length of the arc", - &["_self"], - ) - .register_documented( - "midpoint", - |_self: Ref<::bevy_math::primitives::Arc2d>| { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Arc2d::midpoint( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the midpoint of the arc", - &["_self"], - ) - .register_documented( - "new", - |radius: f32, half_angle: f32| { - let output: Val<::bevy_math::primitives::Arc2d> = { - { - let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::new( - radius, - half_angle, - ) - .into(); - output - } - }; - output - }, - " Create a new [`Arc2d`] from a `radius` and a `half_angle`", - &["radius", "half_angle"], - ) - .register_documented( - "right_endpoint", - |_self: Ref<::bevy_math::primitives::Arc2d>| { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Arc2d::right_endpoint( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the right-hand end point of the arc", - &["_self"], - ) - .register_documented( - "sagitta", - |_self: Ref<::bevy_math::primitives::Arc2d>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::Arc2d::sagitta(&_self) - .into(); - output - } - }; - output - }, - " Get the length of the sagitta of this arc, that is,\n the length of the line between the midpoints of the arc and its chord.\n Equivalently, the height of the triangle whose base is the chord and whose apex is the midpoint of the arc.\n The sagitta is also the sum of the [`radius`](Self::radius) and the [`apothem`](Self::apothem).", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "diameter", + |_self: Ref<::bevy_math::primitives::Circle>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::Circle::diameter(&_self).into(); + output + } + }; + output + }, + " Get the diameter of the circle", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_math::primitives::Circle>, + other: Ref<::bevy_math::primitives::Circle>| { + let output: bool = { + { + let output: bool = + <::bevy_math::primitives::Circle as ::core::cmp::PartialEq< + ::bevy_math::primitives::Circle, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "new", + |radius: f32| { + let output: Val<::bevy_math::primitives::Circle> = { + { + let output: Val<::bevy_math::primitives::Circle> = + ::bevy_math::primitives::Circle::new(radius).into(); + output + } + }; + output + }, + " Create a new [`Circle`] from a `radius`", + &["radius"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::primitives::Arc2d, + ::bevy_math::primitives::Circle, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_capsule_2_d_functions(world: &mut World) { +pub(crate) fn register_annulus_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Capsule2d, + ::bevy_math::primitives::Annulus, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_math::primitives::Capsule2d>| { - let output: Val<::bevy_math::primitives::Capsule2d> = { + |_self: Ref<::bevy_math::primitives::Annulus>| { + let output: Val<::bevy_math::primitives::Annulus> = { { - let output: Val<::bevy_math::primitives::Capsule2d> = - <::bevy_math::primitives::Capsule2d as ::core::clone::Clone>::clone(&_self) + let output: Val<::bevy_math::primitives::Annulus> = + <::bevy_math::primitives::Annulus as ::core::clone::Clone>::clone(&_self) .into(); output } @@ -4014,15 +2576,29 @@ pub(crate) fn register_capsule_2_d_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "diameter", + |_self: Ref<::bevy_math::primitives::Annulus>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::Annulus::diameter(&_self).into(); + output + } + }; + output + }, + " Get the diameter of the annulus", + &["_self"], + ) .register_documented( "eq", - |_self: Ref<::bevy_math::primitives::Capsule2d>, - other: Ref<::bevy_math::primitives::Capsule2d>| { + |_self: Ref<::bevy_math::primitives::Annulus>, + other: Ref<::bevy_math::primitives::Annulus>| { let output: bool = { { let output: bool = - <::bevy_math::primitives::Capsule2d as ::core::cmp::PartialEq< - ::bevy_math::primitives::Capsule2d, + <::bevy_math::primitives::Annulus as ::core::cmp::PartialEq< + ::bevy_math::primitives::Annulus, >>::eq(&_self, &other) .into(); output @@ -4035,120 +2611,81 @@ pub(crate) fn register_capsule_2_d_functions(world: &mut World) { ) .register_documented( "new", - |radius: f32, length: f32| { - let output: Val<::bevy_math::primitives::Capsule2d> = { + |inner_radius: f32, outer_radius: f32| { + let output: Val<::bevy_math::primitives::Annulus> = { { - let output: Val<::bevy_math::primitives::Capsule2d> = - ::bevy_math::primitives::Capsule2d::new(radius, length).into(); + let output: Val<::bevy_math::primitives::Annulus> = + ::bevy_math::primitives::Annulus::new(inner_radius, outer_radius).into(); output } }; output }, - " Create a new `Capsule2d` from a radius and length", - &["radius", "length"], + " Create a new [`Annulus`] from the radii of the inner and outer circle", + &["inner_radius", "outer_radius"], ) .register_documented( - "to_inner_rectangle", - |_self: Ref<::bevy_math::primitives::Capsule2d>| { - let output: Val<::bevy_math::primitives::Rectangle> = { + "thickness", + |_self: Ref<::bevy_math::primitives::Annulus>| { + let output: f32 = { { - let output: Val<::bevy_math::primitives::Rectangle> = - ::bevy_math::primitives::Capsule2d::to_inner_rectangle(&_self).into(); + let output: f32 = ::bevy_math::primitives::Annulus::thickness(&_self).into(); output } }; output }, - " Get the part connecting the semicircular ends of the capsule as a [`Rectangle`]", + " Get the thickness of the annulus", &["_self"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::primitives::Capsule2d, + ::bevy_math::primitives::Annulus, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_circular_sector_functions(world: &mut World) { +pub(crate) fn register_arc_2_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::CircularSector, + ::bevy_math::primitives::Arc2d, >::new(world) .register_documented( "angle", - |_self: Ref<::bevy_math::primitives::CircularSector>| { + |_self: Ref<::bevy_math::primitives::Arc2d>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::CircularSector::angle( - &_self, - ) + let output: f32 = ::bevy_math::primitives::Arc2d::angle(&_self) .into(); output } }; output }, - " Get the angle of the sector", + " Get the angle of the arc", &["_self"], ) .register_documented( "apothem", - |_self: Ref<::bevy_math::primitives::CircularSector>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::CircularSector::apothem( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the length of the apothem of this sector\n See [`Arc2d::apothem`]", - &["_self"], - ) - .register_documented( - "arc_length", - |_self: Ref<::bevy_math::primitives::CircularSector>| { + |_self: Ref<::bevy_math::primitives::Arc2d>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::CircularSector::arc_length( - &_self, - ) + let output: f32 = ::bevy_math::primitives::Arc2d::apothem(&_self) .into(); output } }; output }, - " Get the length of the arc defining the sector", + " Get the length of the apothem of this arc, that is,\n the distance from the center of the circle to the midpoint of the chord, in the direction of the midpoint of the arc.\n Equivalently, the [`radius`](Self::radius) minus the [`sagitta`](Self::sagitta).\n Note that for a [`major`](Self::is_major) arc, the apothem will be negative.", &["_self"], ) .register_documented( "chord_length", - |_self: Ref<::bevy_math::primitives::CircularSector>| { + |_self: Ref<::bevy_math::primitives::Arc2d>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::CircularSector::chord_length( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the length of the chord defined by the sector\n See [`Arc2d::chord_length`]", - &["_self"], - ) - .register_documented( - "chord_midpoint", - |_self: Ref<::bevy_math::primitives::CircularSector>| { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::CircularSector::chord_midpoint( + let output: f32 = ::bevy_math::primitives::Arc2d::chord_length( &_self, ) .into(); @@ -4157,15 +2694,15 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { }; output }, - " Get the midpoint of the chord defined by the sector\n See [`Arc2d::chord_midpoint`]", + " Get the distance between the endpoints (the length of the chord)", &["_self"], ) .register_documented( "clone", - |_self: Ref<::bevy_math::primitives::CircularSector>| { - let output: Val<::bevy_math::primitives::CircularSector> = { + |_self: Ref<::bevy_math::primitives::Arc2d>| { + let output: Val<::bevy_math::primitives::Arc2d> = { { - let output: Val<::bevy_math::primitives::CircularSector> = <::bevy_math::primitives::CircularSector as ::core::clone::Clone>::clone( + let output: Val<::bevy_math::primitives::Arc2d> = <::bevy_math::primitives::Arc2d as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -4180,13 +2717,13 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_math::primitives::CircularSector>, - other: Ref<::bevy_math::primitives::CircularSector>| + _self: Ref<::bevy_math::primitives::Arc2d>, + other: Ref<::bevy_math::primitives::Arc2d>| { let output: bool = { { - let output: bool = <::bevy_math::primitives::CircularSector as ::core::cmp::PartialEq< - ::bevy_math::primitives::CircularSector, + let output: bool = <::bevy_math::primitives::Arc2d as ::core::cmp::PartialEq< + ::bevy_math::primitives::Arc2d, >>::eq(&_self, &other) .into(); output @@ -4200,9 +2737,9 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { .register_documented( "from_degrees", |radius: f32, angle: f32| { - let output: Val<::bevy_math::primitives::CircularSector> = { + let output: Val<::bevy_math::primitives::Arc2d> = { { - let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::from_degrees( + let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::from_degrees( radius, angle, ) @@ -4212,15 +2749,15 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { }; output }, - " Create a new [`CircularSector`] from a `radius` and an `angle` in degrees.", + " Create a new [`Arc2d`] from a `radius` and an `angle` in degrees.", &["radius", "angle"], ) .register_documented( "from_radians", |radius: f32, angle: f32| { - let output: Val<::bevy_math::primitives::CircularSector> = { + let output: Val<::bevy_math::primitives::Arc2d> = { { - let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::from_radians( + let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::from_radians( radius, angle, ) @@ -4230,15 +2767,15 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { }; output }, - " Create a new [`CircularSector`] from a `radius` and an `angle` in radians.", + " Create a new [`Arc2d`] from a `radius` and an `angle` in radians", &["radius", "angle"], ) .register_documented( "from_turns", |radius: f32, fraction: f32| { - let output: Val<::bevy_math::primitives::CircularSector> = { + let output: Val<::bevy_math::primitives::Arc2d> = { { - let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::from_turns( + let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::from_turns( radius, fraction, ) @@ -4248,15 +2785,15 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { }; output }, - " Create a new [`CircularSector`] from a `radius` and a number of `turns` of a circle.\n For instance, `0.5` turns is a semicircle.", + " Create a new [`Arc2d`] from a `radius` and a `fraction` of a single turn.\n For instance, `0.5` turns is a semicircle.", &["radius", "fraction"], ) .register_documented( - "half_angle", - |_self: Ref<::bevy_math::primitives::CircularSector>| { + "half_chord_length", + |_self: Ref<::bevy_math::primitives::Arc2d>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::CircularSector::half_angle( + let output: f32 = ::bevy_math::primitives::Arc2d::half_chord_length( &_self, ) .into(); @@ -4265,15 +2802,15 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { }; output }, - " Get half the angle of the sector", + " Get half the distance between the endpoints (half the length of the chord)", &["_self"], ) .register_documented( - "half_chord_length", - |_self: Ref<::bevy_math::primitives::CircularSector>| { - let output: f32 = { + "is_major", + |_self: Ref<::bevy_math::primitives::Arc2d>| { + let output: bool = { { - let output: f32 = ::bevy_math::primitives::CircularSector::half_chord_length( + let output: bool = ::bevy_math::primitives::Arc2d::is_major( &_self, ) .into(); @@ -4282,17 +2819,16 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { }; output }, - " Get half the length of the chord defined by the sector\n See [`Arc2d::half_chord_length`]", + " Produces true if the arc is at least half a circle.\n **Note:** This is not the negation of [`is_minor`](Self::is_minor): an exact semicircle is both major and minor.", &["_self"], ) .register_documented( - "new", - |radius: f32, angle: f32| { - let output: Val<::bevy_math::primitives::CircularSector> = { + "is_minor", + |_self: Ref<::bevy_math::primitives::Arc2d>| { + let output: bool = { { - let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::new( - radius, - angle, + let output: bool = ::bevy_math::primitives::Arc2d::is_minor( + &_self, ) .into(); output @@ -4300,61 +2836,152 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { }; output }, - " Create a new [`CircularSector`] from a `radius` and an `angle`", - &["radius", "angle"], + " Produces true if the arc is at most half a circle.\n **Note:** This is not the negation of [`is_major`](Self::is_major): an exact semicircle is both major and minor.", + &["_self"], ) .register_documented( - "radius", - |_self: Ref<::bevy_math::primitives::CircularSector>| { + "length", + |_self: Ref<::bevy_math::primitives::Arc2d>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::CircularSector::radius( - &_self, - ) + let output: f32 = ::bevy_math::primitives::Arc2d::length(&_self) .into(); output } }; output }, - " Get the radius of the sector", + " Get the length of the arc", &["_self"], ) + .register_documented( + "new", + |radius: f32, half_angle: f32| { + let output: Val<::bevy_math::primitives::Arc2d> = { + { + let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::new( + radius, + half_angle, + ) + .into(); + output + } + }; + output + }, + " Create a new [`Arc2d`] from a `radius` and a `half_angle`", + &["radius", "half_angle"], + ) .register_documented( "sagitta", - |_self: Ref<::bevy_math::primitives::CircularSector>| { + |_self: Ref<::bevy_math::primitives::Arc2d>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::CircularSector::sagitta( - &_self, - ) + let output: f32 = ::bevy_math::primitives::Arc2d::sagitta(&_self) + .into(); + output + } + }; + output + }, + " Get the length of the sagitta of this arc, that is,\n the length of the line between the midpoints of the arc and its chord.\n Equivalently, the height of the triangle whose base is the chord and whose apex is the midpoint of the arc.\n The sagitta is also the sum of the [`radius`](Self::radius) and the [`apothem`](Self::apothem).", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::Arc2d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_capsule_2_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Capsule2d, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Capsule2d>| { + let output: Val<::bevy_math::primitives::Capsule2d> = { + { + let output: Val<::bevy_math::primitives::Capsule2d> = + <::bevy_math::primitives::Capsule2d as ::core::clone::Clone>::clone(&_self) .into(); - output - } - }; - output - }, - " Get the length of the sagitta of this sector\n See [`Arc2d::sagitta`]", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_math::primitives::Capsule2d>, + other: Ref<::bevy_math::primitives::Capsule2d>| { + let output: bool = { + { + let output: bool = + <::bevy_math::primitives::Capsule2d as ::core::cmp::PartialEq< + ::bevy_math::primitives::Capsule2d, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "new", + |radius: f32, length: f32| { + let output: Val<::bevy_math::primitives::Capsule2d> = { + { + let output: Val<::bevy_math::primitives::Capsule2d> = + ::bevy_math::primitives::Capsule2d::new(radius, length).into(); + output + } + }; + output + }, + " Create a new `Capsule2d` from a radius and length", + &["radius", "length"], + ) + .register_documented( + "to_inner_rectangle", + |_self: Ref<::bevy_math::primitives::Capsule2d>| { + let output: Val<::bevy_math::primitives::Rectangle> = { + { + let output: Val<::bevy_math::primitives::Rectangle> = + ::bevy_math::primitives::Capsule2d::to_inner_rectangle(&_self).into(); + output + } + }; + output + }, + " Get the part connecting the semicircular ends of the capsule as a [`Rectangle`]", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::primitives::CircularSector, + ::bevy_math::primitives::Capsule2d, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_circular_segment_functions(world: &mut World) { +pub(crate) fn register_circular_sector_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::CircularSegment, + ::bevy_math::primitives::CircularSector, >::new(world) .register_documented( "angle", - |_self: Ref<::bevy_math::primitives::CircularSegment>| { + |_self: Ref<::bevy_math::primitives::CircularSector>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::CircularSegment::angle( + let output: f32 = ::bevy_math::primitives::CircularSector::angle( &_self, ) .into(); @@ -4363,15 +2990,15 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { }; output }, - " Get the angle of the segment", + " Get the angle of the sector", &["_self"], ) .register_documented( "apothem", - |_self: Ref<::bevy_math::primitives::CircularSegment>| { + |_self: Ref<::bevy_math::primitives::CircularSector>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::CircularSegment::apothem( + let output: f32 = ::bevy_math::primitives::CircularSector::apothem( &_self, ) .into(); @@ -4380,15 +3007,15 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { }; output }, - " Get the length of the apothem of this segment,\n which is the signed distance between the segment and the center of its circle\n See [`Arc2d::apothem`]", + " Get the length of the apothem of this sector\n See [`Arc2d::apothem`]", &["_self"], ) .register_documented( "arc_length", - |_self: Ref<::bevy_math::primitives::CircularSegment>| { + |_self: Ref<::bevy_math::primitives::CircularSector>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::CircularSegment::arc_length( + let output: f32 = ::bevy_math::primitives::CircularSector::arc_length( &_self, ) .into(); @@ -4397,32 +3024,15 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { }; output }, - " Get the length of the arc defining the segment", + " Get the length of the arc defining the sector", &["_self"], ) .register_documented( "chord_length", - |_self: Ref<::bevy_math::primitives::CircularSegment>| { + |_self: Ref<::bevy_math::primitives::CircularSector>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::CircularSegment::chord_length( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the length of the segment's base, also known as its chord", - &["_self"], - ) - .register_documented( - "chord_midpoint", - |_self: Ref<::bevy_math::primitives::CircularSegment>| { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::CircularSegment::chord_midpoint( + let output: f32 = ::bevy_math::primitives::CircularSector::chord_length( &_self, ) .into(); @@ -4431,15 +3041,15 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { }; output }, - " Get the midpoint of the segment's base, also known as its chord", + " Get the length of the chord defined by the sector\n See [`Arc2d::chord_length`]", &["_self"], ) .register_documented( "clone", - |_self: Ref<::bevy_math::primitives::CircularSegment>| { - let output: Val<::bevy_math::primitives::CircularSegment> = { + |_self: Ref<::bevy_math::primitives::CircularSector>| { + let output: Val<::bevy_math::primitives::CircularSector> = { { - let output: Val<::bevy_math::primitives::CircularSegment> = <::bevy_math::primitives::CircularSegment as ::core::clone::Clone>::clone( + let output: Val<::bevy_math::primitives::CircularSector> = <::bevy_math::primitives::CircularSector as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -4454,13 +3064,13 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_math::primitives::CircularSegment>, - other: Ref<::bevy_math::primitives::CircularSegment>| + _self: Ref<::bevy_math::primitives::CircularSector>, + other: Ref<::bevy_math::primitives::CircularSector>| { let output: bool = { { - let output: bool = <::bevy_math::primitives::CircularSegment as ::core::cmp::PartialEq< - ::bevy_math::primitives::CircularSegment, + let output: bool = <::bevy_math::primitives::CircularSector as ::core::cmp::PartialEq< + ::bevy_math::primitives::CircularSector, >>::eq(&_self, &other) .into(); output @@ -4474,9 +3084,9 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { .register_documented( "from_degrees", |radius: f32, angle: f32| { - let output: Val<::bevy_math::primitives::CircularSegment> = { + let output: Val<::bevy_math::primitives::CircularSector> = { { - let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::from_degrees( + let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::from_degrees( radius, angle, ) @@ -4486,15 +3096,15 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { }; output }, - " Create a new [`CircularSegment`] from a `radius` and an `angle` in degrees.", + " Create a new [`CircularSector`] from a `radius` and an `angle` in degrees.", &["radius", "angle"], ) .register_documented( "from_radians", |radius: f32, angle: f32| { - let output: Val<::bevy_math::primitives::CircularSegment> = { + let output: Val<::bevy_math::primitives::CircularSector> = { { - let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::from_radians( + let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::from_radians( radius, angle, ) @@ -4504,15 +3114,15 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { }; output }, - " Create a new [`CircularSegment`] from a `radius` and an `angle` in radians.", + " Create a new [`CircularSector`] from a `radius` and an `angle` in radians.", &["radius", "angle"], ) .register_documented( "from_turns", |radius: f32, fraction: f32| { - let output: Val<::bevy_math::primitives::CircularSegment> = { + let output: Val<::bevy_math::primitives::CircularSector> = { { - let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::from_turns( + let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::from_turns( radius, fraction, ) @@ -4522,15 +3132,15 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { }; output }, - " Create a new [`CircularSegment`] from a `radius` and a number of `turns` of a circle.\n For instance, `0.5` turns is a semicircle.", + " Create a new [`CircularSector`] from a `radius` and a number of `turns` of a circle.\n For instance, `0.5` turns is a semicircle.", &["radius", "fraction"], ) .register_documented( "half_angle", - |_self: Ref<::bevy_math::primitives::CircularSegment>| { + |_self: Ref<::bevy_math::primitives::CircularSector>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::CircularSegment::half_angle( + let output: f32 = ::bevy_math::primitives::CircularSector::half_angle( &_self, ) .into(); @@ -4539,15 +3149,15 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { }; output }, - " Get the half-angle of the segment", + " Get half the angle of the sector", &["_self"], ) .register_documented( "half_chord_length", - |_self: Ref<::bevy_math::primitives::CircularSegment>| { + |_self: Ref<::bevy_math::primitives::CircularSector>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::CircularSegment::half_chord_length( + let output: f32 = ::bevy_math::primitives::CircularSector::half_chord_length( &_self, ) .into(); @@ -4556,15 +3166,15 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { }; output }, - " Get half the length of the segment's base, also known as its chord", + " Get half the length of the chord defined by the sector\n See [`Arc2d::half_chord_length`]", &["_self"], ) .register_documented( "new", |radius: f32, angle: f32| { - let output: Val<::bevy_math::primitives::CircularSegment> = { + let output: Val<::bevy_math::primitives::CircularSector> = { { - let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::new( + let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::new( radius, angle, ) @@ -4574,15 +3184,15 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { }; output }, - " Create a new [`CircularSegment`] from a `radius`, and an `angle`", + " Create a new [`CircularSector`] from a `radius` and an `angle`", &["radius", "angle"], ) .register_documented( "radius", - |_self: Ref<::bevy_math::primitives::CircularSegment>| { + |_self: Ref<::bevy_math::primitives::CircularSector>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::CircularSegment::radius( + let output: f32 = ::bevy_math::primitives::CircularSector::radius( &_self, ) .into(); @@ -4591,98 +3201,15 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { }; output }, - " Get the radius of the segment", + " Get the radius of the sector", &["_self"], ) .register_documented( "sagitta", - |_self: Ref<::bevy_math::primitives::CircularSegment>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::CircularSegment::sagitta( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the length of the sagitta of this segment, also known as its height\n See [`Arc2d::sagitta`]", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::primitives::CircularSegment, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_ellipse_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Ellipse, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Ellipse>| { - let output: Val<::bevy_math::primitives::Ellipse> = { - { - let output: Val<::bevy_math::primitives::Ellipse> = <::bevy_math::primitives::Ellipse as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eccentricity", - |_self: Ref<::bevy_math::primitives::Ellipse>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::Ellipse::eccentricity( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the [eccentricity](https://en.wikipedia.org/wiki/Eccentricity_(mathematics)) of the ellipse.\n It can be thought of as a measure of how \"stretched\" or elongated the ellipse is.\n The value should be in the range [0, 1), where 0 represents a circle, and 1 represents a parabola.", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_math::primitives::Ellipse>, - other: Ref<::bevy_math::primitives::Ellipse>| - { - let output: bool = { - { - let output: bool = <::bevy_math::primitives::Ellipse as ::core::cmp::PartialEq< - ::bevy_math::primitives::Ellipse, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "focal_length", - |_self: Ref<::bevy_math::primitives::Ellipse>| { + |_self: Ref<::bevy_math::primitives::CircularSector>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::Ellipse::focal_length( + let output: f32 = ::bevy_math::primitives::CircularSector::sagitta( &_self, ) .into(); @@ -4691,16 +3218,28 @@ pub(crate) fn register_ellipse_functions(world: &mut World) { }; output }, - " Get the focal length of the ellipse. This corresponds to the distance between one of the foci and the center of the ellipse.\n The focal length of an ellipse is related to its eccentricity by `eccentricity = focal_length / semi_major`", + " Get the length of the sagitta of this sector\n See [`Arc2d::sagitta`]", &["_self"], - ) + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::CircularSector, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_circular_segment_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::CircularSegment, + >::new(world) .register_documented( - "from_size", - |size: Val<::bevy_math::prelude::Vec2>| { - let output: Val<::bevy_math::primitives::Ellipse> = { + "angle", + |_self: Ref<::bevy_math::primitives::CircularSegment>| { + let output: f32 = { { - let output: Val<::bevy_math::primitives::Ellipse> = ::bevy_math::primitives::Ellipse::from_size( - size.into_inner(), + let output: f32 = ::bevy_math::primitives::CircularSegment::angle( + &_self, ) .into(); output @@ -4708,17 +3247,16 @@ pub(crate) fn register_ellipse_functions(world: &mut World) { }; output }, - " Create a new `Ellipse` from a given full size.\n `size.x` is the diameter along the X axis, and `size.y` is the diameter along the Y axis.", - &["size"], + " Get the angle of the segment", + &["_self"], ) .register_documented( - "new", - |half_width: f32, half_height: f32| { - let output: Val<::bevy_math::primitives::Ellipse> = { + "apothem", + |_self: Ref<::bevy_math::primitives::CircularSegment>| { + let output: f32 = { { - let output: Val<::bevy_math::primitives::Ellipse> = ::bevy_math::primitives::Ellipse::new( - half_width, - half_height, + let output: f32 = ::bevy_math::primitives::CircularSegment::apothem( + &_self, ) .into(); output @@ -4726,15 +3264,15 @@ pub(crate) fn register_ellipse_functions(world: &mut World) { }; output }, - " Create a new `Ellipse` from half of its width and height.\n This corresponds to the two perpendicular radii defining the ellipse.", - &["half_width", "half_height"], + " Get the length of the apothem of this segment,\n which is the signed distance between the segment and the center of its circle\n See [`Arc2d::apothem`]", + &["_self"], ) .register_documented( - "semi_major", - |_self: Ref<::bevy_math::primitives::Ellipse>| { + "arc_length", + |_self: Ref<::bevy_math::primitives::CircularSegment>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::Ellipse::semi_major( + let output: f32 = ::bevy_math::primitives::CircularSegment::arc_length( &_self, ) .into(); @@ -4743,15 +3281,15 @@ pub(crate) fn register_ellipse_functions(world: &mut World) { }; output }, - " Returns the length of the semi-major axis. This corresponds to the longest radius of the ellipse.", + " Get the length of the arc defining the segment", &["_self"], ) .register_documented( - "semi_minor", - |_self: Ref<::bevy_math::primitives::Ellipse>| { + "chord_length", + |_self: Ref<::bevy_math::primitives::CircularSegment>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::Ellipse::semi_minor( + let output: f32 = ::bevy_math::primitives::CircularSegment::chord_length( &_self, ) .into(); @@ -4760,74 +3298,15 @@ pub(crate) fn register_ellipse_functions(world: &mut World) { }; output }, - " Returns the length of the semi-minor axis. This corresponds to the shortest radius of the ellipse.", + " Get the length of the segment's base, also known as its chord", &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::primitives::Ellipse, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_line_2_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Line2d, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Line2d>| { - let output: Val<::bevy_math::primitives::Line2d> = { - { - let output: Val<::bevy_math::primitives::Line2d> = - <::bevy_math::primitives::Line2d as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::primitives::Line2d>, - other: Ref<::bevy_math::primitives::Line2d>| { - let output: bool = { - { - let output: bool = - <::bevy_math::primitives::Line2d as ::core::cmp::PartialEq< - ::bevy_math::primitives::Line2d, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::primitives::Line2d, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_plane_2_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Plane2d, - >::new(world) + ) .register_documented( "clone", - |_self: Ref<::bevy_math::primitives::Plane2d>| { - let output: Val<::bevy_math::primitives::Plane2d> = { + |_self: Ref<::bevy_math::primitives::CircularSegment>| { + let output: Val<::bevy_math::primitives::CircularSegment> = { { - let output: Val<::bevy_math::primitives::Plane2d> = <::bevy_math::primitives::Plane2d as ::core::clone::Clone>::clone( + let output: Val<::bevy_math::primitives::CircularSegment> = <::bevy_math::primitives::CircularSegment as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -4842,13 +3321,13 @@ pub(crate) fn register_plane_2_d_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_math::primitives::Plane2d>, - other: Ref<::bevy_math::primitives::Plane2d>| + _self: Ref<::bevy_math::primitives::CircularSegment>, + other: Ref<::bevy_math::primitives::CircularSegment>| { let output: bool = { { - let output: bool = <::bevy_math::primitives::Plane2d as ::core::cmp::PartialEq< - ::bevy_math::primitives::Plane2d, + let output: bool = <::bevy_math::primitives::CircularSegment as ::core::cmp::PartialEq< + ::bevy_math::primitives::CircularSegment, >>::eq(&_self, &other) .into(); output @@ -4860,41 +3339,13 @@ pub(crate) fn register_plane_2_d_functions(world: &mut World) { &["_self", "other"], ) .register_documented( - "new", - |normal: Val<::bevy_math::prelude::Vec2>| { - let output: Val<::bevy_math::primitives::Plane2d> = { - { - let output: Val<::bevy_math::primitives::Plane2d> = ::bevy_math::primitives::Plane2d::new( - normal.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a new `Plane2d` from a normal\n # Panics\n Panics if the given `normal` is zero (or very close to zero), or non-finite.", - &["normal"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::primitives::Plane2d, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_rectangle_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Rectangle, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Rectangle>| { - let output: Val<::bevy_math::primitives::Rectangle> = { + "from_degrees", + |radius: f32, angle: f32| { + let output: Val<::bevy_math::primitives::CircularSegment> = { { - let output: Val<::bevy_math::primitives::Rectangle> = <::bevy_math::primitives::Rectangle as ::core::clone::Clone>::clone( - &_self, + let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::from_degrees( + radius, + angle, ) .into(); output @@ -4902,20 +3353,17 @@ pub(crate) fn register_rectangle_functions(world: &mut World) { }; output }, - "", - &["_self"], + " Create a new [`CircularSegment`] from a `radius` and an `angle` in degrees.", + &["radius", "angle"], ) .register_documented( - "closest_point", - | - _self: Ref<::bevy_math::primitives::Rectangle>, - point: Val<::bevy_math::prelude::Vec2>| - { - let output: Val<::bevy_math::prelude::Vec2> = { + "from_radians", + |radius: f32, angle: f32| { + let output: Val<::bevy_math::primitives::CircularSegment> = { { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Rectangle::closest_point( - &_self, - point.into_inner(), + let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::from_radians( + radius, + angle, ) .into(); output @@ -4923,40 +3371,34 @@ pub(crate) fn register_rectangle_functions(world: &mut World) { }; output }, - " Finds the point on the rectangle that is closest to the given `point`.\n If the point is outside the rectangle, the returned point will be on the perimeter of the rectangle.\n Otherwise, it will be inside the rectangle and returned as is.", - &["_self", "point"], + " Create a new [`CircularSegment`] from a `radius` and an `angle` in radians.", + &["radius", "angle"], ) .register_documented( - "eq", - | - _self: Ref<::bevy_math::primitives::Rectangle>, - other: Ref<::bevy_math::primitives::Rectangle>| - { - let output: bool = { + "from_turns", + |radius: f32, fraction: f32| { + let output: Val<::bevy_math::primitives::CircularSegment> = { { - let output: bool = <::bevy_math::primitives::Rectangle as ::core::cmp::PartialEq< - ::bevy_math::primitives::Rectangle, - >>::eq(&_self, &other) + let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::from_turns( + radius, + fraction, + ) .into(); output } }; output }, - "", - &["_self", "other"], + " Create a new [`CircularSegment`] from a `radius` and a number of `turns` of a circle.\n For instance, `0.5` turns is a semicircle.", + &["radius", "fraction"], ) .register_documented( - "from_corners", - | - point1: Val<::bevy_math::prelude::Vec2>, - point2: Val<::bevy_math::prelude::Vec2>| - { - let output: Val<::bevy_math::primitives::Rectangle> = { + "half_angle", + |_self: Ref<::bevy_math::primitives::CircularSegment>| { + let output: f32 = { { - let output: Val<::bevy_math::primitives::Rectangle> = ::bevy_math::primitives::Rectangle::from_corners( - point1.into_inner(), - point2.into_inner(), + let output: f32 = ::bevy_math::primitives::CircularSegment::half_angle( + &_self, ) .into(); output @@ -4964,16 +3406,16 @@ pub(crate) fn register_rectangle_functions(world: &mut World) { }; output }, - " Create a new `Rectangle` from two corner points", - &["point1", "point2"], + " Get the half-angle of the segment", + &["_self"], ) .register_documented( - "from_length", - |length: f32| { - let output: Val<::bevy_math::primitives::Rectangle> = { + "half_chord_length", + |_self: Ref<::bevy_math::primitives::CircularSegment>| { + let output: f32 = { { - let output: Val<::bevy_math::primitives::Rectangle> = ::bevy_math::primitives::Rectangle::from_length( - length, + let output: f32 = ::bevy_math::primitives::CircularSegment::half_chord_length( + &_self, ) .into(); output @@ -4981,16 +3423,17 @@ pub(crate) fn register_rectangle_functions(world: &mut World) { }; output }, - " Create a `Rectangle` from a single length.\n The resulting `Rectangle` will be the same size in every direction.", - &["length"], + " Get half the length of the segment's base, also known as its chord", + &["_self"], ) .register_documented( - "from_size", - |size: Val<::bevy_math::prelude::Vec2>| { - let output: Val<::bevy_math::primitives::Rectangle> = { + "new", + |radius: f32, angle: f32| { + let output: Val<::bevy_math::primitives::CircularSegment> = { { - let output: Val<::bevy_math::primitives::Rectangle> = ::bevy_math::primitives::Rectangle::from_size( - size.into_inner(), + let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::new( + radius, + angle, ) .into(); output @@ -4998,17 +3441,16 @@ pub(crate) fn register_rectangle_functions(world: &mut World) { }; output }, - " Create a new `Rectangle` from a given full size", - &["size"], + " Create a new [`CircularSegment`] from a `radius`, and an `angle`", + &["radius", "angle"], ) .register_documented( - "new", - |width: f32, height: f32| { - let output: Val<::bevy_math::primitives::Rectangle> = { + "radius", + |_self: Ref<::bevy_math::primitives::CircularSegment>| { + let output: f32 = { { - let output: Val<::bevy_math::primitives::Rectangle> = ::bevy_math::primitives::Rectangle::new( - width, - height, + let output: f32 = ::bevy_math::primitives::CircularSegment::radius( + &_self, ) .into(); output @@ -5016,15 +3458,15 @@ pub(crate) fn register_rectangle_functions(world: &mut World) { }; output }, - " Create a new `Rectangle` from a full width and height", - &["width", "height"], + " Get the radius of the segment", + &["_self"], ) .register_documented( - "size", - |_self: Ref<::bevy_math::primitives::Rectangle>| { - let output: Val<::bevy_math::prelude::Vec2> = { + "sagitta", + |_self: Ref<::bevy_math::primitives::CircularSegment>| { + let output: f32 = { { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Rectangle::size( + let output: f32 = ::bevy_math::primitives::CircularSegment::sagitta( &_self, ) .into(); @@ -5033,27 +3475,27 @@ pub(crate) fn register_rectangle_functions(world: &mut World) { }; output }, - " Get the size of the rectangle", + " Get the length of the sagitta of this segment, also known as its height\n See [`Arc2d::sagitta`]", &["_self"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::primitives::Rectangle, + ::bevy_math::primitives::CircularSegment, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_regular_polygon_functions(world: &mut World) { +pub(crate) fn register_ellipse_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::RegularPolygon, + ::bevy_math::primitives::Ellipse, >::new(world) .register_documented( - "circumradius", - |_self: Ref<::bevy_math::primitives::RegularPolygon>| { - let output: f32 = { + "clone", + |_self: Ref<::bevy_math::primitives::Ellipse>| { + let output: Val<::bevy_math::primitives::Ellipse> = { { - let output: f32 = ::bevy_math::primitives::RegularPolygon::circumradius( + let output: Val<::bevy_math::primitives::Ellipse> = <::bevy_math::primitives::Ellipse as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -5062,15 +3504,15 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { }; output }, - " Get the radius of the circumcircle on which all vertices\n of the regular polygon lie", + "", &["_self"], ) .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::RegularPolygon>| { - let output: Val<::bevy_math::primitives::RegularPolygon> = { + "eccentricity", + |_self: Ref<::bevy_math::primitives::Ellipse>| { + let output: f32 = { { - let output: Val<::bevy_math::primitives::RegularPolygon> = <::bevy_math::primitives::RegularPolygon as ::core::clone::Clone>::clone( + let output: f32 = ::bevy_math::primitives::Ellipse::eccentricity( &_self, ) .into(); @@ -5079,19 +3521,19 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { }; output }, - "", + " Returns the [eccentricity](https://en.wikipedia.org/wiki/Eccentricity_(mathematics)) of the ellipse.\n It can be thought of as a measure of how \"stretched\" or elongated the ellipse is.\n The value should be in the range [0, 1), where 0 represents a circle, and 1 represents a parabola.", &["_self"], ) .register_documented( "eq", | - _self: Ref<::bevy_math::primitives::RegularPolygon>, - other: Ref<::bevy_math::primitives::RegularPolygon>| + _self: Ref<::bevy_math::primitives::Ellipse>, + other: Ref<::bevy_math::primitives::Ellipse>| { let output: bool = { { - let output: bool = <::bevy_math::primitives::RegularPolygon as ::core::cmp::PartialEq< - ::bevy_math::primitives::RegularPolygon, + let output: bool = <::bevy_math::primitives::Ellipse as ::core::cmp::PartialEq< + ::bevy_math::primitives::Ellipse, >>::eq(&_self, &other) .into(); output @@ -5103,11 +3545,11 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { &["_self", "other"], ) .register_documented( - "external_angle_degrees", - |_self: Ref<::bevy_math::primitives::RegularPolygon>| { + "focal_length", + |_self: Ref<::bevy_math::primitives::Ellipse>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::RegularPolygon::external_angle_degrees( + let output: f32 = ::bevy_math::primitives::Ellipse::focal_length( &_self, ) .into(); @@ -5116,16 +3558,17 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { }; output }, - " Get the external angle of the regular polygon in degrees.\n This is the angle formed by two adjacent sides with points\n within the angle being in the exterior of the polygon", + " Get the focal length of the ellipse. This corresponds to the distance between one of the foci and the center of the ellipse.\n The focal length of an ellipse is related to its eccentricity by `eccentricity = focal_length / semi_major`", &["_self"], ) .register_documented( - "external_angle_radians", - |_self: Ref<::bevy_math::primitives::RegularPolygon>| { - let output: f32 = { + "new", + |half_width: f32, half_height: f32| { + let output: Val<::bevy_math::primitives::Ellipse> = { { - let output: f32 = ::bevy_math::primitives::RegularPolygon::external_angle_radians( - &_self, + let output: Val<::bevy_math::primitives::Ellipse> = ::bevy_math::primitives::Ellipse::new( + half_width, + half_height, ) .into(); output @@ -5133,15 +3576,15 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { }; output }, - " Get the external angle of the regular polygon in radians.\n This is the angle formed by two adjacent sides with points\n within the angle being in the exterior of the polygon", - &["_self"], + " Create a new `Ellipse` from half of its width and height.\n This corresponds to the two perpendicular radii defining the ellipse.", + &["half_width", "half_height"], ) .register_documented( - "inradius", - |_self: Ref<::bevy_math::primitives::RegularPolygon>| { + "semi_major", + |_self: Ref<::bevy_math::primitives::Ellipse>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::RegularPolygon::inradius( + let output: f32 = ::bevy_math::primitives::Ellipse::semi_major( &_self, ) .into(); @@ -5150,15 +3593,15 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { }; output }, - " Get the inradius or apothem of the regular polygon.\n This is the radius of the largest circle that can\n be drawn within the polygon", + " Returns the length of the semi-major axis. This corresponds to the longest radius of the ellipse.", &["_self"], ) .register_documented( - "internal_angle_degrees", - |_self: Ref<::bevy_math::primitives::RegularPolygon>| { + "semi_minor", + |_self: Ref<::bevy_math::primitives::Ellipse>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::RegularPolygon::internal_angle_degrees( + let output: f32 = ::bevy_math::primitives::Ellipse::semi_minor( &_self, ) .into(); @@ -5167,15 +3610,121 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { }; output }, - " Get the internal angle of the regular polygon in degrees.\n This is the angle formed by two adjacent sides with points\n within the angle being in the interior of the polygon", + " Returns the length of the semi-minor axis. This corresponds to the shortest radius of the ellipse.", &["_self"], - ) + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::Ellipse, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_line_2_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Line2d, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Line2d>| { + let output: Val<::bevy_math::primitives::Line2d> = { + { + let output: Val<::bevy_math::primitives::Line2d> = + <::bevy_math::primitives::Line2d as ::core::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_math::primitives::Line2d>, + other: Ref<::bevy_math::primitives::Line2d>| { + let output: bool = { + { + let output: bool = + <::bevy_math::primitives::Line2d as ::core::cmp::PartialEq< + ::bevy_math::primitives::Line2d, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::Line2d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_plane_2_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Plane2d, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Plane2d>| { + let output: Val<::bevy_math::primitives::Plane2d> = { + { + let output: Val<::bevy_math::primitives::Plane2d> = + <::bevy_math::primitives::Plane2d as ::core::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_math::primitives::Plane2d>, + other: Ref<::bevy_math::primitives::Plane2d>| { + let output: bool = { + { + let output: bool = + <::bevy_math::primitives::Plane2d as ::core::cmp::PartialEq< + ::bevy_math::primitives::Plane2d, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::Plane2d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_rectangle_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Rectangle, + >::new(world) .register_documented( - "internal_angle_radians", - |_self: Ref<::bevy_math::primitives::RegularPolygon>| { - let output: f32 = { + "clone", + |_self: Ref<::bevy_math::primitives::Rectangle>| { + let output: Val<::bevy_math::primitives::Rectangle> = { { - let output: f32 = ::bevy_math::primitives::RegularPolygon::internal_angle_radians( + let output: Val<::bevy_math::primitives::Rectangle> = <::bevy_math::primitives::Rectangle as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -5184,17 +3733,36 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { }; output }, - " Get the internal angle of the regular polygon in radians.\n This is the angle formed by two adjacent sides with points\n within the angle being in the interior of the polygon", + "", &["_self"], ) .register_documented( - "new", - |circumradius: f32, sides: u32| { - let output: Val<::bevy_math::primitives::RegularPolygon> = { + "eq", + | + _self: Ref<::bevy_math::primitives::Rectangle>, + other: Ref<::bevy_math::primitives::Rectangle>| + { + let output: bool = { { - let output: Val<::bevy_math::primitives::RegularPolygon> = ::bevy_math::primitives::RegularPolygon::new( - circumradius, - sides, + let output: bool = <::bevy_math::primitives::Rectangle as ::core::cmp::PartialEq< + ::bevy_math::primitives::Rectangle, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "from_length", + |length: f32| { + let output: Val<::bevy_math::primitives::Rectangle> = { + { + let output: Val<::bevy_math::primitives::Rectangle> = ::bevy_math::primitives::Rectangle::from_length( + length, ) .into(); output @@ -5202,16 +3770,17 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { }; output }, - " Create a new `RegularPolygon`\n from the radius of the circumcircle and a number of sides\n # Panics\n Panics if `circumradius` is negative", - &["circumradius", "sides"], + " Create a `Rectangle` from a single length.\n The resulting `Rectangle` will be the same size in every direction.", + &["length"], ) .register_documented( - "side_length", - |_self: Ref<::bevy_math::primitives::RegularPolygon>| { - let output: f32 = { + "new", + |width: f32, height: f32| { + let output: Val<::bevy_math::primitives::Rectangle> = { { - let output: f32 = ::bevy_math::primitives::RegularPolygon::side_length( - &_self, + let output: Val<::bevy_math::primitives::Rectangle> = ::bevy_math::primitives::Rectangle::new( + width, + height, ) .into(); output @@ -5219,27 +3788,27 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { }; output }, - " Get the length of one side of the regular polygon", - &["_self"], + " Create a new `Rectangle` from a full width and height", + &["width", "height"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::primitives::RegularPolygon, + ::bevy_math::primitives::Rectangle, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_rhombus_functions(world: &mut World) { +pub(crate) fn register_regular_polygon_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Rhombus, + ::bevy_math::primitives::RegularPolygon, >::new(world) .register_documented( "circumradius", - |_self: Ref<::bevy_math::primitives::Rhombus>| { + |_self: Ref<::bevy_math::primitives::RegularPolygon>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::Rhombus::circumradius( + let output: f32 = ::bevy_math::primitives::RegularPolygon::circumradius( &_self, ) .into(); @@ -5248,17 +3817,37 @@ pub(crate) fn register_rhombus_functions(world: &mut World) { }; output }, - " Get the radius of the circumcircle on which all vertices\n of the rhombus lie", + " Get the radius of the circumcircle on which all vertices\n of the regular polygon lie", &["_self"], ) .register_documented( "clone", - |_self: Ref<::bevy_math::primitives::Rhombus>| { - let output: Val<::bevy_math::primitives::Rhombus> = { + |_self: Ref<::bevy_math::primitives::RegularPolygon>| { + let output: Val<::bevy_math::primitives::RegularPolygon> = { + { + let output: Val<::bevy_math::primitives::RegularPolygon> = <::bevy_math::primitives::RegularPolygon as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::primitives::RegularPolygon>, + other: Ref<::bevy_math::primitives::RegularPolygon>| + { + let output: bool = { { - let output: Val<::bevy_math::primitives::Rhombus> = <::bevy_math::primitives::Rhombus as ::core::clone::Clone>::clone( - &_self, - ) + let output: bool = <::bevy_math::primitives::RegularPolygon as ::core::cmp::PartialEq< + ::bevy_math::primitives::RegularPolygon, + >>::eq(&_self, &other) .into(); output } @@ -5266,19 +3855,15 @@ pub(crate) fn register_rhombus_functions(world: &mut World) { output }, "", - &["_self"], + &["_self", "other"], ) .register_documented( - "closest_point", - | - _self: Ref<::bevy_math::primitives::Rhombus>, - point: Val<::bevy_math::prelude::Vec2>| - { - let output: Val<::bevy_math::prelude::Vec2> = { + "external_angle_degrees", + |_self: Ref<::bevy_math::primitives::RegularPolygon>| { + let output: f32 = { { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Rhombus::closest_point( + let output: f32 = ::bevy_math::primitives::RegularPolygon::external_angle_degrees( &_self, - point.into_inner(), ) .into(); output @@ -5286,36 +3871,33 @@ pub(crate) fn register_rhombus_functions(world: &mut World) { }; output }, - " Finds the point on the rhombus that is closest to the given `point`.\n If the point is outside the rhombus, the returned point will be on the perimeter of the rhombus.\n Otherwise, it will be inside the rhombus and returned as is.", - &["_self", "point"], + " Get the external angle of the regular polygon in degrees.\n This is the angle formed by two adjacent sides with points\n within the angle being in the exterior of the polygon", + &["_self"], ) .register_documented( - "eq", - | - _self: Ref<::bevy_math::primitives::Rhombus>, - other: Ref<::bevy_math::primitives::Rhombus>| - { - let output: bool = { + "external_angle_radians", + |_self: Ref<::bevy_math::primitives::RegularPolygon>| { + let output: f32 = { { - let output: bool = <::bevy_math::primitives::Rhombus as ::core::cmp::PartialEq< - ::bevy_math::primitives::Rhombus, - >>::eq(&_self, &other) + let output: f32 = ::bevy_math::primitives::RegularPolygon::external_angle_radians( + &_self, + ) .into(); output } }; output }, - "", - &["_self", "other"], + " Get the external angle of the regular polygon in radians.\n This is the angle formed by two adjacent sides with points\n within the angle being in the exterior of the polygon", + &["_self"], ) .register_documented( - "from_inradius", - |inradius: f32| { - let output: Val<::bevy_math::primitives::Rhombus> = { + "inradius", + |_self: Ref<::bevy_math::primitives::RegularPolygon>| { + let output: f32 = { { - let output: Val<::bevy_math::primitives::Rhombus> = ::bevy_math::primitives::Rhombus::from_inradius( - inradius, + let output: f32 = ::bevy_math::primitives::RegularPolygon::inradius( + &_self, ) .into(); output @@ -5323,16 +3905,16 @@ pub(crate) fn register_rhombus_functions(world: &mut World) { }; output }, - " Create a new `Rhombus` from a given inradius with all inner angles equal.", - &["inradius"], + " Get the inradius or apothem of the regular polygon.\n This is the radius of the largest circle that can\n be drawn within the polygon", + &["_self"], ) .register_documented( - "from_side", - |side: f32| { - let output: Val<::bevy_math::primitives::Rhombus> = { + "internal_angle_degrees", + |_self: Ref<::bevy_math::primitives::RegularPolygon>| { + let output: f32 = { { - let output: Val<::bevy_math::primitives::Rhombus> = ::bevy_math::primitives::Rhombus::from_side( - side, + let output: f32 = ::bevy_math::primitives::RegularPolygon::internal_angle_degrees( + &_self, ) .into(); output @@ -5340,15 +3922,15 @@ pub(crate) fn register_rhombus_functions(world: &mut World) { }; output }, - " Create a new `Rhombus` from a side length with all inner angles equal.", - &["side"], + " Get the internal angle of the regular polygon in degrees.\n This is the angle formed by two adjacent sides with points\n within the angle being in the interior of the polygon", + &["_self"], ) .register_documented( - "inradius", - |_self: Ref<::bevy_math::primitives::Rhombus>| { + "internal_angle_radians", + |_self: Ref<::bevy_math::primitives::RegularPolygon>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::Rhombus::inradius( + let output: f32 = ::bevy_math::primitives::RegularPolygon::internal_angle_radians( &_self, ) .into(); @@ -5357,17 +3939,17 @@ pub(crate) fn register_rhombus_functions(world: &mut World) { }; output }, - " Get the radius of the largest circle that can\n be drawn within the rhombus", + " Get the internal angle of the regular polygon in radians.\n This is the angle formed by two adjacent sides with points\n within the angle being in the interior of the polygon", &["_self"], ) .register_documented( "new", - |horizontal_diagonal: f32, vertical_diagonal: f32| { - let output: Val<::bevy_math::primitives::Rhombus> = { + |circumradius: f32, sides: u32| { + let output: Val<::bevy_math::primitives::RegularPolygon> = { { - let output: Val<::bevy_math::primitives::Rhombus> = ::bevy_math::primitives::Rhombus::new( - horizontal_diagonal, - vertical_diagonal, + let output: Val<::bevy_math::primitives::RegularPolygon> = ::bevy_math::primitives::RegularPolygon::new( + circumradius, + sides, ) .into(); output @@ -5375,26 +3957,166 @@ pub(crate) fn register_rhombus_functions(world: &mut World) { }; output }, - " Create a new `Rhombus` from a vertical and horizontal diagonal sizes.", - &["horizontal_diagonal", "vertical_diagonal"], + " Create a new `RegularPolygon`\n from the radius of the circumcircle and a number of sides\n # Panics\n Panics if `circumradius` is negative", + &["circumradius", "sides"], ) .register_documented( - "side", - |_self: Ref<::bevy_math::primitives::Rhombus>| { + "side_length", + |_self: Ref<::bevy_math::primitives::RegularPolygon>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::Rhombus::side(&_self) + let output: f32 = ::bevy_math::primitives::RegularPolygon::side_length( + &_self, + ) .into(); output } }; output }, - " Get the length of each side of the rhombus", + " Get the length of one side of the regular polygon", &["_self"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::RegularPolygon, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_rhombus_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Rhombus, + >::new(world) + .register_documented( + "circumradius", + |_self: Ref<::bevy_math::primitives::Rhombus>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::Rhombus::circumradius(&_self).into(); + output + } + }; + output + }, + " Get the radius of the circumcircle on which all vertices\n of the rhombus lie", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Rhombus>| { + let output: Val<::bevy_math::primitives::Rhombus> = { + { + let output: Val<::bevy_math::primitives::Rhombus> = + <::bevy_math::primitives::Rhombus as ::core::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_math::primitives::Rhombus>, + other: Ref<::bevy_math::primitives::Rhombus>| { + let output: bool = { + { + let output: bool = + <::bevy_math::primitives::Rhombus as ::core::cmp::PartialEq< + ::bevy_math::primitives::Rhombus, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "from_inradius", + |inradius: f32| { + let output: Val<::bevy_math::primitives::Rhombus> = { + { + let output: Val<::bevy_math::primitives::Rhombus> = + ::bevy_math::primitives::Rhombus::from_inradius(inradius).into(); + output + } + }; + output + }, + " Create a new `Rhombus` from a given inradius with all inner angles equal.", + &["inradius"], + ) + .register_documented( + "from_side", + |side: f32| { + let output: Val<::bevy_math::primitives::Rhombus> = { + { + let output: Val<::bevy_math::primitives::Rhombus> = + ::bevy_math::primitives::Rhombus::from_side(side).into(); + output + } + }; + output + }, + " Create a new `Rhombus` from a side length with all inner angles equal.", + &["side"], + ) + .register_documented( + "inradius", + |_self: Ref<::bevy_math::primitives::Rhombus>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::Rhombus::inradius(&_self).into(); + output + } + }; + output + }, + " Get the radius of the largest circle that can\n be drawn within the rhombus", + &["_self"], + ) + .register_documented( + "new", + |horizontal_diagonal: f32, vertical_diagonal: f32| { + let output: Val<::bevy_math::primitives::Rhombus> = { + { + let output: Val<::bevy_math::primitives::Rhombus> = + ::bevy_math::primitives::Rhombus::new( + horizontal_diagonal, + vertical_diagonal, + ) + .into(); + output + } + }; + output + }, + " Create a new `Rhombus` from a vertical and horizontal diagonal sizes.", + &["horizontal_diagonal", "vertical_diagonal"], + ) + .register_documented( + "side", + |_self: Ref<::bevy_math::primitives::Rhombus>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::Rhombus::side(&_self).into(); + output + } + }; + output + }, + " Get the length of each side of the rhombus", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); registry .register_type_data::< ::bevy_math::primitives::Rhombus, @@ -5405,23 +4127,6 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_math::primitives::Segment2d, >::new(world) - .register_documented( - "center", - |_self: Ref<::bevy_math::primitives::Segment2d>| { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Segment2d::center( - &_self, - ) - .into(); - output - } - }; - output - }, - " Compute the midpoint between the two endpoints of the line segment.", - &["_self"], - ) .register_documented( "centered", |_self: Ref<::bevy_math::primitives::Segment2d>| { @@ -5456,27 +4161,6 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { "", &["_self"], ) - .register_documented( - "closest_point", - | - _self: Ref<::bevy_math::primitives::Segment2d>, - point: Val<::bevy_math::prelude::Vec2>| - { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Segment2d::closest_point( - &_self, - point.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Returns the point on the [`Segment2d`] that is closest to the specified `point`.", - &["_self", "point"], - ) .register_documented( "direction", |_self: Ref<::bevy_math::primitives::Segment2d>| { @@ -5533,81 +4217,13 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { &["direction", "length"], ) .register_documented( - "from_ray_and_length", - |ray: Val<::bevy_math::Ray2d>, length: f32| { - let output: Val<::bevy_math::primitives::Segment2d> = { - { - let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::from_ray_and_length( - ray.into_inner(), - length, - ) - .into(); - output - } - }; - output - }, - " Create a new `Segment2d` starting from the origin of the given `ray`,\n going in the direction of the ray for the given `length`.\n The endpoints will be at `ray.origin` and `ray.origin + length * ray.direction`.", - &["ray", "length"], - ) - .register_documented( - "from_scaled_direction", - |scaled_direction: Val<::bevy_math::prelude::Vec2>| { - let output: Val<::bevy_math::primitives::Segment2d> = { - { - let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::from_scaled_direction( - scaled_direction.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a new `Segment2d` centered at the origin from a vector representing\n the direction and length of the line segment.\n The endpoints will be at `-scaled_direction / 2.0` and `scaled_direction / 2.0`.", - &["scaled_direction"], - ) - .register_documented( - "left_normal", - |_self: Ref<::bevy_math::primitives::Segment2d>| { - let output: Val<::bevy_math::prelude::Dir2> = { - { - let output: Val<::bevy_math::prelude::Dir2> = ::bevy_math::primitives::Segment2d::left_normal( - &_self, - ) - .into(); - output - } - }; - output - }, - " Compute the normalized counterclockwise normal on the left-hand side of the line segment.\n For the non-panicking version, see [`Segment2d::try_left_normal`].\n # Panics\n Panics if a valid normal could not be computed, for example when the endpoints are coincident, NaN, or infinite.", - &["_self"], - ) - .register_documented( - "length", - |_self: Ref<::bevy_math::primitives::Segment2d>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::Segment2d::length( - &_self, - ) - .into(); - output - } - }; - output - }, - " Compute the length of the line segment.", - &["_self"], - ) - .register_documented( - "length_squared", - |_self: Ref<::bevy_math::primitives::Segment2d>| { - let output: f32 = { + "from_ray_and_length", + |ray: Val<::bevy_math::Ray2d>, length: f32| { + let output: Val<::bevy_math::primitives::Segment2d> = { { - let output: f32 = ::bevy_math::primitives::Segment2d::length_squared( - &_self, + let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::from_ray_and_length( + ray.into_inner(), + length, ) .into(); output @@ -5615,20 +4231,16 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { }; output }, - " Compute the squared length of the line segment.", - &["_self"], + " Create a new `Segment2d` starting from the origin of the given `ray`,\n going in the direction of the ray for the given `length`.\n The endpoints will be at `ray.origin` and `ray.origin + length * ray.direction`.", + &["ray", "length"], ) .register_documented( - "new", - | - point1: Val<::bevy_math::prelude::Vec2>, - point2: Val<::bevy_math::prelude::Vec2>| - { - let output: Val<::bevy_math::primitives::Segment2d> = { + "left_normal", + |_self: Ref<::bevy_math::primitives::Segment2d>| { + let output: Val<::bevy_math::prelude::Dir2> = { { - let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::new( - point1.into_inner(), - point2.into_inner(), + let output: Val<::bevy_math::prelude::Dir2> = ::bevy_math::primitives::Segment2d::left_normal( + &_self, ) .into(); output @@ -5636,15 +4248,15 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { }; output }, - " Create a new `Segment2d` from its endpoints.", - &["point1", "point2"], + " Compute the normalized counterclockwise normal on the left-hand side of the line segment.\n For the non-panicking version, see [`Segment2d::try_left_normal`].\n # Panics\n Panics if a valid normal could not be computed, for example when the endpoints are coincident, NaN, or infinite.", + &["_self"], ) .register_documented( - "point1", + "length", |_self: Ref<::bevy_math::primitives::Segment2d>| { - let output: Val<::bevy_math::prelude::Vec2> = { + let output: f32 = { { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Segment2d::point1( + let output: f32 = ::bevy_math::primitives::Segment2d::length( &_self, ) .into(); @@ -5653,15 +4265,15 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { }; output }, - " Get the position of the first endpoint of the line segment.", + " Compute the length of the line segment.", &["_self"], ) .register_documented( - "point2", + "length_squared", |_self: Ref<::bevy_math::primitives::Segment2d>| { - let output: Val<::bevy_math::prelude::Vec2> = { + let output: f32 = { { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Segment2d::point2( + let output: f32 = ::bevy_math::primitives::Segment2d::length_squared( &_self, ) .into(); @@ -5670,7 +4282,7 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { }; output }, - " Get the position of the second endpoint of the line segment.", + " Compute the squared length of the line segment.", &["_self"], ) .register_documented( @@ -5763,29 +4375,6 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { " Compute the segment rotated around the origin by the given rotation.", &["_self", "rotation"], ) - .register_documented( - "rotated_around", - | - _self: Ref<::bevy_math::primitives::Segment2d>, - rotation: Val<::bevy_math::Rot2>, - point: Val<::bevy_math::prelude::Vec2>| - { - let output: Val<::bevy_math::primitives::Segment2d> = { - { - let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::rotated_around( - &_self, - rotation.into_inner(), - point.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Compute the segment rotated around the given point by the given rotation.", - &["_self", "rotation", "point"], - ) .register_documented( "rotated_around_center", | @@ -5806,78 +4395,6 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { }, " Compute the segment rotated around its own center.", &["_self", "rotation"], - ) - .register_documented( - "scaled_direction", - |_self: Ref<::bevy_math::primitives::Segment2d>| { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Segment2d::scaled_direction( - &_self, - ) - .into(); - output - } - }; - output - }, - " Compute the vector from the first endpoint to the second endpoint.", - &["_self"], - ) - .register_documented( - "scaled_left_normal", - |_self: Ref<::bevy_math::primitives::Segment2d>| { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Segment2d::scaled_left_normal( - &_self, - ) - .into(); - output - } - }; - output - }, - " Compute the non-normalized counterclockwise normal on the left-hand side of the line segment.\n The length of the normal is the distance between the endpoints.", - &["_self"], - ) - .register_documented( - "scaled_right_normal", - |_self: Ref<::bevy_math::primitives::Segment2d>| { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Segment2d::scaled_right_normal( - &_self, - ) - .into(); - output - } - }; - output - }, - " Compute the non-normalized clockwise normal on the right-hand side of the line segment.\n The length of the normal is the distance between the endpoints.", - &["_self"], - ) - .register_documented( - "translated", - | - _self: Ref<::bevy_math::primitives::Segment2d>, - translation: Val<::bevy_math::prelude::Vec2>| - { - let output: Val<::bevy_math::primitives::Segment2d> = { - { - let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::translated( - &_self, - translation.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Compute the segment translated by the given vector.", - &["_self", "translation"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -5979,29 +4496,6 @@ pub(crate) fn register_triangle_2_d_functions(world: &mut World) { " Checks if the triangle is obtuse, meaning one angle is greater than 90 degrees", &["_self"], ) - .register_documented( - "new", - | - a: Val<::bevy_math::prelude::Vec2>, - b: Val<::bevy_math::prelude::Vec2>, - c: Val<::bevy_math::prelude::Vec2>| - { - let output: Val<::bevy_math::primitives::Triangle2d> = { - { - let output: Val<::bevy_math::primitives::Triangle2d> = ::bevy_math::primitives::Triangle2d::new( - a.into_inner(), - b.into_inner(), - c.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a new `Triangle2d` from points `a`, `b`, and `c`", - &["a", "b", "c"], - ) .register_documented( "reverse", |mut _self: Mut<::bevy_math::primitives::Triangle2d>| { @@ -6163,66 +4657,43 @@ pub(crate) fn register_polyline_2_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_math::primitives::Polyline2d, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Polyline2d>| { - let output: Val<::bevy_math::primitives::Polyline2d> = { - { - let output: Val<::bevy_math::primitives::Polyline2d> = <::bevy_math::primitives::Polyline2d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_math::primitives::Polyline2d>, - other: Ref<::bevy_math::primitives::Polyline2d>| - { - let output: bool = { - { - let output: bool = <::bevy_math::primitives::Polyline2d as ::core::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Polyline2d>| { + let output: Val<::bevy_math::primitives::Polyline2d> = { + { + let output: Val<::bevy_math::primitives::Polyline2d> = + <::bevy_math::primitives::Polyline2d as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_math::primitives::Polyline2d>, + other: Ref<::bevy_math::primitives::Polyline2d>| { + let output: bool = { + { + let output: bool = + <::bevy_math::primitives::Polyline2d as ::core::cmp::PartialEq< ::bevy_math::primitives::Polyline2d, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "with_subdivisions", - | - start: Val<::bevy_math::prelude::Vec2>, - end: Val<::bevy_math::prelude::Vec2>, - subdivisions: usize| - { - let output: Val<::bevy_math::primitives::Polyline2d> = { - { - let output: Val<::bevy_math::primitives::Polyline2d> = ::bevy_math::primitives::Polyline2d::with_subdivisions( - start.into_inner(), - end.into_inner(), - subdivisions, - ) - .into(); - output - } - }; - output - }, - " Create a new `Polyline2d` from two endpoints with subdivision points.\n `subdivisions = 0` creates a simple line with just start and end points.\n `subdivisions = 1` adds one point in the middle, creating 2 segments, etc.", - &["start", "end", "subdivisions"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -6315,28 +4786,103 @@ pub(crate) fn register_bounding_sphere_functions(world: &mut World) { |_self: Ref<::bevy_math::bounding::BoundingSphere>| { let output: Val<::bevy_math::bounding::BoundingSphere> = { { - let output: Val<::bevy_math::bounding::BoundingSphere> = - <::bevy_math::bounding::BoundingSphere as ::core::clone::Clone>::clone( - &_self, - ) - .into(); + let output: Val<::bevy_math::bounding::BoundingSphere> = + <::bevy_math::bounding::BoundingSphere as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_math::bounding::BoundingSphere>, + other: Ref<::bevy_math::bounding::BoundingSphere>| { + let output: bool = { + { + let output: bool = + <::bevy_math::bounding::BoundingSphere as ::core::cmp::PartialEq< + ::bevy_math::bounding::BoundingSphere, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "radius", + |_self: Ref<::bevy_math::bounding::BoundingSphere>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::bounding::BoundingSphere::radius(&_self).into(); + output + } + }; + output + }, + " Get the radius of the bounding sphere", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::bounding::BoundingSphere, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_sphere_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Sphere, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Sphere>| { + let output: Val<::bevy_math::primitives::Sphere> = { + { + let output: Val<::bevy_math::primitives::Sphere> = + <::bevy_math::primitives::Sphere as ::core::clone::Clone>::clone(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "diameter", + |_self: Ref<::bevy_math::primitives::Sphere>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::Sphere::diameter(&_self).into(); output } }; output }, - "", + " Get the diameter of the sphere", &["_self"], ) .register_documented( "eq", - |_self: Ref<::bevy_math::bounding::BoundingSphere>, - other: Ref<::bevy_math::bounding::BoundingSphere>| { + |_self: Ref<::bevy_math::primitives::Sphere>, + other: Ref<::bevy_math::primitives::Sphere>| { let output: bool = { { let output: bool = - <::bevy_math::bounding::BoundingSphere as ::core::cmp::PartialEq< - ::bevy_math::bounding::BoundingSphere, + <::bevy_math::primitives::Sphere as ::core::cmp::PartialEq< + ::bevy_math::primitives::Sphere, >>::eq(&_self, &other) .into(); output @@ -6348,125 +4894,22 @@ pub(crate) fn register_bounding_sphere_functions(world: &mut World) { &["_self", "other"], ) .register_documented( - "radius", - |_self: Ref<::bevy_math::bounding::BoundingSphere>| { - let output: f32 = { + "new", + |radius: f32| { + let output: Val<::bevy_math::primitives::Sphere> = { { - let output: f32 = ::bevy_math::bounding::BoundingSphere::radius(&_self).into(); + let output: Val<::bevy_math::primitives::Sphere> = + ::bevy_math::primitives::Sphere::new(radius).into(); output } }; output }, - " Get the radius of the bounding sphere", - &["_self"], + " Create a new [`Sphere`] from a `radius`", + &["radius"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::bounding::BoundingSphere, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_sphere_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Sphere, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Sphere>| { - let output: Val<::bevy_math::primitives::Sphere> = { - { - let output: Val<::bevy_math::primitives::Sphere> = <::bevy_math::primitives::Sphere as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "closest_point", - | - _self: Ref<::bevy_math::primitives::Sphere>, - point: Val<::bevy_math::prelude::Vec3>| - { - let output: Val<::bevy_math::prelude::Vec3> = { - { - let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::primitives::Sphere::closest_point( - &_self, - point.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Finds the point on the sphere that is closest to the given `point`.\n If the point is outside the sphere, the returned point will be on the surface of the sphere.\n Otherwise, it will be inside the sphere and returned as is.", - &["_self", "point"], - ) - .register_documented( - "diameter", - |_self: Ref<::bevy_math::primitives::Sphere>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::Sphere::diameter( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the diameter of the sphere", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_math::primitives::Sphere>, - other: Ref<::bevy_math::primitives::Sphere>| - { - let output: bool = { - { - let output: bool = <::bevy_math::primitives::Sphere as ::core::cmp::PartialEq< - ::bevy_math::primitives::Sphere, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "new", - |radius: f32| { - let output: Val<::bevy_math::primitives::Sphere> = { - { - let output: Val<::bevy_math::primitives::Sphere> = ::bevy_math::primitives::Sphere::new( - radius, - ) - .into(); - output - } - }; - output - }, - " Create a new [`Sphere`] from a `radius`", - &["radius"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); registry .register_type_data::< ::bevy_math::primitives::Sphere, @@ -6494,27 +4937,6 @@ pub(crate) fn register_cuboid_functions(world: &mut World) { "", &["_self"], ) - .register_documented( - "closest_point", - | - _self: Ref<::bevy_math::primitives::Cuboid>, - point: Val<::bevy_math::prelude::Vec3>| - { - let output: Val<::bevy_math::prelude::Vec3> = { - { - let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::primitives::Cuboid::closest_point( - &_self, - point.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Finds the point on the cuboid that is closest to the given `point`.\n If the point is outside the cuboid, the returned point will be on the surface of the cuboid.\n Otherwise, it will be inside the cuboid and returned as is.", - &["_self", "point"], - ) .register_documented( "eq", | @@ -6535,27 +4957,6 @@ pub(crate) fn register_cuboid_functions(world: &mut World) { "", &["_self", "other"], ) - .register_documented( - "from_corners", - | - point1: Val<::bevy_math::prelude::Vec3>, - point2: Val<::bevy_math::prelude::Vec3>| - { - let output: Val<::bevy_math::primitives::Cuboid> = { - { - let output: Val<::bevy_math::primitives::Cuboid> = ::bevy_math::primitives::Cuboid::from_corners( - point1.into_inner(), - point2.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a new `Cuboid` from two corner points", - &["point1", "point2"], - ) .register_documented( "from_length", |length: f32| { @@ -6573,23 +4974,6 @@ pub(crate) fn register_cuboid_functions(world: &mut World) { " Create a `Cuboid` from a single length.\n The resulting `Cuboid` will be the same size in every direction.", &["length"], ) - .register_documented( - "from_size", - |size: Val<::bevy_math::prelude::Vec3>| { - let output: Val<::bevy_math::primitives::Cuboid> = { - { - let output: Val<::bevy_math::primitives::Cuboid> = ::bevy_math::primitives::Cuboid::from_size( - size.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a new `Cuboid` from a given full size", - &["size"], - ) .register_documented( "new", |x_length: f32, y_length: f32, z_length: f32| { @@ -6608,23 +4992,6 @@ pub(crate) fn register_cuboid_functions(world: &mut World) { }, " Create a new `Cuboid` from a full x, y, and z length", &["x_length", "y_length", "z_length"], - ) - .register_documented( - "size", - |_self: Ref<::bevy_math::primitives::Cuboid>| { - let output: Val<::bevy_math::prelude::Vec3> = { - { - let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::primitives::Cuboid::size( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the size of the cuboid", - &["_self"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -7005,85 +5372,43 @@ pub(crate) fn register_infinite_plane_3_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_math::primitives::InfinitePlane3d, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::InfinitePlane3d>| { - let output: Val<::bevy_math::primitives::InfinitePlane3d> = { - { - let output: Val<::bevy_math::primitives::InfinitePlane3d> = <::bevy_math::primitives::InfinitePlane3d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_math::primitives::InfinitePlane3d>, - other: Ref<::bevy_math::primitives::InfinitePlane3d>| - { - let output: bool = { - { - let output: bool = <::bevy_math::primitives::InfinitePlane3d as ::core::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::InfinitePlane3d>| { + let output: Val<::bevy_math::primitives::InfinitePlane3d> = { + { + let output: Val<::bevy_math::primitives::InfinitePlane3d> = + <::bevy_math::primitives::InfinitePlane3d as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_math::primitives::InfinitePlane3d>, + other: Ref<::bevy_math::primitives::InfinitePlane3d>| { + let output: bool = { + { + let output: bool = + <::bevy_math::primitives::InfinitePlane3d as ::core::cmp::PartialEq< ::bevy_math::primitives::InfinitePlane3d, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "isometry_from_xy", - | - _self: Ref<::bevy_math::primitives::InfinitePlane3d>, - origin: Val<::bevy_math::prelude::Vec3>| - { - let output: Val<::bevy_math::Isometry3d> = { - { - let output: Val<::bevy_math::Isometry3d> = ::bevy_math::primitives::InfinitePlane3d::isometry_from_xy( - &_self, - origin.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Computes an [`Isometry3d`] which transforms points from the XY-plane to this plane with the\n given `origin`.\n ## Guarantees\n * the transformation is a [congruence] meaning it will preserve all distances and angles of\n the transformed geometry\n * uses the least rotation possible to transform the geometry\n * if two geometries are transformed with the same isometry, then the relations between\n them, like distances, are also preserved\n * compared to projections, the transformation is lossless (up to floating point errors)\n reversible\n ## Non-Guarantees\n * the rotation used is generally not unique\n * the orientation of the transformed geometry in the XY plane might be arbitrary, to\n enforce some kind of alignment the user has to use an extra transformation ontop of this\n one\n See [`isometries_xy`] for example usescases.\n [congruence]: https://en.wikipedia.org/wiki/Congruence_(geometry)\n [`isometries_xy`]: `InfinitePlane3d::isometries_xy`", - &["_self", "origin"], - ) - .register_documented( - "isometry_into_xy", - | - _self: Ref<::bevy_math::primitives::InfinitePlane3d>, - origin: Val<::bevy_math::prelude::Vec3>| - { - let output: Val<::bevy_math::Isometry3d> = { - { - let output: Val<::bevy_math::Isometry3d> = ::bevy_math::primitives::InfinitePlane3d::isometry_into_xy( - &_self, - origin.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Computes an [`Isometry3d`] which transforms points from the plane in 3D space with the given\n `origin` to the XY-plane.\n ## Guarantees\n * the transformation is a [congruence] meaning it will preserve all distances and angles of\n the transformed geometry\n * uses the least rotation possible to transform the geometry\n * if two geometries are transformed with the same isometry, then the relations between\n them, like distances, are also preserved\n * compared to projections, the transformation is lossless (up to floating point errors)\n reversible\n ## Non-Guarantees\n * the rotation used is generally not unique\n * the orientation of the transformed geometry in the XY plane might be arbitrary, to\n enforce some kind of alignment the user has to use an extra transformation ontop of this\n one\n See [`isometries_xy`] for example usescases.\n [congruence]: https://en.wikipedia.org/wiki/Congruence_(geometry)\n [`isometries_xy`]: `InfinitePlane3d::isometries_xy`", - &["_self", "origin"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -7137,29 +5462,12 @@ pub(crate) fn register_line_3_d_functions(world: &mut World) { .register_type_data::< ::bevy_math::primitives::Line3d, bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_segment_3_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Segment3d, - >::new(world) - .register_documented( - "center", - |_self: Ref<::bevy_math::primitives::Segment3d>| { - let output: Val<::bevy_math::prelude::Vec3> = { - { - let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::primitives::Segment3d::center( - &_self, - ) - .into(); - output - } - }; - output - }, - " Compute the midpoint between the two endpoints of the line segment.", - &["_self"], - ) + >(); +} +pub(crate) fn register_segment_3_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Segment3d, + >::new(world) .register_documented( "centered", |_self: Ref<::bevy_math::primitives::Segment3d>| { @@ -7194,27 +5502,6 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { "", &["_self"], ) - .register_documented( - "closest_point", - | - _self: Ref<::bevy_math::primitives::Segment3d>, - point: Val<::bevy_math::prelude::Vec3>| - { - let output: Val<::bevy_math::prelude::Vec3> = { - { - let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::primitives::Segment3d::closest_point( - &_self, - point.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Returns the point on the [`Segment3d`] that is closest to the specified `point`.", - &["_self", "point"], - ) .register_documented( "direction", |_self: Ref<::bevy_math::primitives::Segment3d>| { @@ -7288,23 +5575,6 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { " Create a new `Segment3d` starting from the origin of the given `ray`,\n going in the direction of the ray for the given `length`.\n The endpoints will be at `ray.origin` and `ray.origin + length * ray.direction`.", &["ray", "length"], ) - .register_documented( - "from_scaled_direction", - |scaled_direction: Val<::bevy_math::prelude::Vec3>| { - let output: Val<::bevy_math::primitives::Segment3d> = { - { - let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::from_scaled_direction( - scaled_direction.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a new `Segment3d` centered at the origin from a vector representing\n the direction and length of the line segment.\n The endpoints will be at `-scaled_direction / 2.0` and `scaled_direction / 2.0`.", - &["scaled_direction"], - ) .register_documented( "length", |_self: Ref<::bevy_math::primitives::Segment3d>| { @@ -7339,61 +5609,6 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { " Compute the squared length of the line segment.", &["_self"], ) - .register_documented( - "new", - | - point1: Val<::bevy_math::prelude::Vec3>, - point2: Val<::bevy_math::prelude::Vec3>| - { - let output: Val<::bevy_math::primitives::Segment3d> = { - { - let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::new( - point1.into_inner(), - point2.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a new `Segment3d` from its endpoints.", - &["point1", "point2"], - ) - .register_documented( - "point1", - |_self: Ref<::bevy_math::primitives::Segment3d>| { - let output: Val<::bevy_math::prelude::Vec3> = { - { - let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::primitives::Segment3d::point1( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the position of the first endpoint of the line segment.", - &["_self"], - ) - .register_documented( - "point2", - |_self: Ref<::bevy_math::primitives::Segment3d>| { - let output: Val<::bevy_math::prelude::Vec3> = { - { - let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::primitives::Segment3d::point2( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the position of the second endpoint of the line segment.", - &["_self"], - ) .register_documented( "resized", |_self: Ref<::bevy_math::primitives::Segment3d>, length: f32| { @@ -7445,109 +5660,6 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { }, " Returns the line segment with its direction reversed by swapping the endpoints.", &["_self"], - ) - .register_documented( - "rotated", - | - _self: Ref<::bevy_math::primitives::Segment3d>, - rotation: Val<::bevy_math::prelude::Quat>| - { - let output: Val<::bevy_math::primitives::Segment3d> = { - { - let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::rotated( - &_self, - rotation.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Compute the segment rotated around the origin by the given rotation.", - &["_self", "rotation"], - ) - .register_documented( - "rotated_around", - | - _self: Ref<::bevy_math::primitives::Segment3d>, - rotation: Val<::bevy_math::prelude::Quat>, - point: Val<::bevy_math::prelude::Vec3>| - { - let output: Val<::bevy_math::primitives::Segment3d> = { - { - let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::rotated_around( - &_self, - rotation.into_inner(), - point.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Compute the segment rotated around the given point by the given rotation.", - &["_self", "rotation", "point"], - ) - .register_documented( - "rotated_around_center", - | - _self: Ref<::bevy_math::primitives::Segment3d>, - rotation: Val<::bevy_math::prelude::Quat>| - { - let output: Val<::bevy_math::primitives::Segment3d> = { - { - let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::rotated_around_center( - &_self, - rotation.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Compute the segment rotated around its own center.", - &["_self", "rotation"], - ) - .register_documented( - "scaled_direction", - |_self: Ref<::bevy_math::primitives::Segment3d>| { - let output: Val<::bevy_math::prelude::Vec3> = { - { - let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::primitives::Segment3d::scaled_direction( - &_self, - ) - .into(); - output - } - }; - output - }, - " Compute the vector from the first endpoint to the second endpoint.", - &["_self"], - ) - .register_documented( - "translated", - | - _self: Ref<::bevy_math::primitives::Segment3d>, - translation: Val<::bevy_math::prelude::Vec3>| - { - let output: Val<::bevy_math::primitives::Segment3d> = { - { - let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::translated( - &_self, - translation.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Compute the segment translated by the given vector.", - &["_self", "translation"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -7662,40 +5774,6 @@ pub(crate) fn register_triangle_3_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_math::primitives::Triangle3d, >::new(world) - .register_documented( - "centroid", - |_self: Ref<::bevy_math::primitives::Triangle3d>| { - let output: Val<::bevy_math::prelude::Vec3> = { - { - let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::primitives::Triangle3d::centroid( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the centroid of the triangle.\n This function finds the geometric center of the triangle by averaging the vertices:\n `centroid = (a + b + c) / 3`.", - &["_self"], - ) - .register_documented( - "circumcenter", - |_self: Ref<::bevy_math::primitives::Triangle3d>| { - let output: Val<::bevy_math::prelude::Vec3> = { - { - let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::primitives::Triangle3d::circumcenter( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the circumcenter of the triangle.", - &["_self"], - ) .register_documented( "clone", |_self: Ref<::bevy_math::primitives::Triangle3d>| { @@ -7784,125 +5862,30 @@ pub(crate) fn register_triangle_3_d_functions(world: &mut World) { " Checks if the triangle is obtuse, meaning one angle is greater than 90 degrees", &["_self"], ) - .register_documented( - "new", - | - a: Val<::bevy_math::prelude::Vec3>, - b: Val<::bevy_math::prelude::Vec3>, - c: Val<::bevy_math::prelude::Vec3>| - { - let output: Val<::bevy_math::primitives::Triangle3d> = { - { - let output: Val<::bevy_math::primitives::Triangle3d> = ::bevy_math::primitives::Triangle3d::new( - a.into_inner(), - b.into_inner(), - c.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a new [`Triangle3d`] from points `a`, `b`, and `c`.", - &["a", "b", "c"], - ) .register_documented( "reverse", |mut _self: Mut<::bevy_math::primitives::Triangle3d>| { let output: () = { { - let output: () = ::bevy_math::primitives::Triangle3d::reverse( - &mut _self, - ) - .into(); - output - } - }; - output - }, - " Reverse the triangle by swapping the first and last vertices.", - &["_self"], - ) - .register_documented( - "reversed", - |_self: Val<::bevy_math::primitives::Triangle3d>| { - let output: Val<::bevy_math::primitives::Triangle3d> = { - { - let output: Val<::bevy_math::primitives::Triangle3d> = ::bevy_math::primitives::Triangle3d::reversed( - _self.into_inner(), - ) - .into(); - output - } - }; - output - }, - " This triangle but reversed.", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::primitives::Triangle3d, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_polyline_3_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Polyline3d, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Polyline3d>| { - let output: Val<::bevy_math::primitives::Polyline3d> = { - { - let output: Val<::bevy_math::primitives::Polyline3d> = <::bevy_math::primitives::Polyline3d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_math::primitives::Polyline3d>, - other: Ref<::bevy_math::primitives::Polyline3d>| - { - let output: bool = { - { - let output: bool = <::bevy_math::primitives::Polyline3d as ::core::cmp::PartialEq< - ::bevy_math::primitives::Polyline3d, - >>::eq(&_self, &other) + let output: () = ::bevy_math::primitives::Triangle3d::reverse( + &mut _self, + ) .into(); output } }; output }, - "", - &["_self", "other"], + " Reverse the triangle by swapping the first and last vertices.", + &["_self"], ) .register_documented( - "with_subdivisions", - | - start: Val<::bevy_math::prelude::Vec3>, - end: Val<::bevy_math::prelude::Vec3>, - subdivisions: usize| - { - let output: Val<::bevy_math::primitives::Polyline3d> = { + "reversed", + |_self: Val<::bevy_math::primitives::Triangle3d>| { + let output: Val<::bevy_math::primitives::Triangle3d> = { { - let output: Val<::bevy_math::primitives::Polyline3d> = ::bevy_math::primitives::Polyline3d::with_subdivisions( - start.into_inner(), - end.into_inner(), - subdivisions, + let output: Val<::bevy_math::primitives::Triangle3d> = ::bevy_math::primitives::Triangle3d::reversed( + _self.into_inner(), ) .into(); output @@ -7910,11 +5893,60 @@ pub(crate) fn register_polyline_3_d_functions(world: &mut World) { }; output }, - " Create a new `Polyline3d` from two endpoints with subdivision points.\n `subdivisions = 0` creates a simple line with just start and end points.\n `subdivisions = 1` adds one point in the middle, creating 2 segments, etc.", - &["start", "end", "subdivisions"], + " This triangle but reversed.", + &["_self"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::Triangle3d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_polyline_3_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Polyline3d, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Polyline3d>| { + let output: Val<::bevy_math::primitives::Polyline3d> = { + { + let output: Val<::bevy_math::primitives::Polyline3d> = + <::bevy_math::primitives::Polyline3d as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_math::primitives::Polyline3d>, + other: Ref<::bevy_math::primitives::Polyline3d>| { + let output: bool = { + { + let output: bool = + <::bevy_math::primitives::Polyline3d as ::core::cmp::PartialEq< + ::bevy_math::primitives::Polyline3d, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); registry .register_type_data::< ::bevy_math::primitives::Polyline3d, @@ -7974,21 +6006,6 @@ pub(crate) fn register_ray_cast_2_d_functions(world: &mut World) { "", &["_self"], ) - .register_documented( - "direction_recip", - |_self: Ref<::bevy_math::bounding::RayCast2d>| { - let output: Val<::bevy_math::prelude::Vec2> = { - { - let output: Val<::bevy_math::prelude::Vec2> = - ::bevy_math::bounding::RayCast2d::direction_recip(&_self).into(); - output - } - }; - output - }, - " Get the cached multiplicative inverse of the direction of the ray.", - &["_self"], - ) .register_documented( "from_ray", |ray: Val<::bevy_math::Ray2d>, max: f32| { @@ -8003,28 +6020,6 @@ pub(crate) fn register_ray_cast_2_d_functions(world: &mut World) { }, " Construct a [`RayCast2d`] from a [`Ray2d`] and max distance.", &["ray", "max"], - ) - .register_documented( - "new", - |origin: Val<::bevy_math::prelude::Vec2>, - direction: Val<::bevy_math::prelude::Dir2>, - max: f32| { - let output: Val<::bevy_math::bounding::RayCast2d> = { - { - let output: Val<::bevy_math::bounding::RayCast2d> = - ::bevy_math::bounding::RayCast2d::new( - origin.into_inner(), - direction.into_inner(), - max, - ) - .into(); - output - } - }; - output - }, - " Construct a [`RayCast2d`] from an origin, [`Dir2`], and max distance.", - &["origin", "direction", "max"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -8093,30 +6088,6 @@ pub(crate) fn register_aabb_cast_2_d_functions(world: &mut World) { }, " Construct an [`AabbCast2d`] from an [`Aabb2d`], [`Ray2d`], and max distance.", &["aabb", "ray", "max"], - ) - .register_documented( - "new", - |aabb: Val<::bevy_math::bounding::Aabb2d>, - origin: Val<::bevy_math::prelude::Vec2>, - direction: Val<::bevy_math::prelude::Dir2>, - max: f32| { - let output: Val<::bevy_math::bounding::AabbCast2d> = { - { - let output: Val<::bevy_math::bounding::AabbCast2d> = - ::bevy_math::bounding::AabbCast2d::new( - aabb.into_inner(), - origin.into_inner(), - direction.into_inner(), - max, - ) - .into(); - output - } - }; - output - }, - " Construct an [`AabbCast2d`] from an [`Aabb2d`], origin, [`Dir2`], and max distance.", - &["aabb", "origin", "direction", "max"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -8190,31 +6161,6 @@ pub(crate) fn register_bounding_circle_cast_functions(world: &mut World) { }, " Construct a [`BoundingCircleCast`] from a [`BoundingCircle`], [`Ray2d`], and max distance.", &["circle", "ray", "max"], - ) - .register_documented( - "new", - | - circle: Val<::bevy_math::bounding::BoundingCircle>, - origin: Val<::bevy_math::prelude::Vec2>, - direction: Val<::bevy_math::prelude::Dir2>, - max: f32| - { - let output: Val<::bevy_math::bounding::BoundingCircleCast> = { - { - let output: Val<::bevy_math::bounding::BoundingCircleCast> = ::bevy_math::bounding::BoundingCircleCast::new( - circle.into_inner(), - origin.into_inner(), - direction.into_inner(), - max, - ) - .into(); - output - } - }; - output - }, - " Construct a [`BoundingCircleCast`] from a [`BoundingCircle`], origin, [`Dir2`], and max distance.", - &["circle", "origin", "direction", "max"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -8260,21 +6206,6 @@ pub(crate) fn register_ray_cast_3_d_functions(world: &mut World) { "", &["_self"], ) - .register_documented( - "direction_recip", - |_self: Ref<::bevy_math::bounding::RayCast3d>| { - let output: Val<::bevy_math::prelude::Vec3A> = { - { - let output: Val<::bevy_math::prelude::Vec3A> = - ::bevy_math::bounding::RayCast3d::direction_recip(&_self).into(); - output - } - }; - output - }, - " Get the cached multiplicative inverse of the direction of the ray.", - &["_self"], - ) .register_documented( "from_ray", |ray: Val<::bevy_math::Ray3d>, max: f32| { @@ -8668,23 +6599,6 @@ pub(crate) fn register_dir_4_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_math::Dir4, >::new(world) - .register_documented( - "as_vec4", - |_self: Ref<::bevy_math::Dir4>| { - let output: Val<::bevy_math::prelude::Vec4> = { - { - let output: Val<::bevy_math::prelude::Vec4> = ::bevy_math::Dir4::as_vec4( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the inner [`Vec4`]", - &["_self"], - ) .register_documented( "clone", |_self: Ref<::bevy_math::Dir4>| { @@ -8756,23 +6670,6 @@ pub(crate) fn register_dir_4_functions(world: &mut World) { " Create a direction from its `x`, `y`, `z`, and `w` components, assuming the resulting vector is normalized.\n # Warning\n The vector produced from `x`, `y`, `z`, and `w` must be normalized, i.e its length must be `1.0`.", &["x", "y", "z", "w"], ) - .register_documented( - "mul", - |_self: Val<::bevy_math::Dir4>, rhs: f32| { - let output: Val<::bevy_math::prelude::Vec4> = { - { - let output: Val<::bevy_math::prelude::Vec4> = <::bevy_math::Dir4 as ::core::ops::Mul< - f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output - } - }; - output - }, - "", - &["_self", "rhs"], - ) .register_documented( "neg", |_self: Val<::bevy_math::Dir4>| { @@ -8789,23 +6686,6 @@ pub(crate) fn register_dir_4_functions(world: &mut World) { }, "", &["_self"], - ) - .register_documented( - "new_unchecked", - |value: Val<::bevy_math::prelude::Vec4>| { - let output: Val<::bevy_math::Dir4> = { - { - let output: Val<::bevy_math::Dir4> = ::bevy_math::Dir4::new_unchecked( - value.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a [`Dir4`] from a [`Vec4`] that is already normalized.\n # Warning\n `value` must be normalized, i.e its length must be `1.0`.", - &["value"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -8945,64 +6825,41 @@ pub(crate) fn register_plane_3_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_math::primitives::Plane3d, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Plane3d>| { - let output: Val<::bevy_math::primitives::Plane3d> = { - { - let output: Val<::bevy_math::primitives::Plane3d> = <::bevy_math::primitives::Plane3d as ::core::clone::Clone>::clone( - &_self, - ) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Plane3d>| { + let output: Val<::bevy_math::primitives::Plane3d> = { + { + let output: Val<::bevy_math::primitives::Plane3d> = + <::bevy_math::primitives::Plane3d as ::core::clone::Clone>::clone(&_self) .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_math::primitives::Plane3d>, - other: Ref<::bevy_math::primitives::Plane3d>| - { - let output: bool = { - { - let output: bool = <::bevy_math::primitives::Plane3d as ::core::cmp::PartialEq< + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_math::primitives::Plane3d>, + other: Ref<::bevy_math::primitives::Plane3d>| { + let output: bool = { + { + let output: bool = + <::bevy_math::primitives::Plane3d as ::core::cmp::PartialEq< ::bevy_math::primitives::Plane3d, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "new", - | - normal: Val<::bevy_math::prelude::Vec3>, - half_size: Val<::bevy_math::prelude::Vec2>| - { - let output: Val<::bevy_math::primitives::Plane3d> = { - { - let output: Val<::bevy_math::primitives::Plane3d> = ::bevy_math::primitives::Plane3d::new( - normal.into_inner(), - half_size.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a new `Plane3d` from a normal and a half size\n # Panics\n Panics if the given `normal` is zero (or very close to zero), or non-finite.", - &["normal", "half_size"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -9015,23 +6872,6 @@ pub(crate) fn register_tetrahedron_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_math::primitives::Tetrahedron, >::new(world) - .register_documented( - "centroid", - |_self: Ref<::bevy_math::primitives::Tetrahedron>| { - let output: Val<::bevy_math::prelude::Vec3> = { - { - let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::primitives::Tetrahedron::centroid( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the centroid of the tetrahedron.\n This function finds the geometric center of the tetrahedron\n by averaging the vertices: `centroid = (a + b + c + d) / 4`.", - &["_self"], - ) .register_documented( "clone", |_self: Ref<::bevy_math::primitives::Tetrahedron>| { @@ -9069,31 +6909,6 @@ pub(crate) fn register_tetrahedron_functions(world: &mut World) { "", &["_self", "other"], ) - .register_documented( - "new", - | - a: Val<::bevy_math::prelude::Vec3>, - b: Val<::bevy_math::prelude::Vec3>, - c: Val<::bevy_math::prelude::Vec3>, - d: Val<::bevy_math::prelude::Vec3>| - { - let output: Val<::bevy_math::primitives::Tetrahedron> = { - { - let output: Val<::bevy_math::primitives::Tetrahedron> = ::bevy_math::primitives::Tetrahedron::new( - a.into_inner(), - b.into_inner(), - c.into_inner(), - d.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a new [`Tetrahedron`] from points `a`, `b`, `c` and `d`.", - &["a", "b", "c", "d"], - ) .register_documented( "signed_volume", |_self: Ref<::bevy_math::primitives::Tetrahedron>| { diff --git a/crates/bindings/bevy_mesh_bms_bindings/src/lib.rs b/crates/bindings/bevy_mesh_bms_bindings/src/lib.rs index 90a8ffb06b..c15d28bc38 100644 --- a/crates/bindings/bevy_mesh_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_mesh_bms_bindings/src/lib.rs @@ -289,81 +289,6 @@ pub(crate) fn register_mesh_functions(world: &mut World) { " Normalize joint weights so they sum to 1.", &["_self"], ) - .register_documented( - "rotate_by", - | - mut _self: Mut<::bevy_mesh::prelude::Mesh>, - rotation: Val<::bevy_math::Quat>| - { - let output: () = { - { - let output: () = ::bevy_mesh::prelude::Mesh::rotate_by( - &mut _self, - rotation.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Rotates the vertex positions, normals, and tangents of the mesh in place by the given [`Quat`].\n `Aabb` of entities with modified mesh are not updated automatically.", - &["_self", "rotation"], - ) - .register_documented( - "rotated_by", - |_self: Val<::bevy_mesh::prelude::Mesh>, rotation: Val<::bevy_math::Quat>| { - let output: Val<::bevy_mesh::prelude::Mesh> = { - { - let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::rotated_by( - _self.into_inner(), - rotation.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Rotates the vertex positions, normals, and tangents of the mesh by the given [`Quat`].\n `Aabb` of entities with modified mesh are not updated automatically.", - &["_self", "rotation"], - ) - .register_documented( - "scale_by", - |mut _self: Mut<::bevy_mesh::prelude::Mesh>, scale: Val<::bevy_math::Vec3>| { - let output: () = { - { - let output: () = ::bevy_mesh::prelude::Mesh::scale_by( - &mut _self, - scale.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Scales the vertex positions, normals, and tangents of the mesh in place by the given [`Vec3`].\n `Aabb` of entities with modified mesh are not updated automatically.", - &["_self", "scale"], - ) - .register_documented( - "scaled_by", - |_self: Val<::bevy_mesh::prelude::Mesh>, scale: Val<::bevy_math::Vec3>| { - let output: Val<::bevy_mesh::prelude::Mesh> = { - { - let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::scaled_by( - _self.into_inner(), - scale.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Scales the vertex positions, normals, and tangents of the mesh by the given [`Vec3`].\n `Aabb` of entities with modified mesh are not updated automatically.", - &["_self", "scale"], - ) .register_documented( "set_morph_target_names", | @@ -427,48 +352,6 @@ pub(crate) fn register_mesh_functions(world: &mut World) { " Transforms the vertex positions, normals, and tangents of the mesh by the given [`Transform`].\n `Aabb` of entities with modified mesh are not updated automatically.", &["_self", "transform"], ) - .register_documented( - "translate_by", - | - mut _self: Mut<::bevy_mesh::prelude::Mesh>, - translation: Val<::bevy_math::Vec3>| - { - let output: () = { - { - let output: () = ::bevy_mesh::prelude::Mesh::translate_by( - &mut _self, - translation.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Translates the vertex positions of the mesh in place by the given [`Vec3`].\n `Aabb` of entities with modified mesh are not updated automatically.", - &["_self", "translation"], - ) - .register_documented( - "translated_by", - | - _self: Val<::bevy_mesh::prelude::Mesh>, - translation: Val<::bevy_math::Vec3>| - { - let output: Val<::bevy_mesh::prelude::Mesh> = { - { - let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::translated_by( - _self.into_inner(), - translation.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Translates the vertex positions of the mesh by the given [`Vec3`].\n `Aabb` of entities with modified mesh are not updated automatically.", - &["_self", "translation"], - ) .register_documented( "with_computed_area_weighted_normals", |_self: Val<::bevy_mesh::prelude::Mesh>| { @@ -1560,31 +1443,6 @@ pub(crate) fn register_triangle_2_d_mesh_builder_functions(world: &mut World) { }, "", &["_self"], - ) - .register_documented( - "new", - | - a: Val<::bevy_math::Vec2>, - b: Val<::bevy_math::Vec2>, - c: Val<::bevy_math::Vec2>| - { - let output: Val<::bevy_mesh::primitives::Triangle2dMeshBuilder> = { - { - let output: Val< - ::bevy_mesh::primitives::Triangle2dMeshBuilder, - > = ::bevy_mesh::primitives::Triangle2dMeshBuilder::new( - a.into_inner(), - b.into_inner(), - c.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Creates a new [`Triangle2dMeshBuilder`] from the points `a`, `b`, and `c`.", - &["a", "b", "c"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -2295,41 +2153,6 @@ pub(crate) fn register_plane_mesh_builder_functions(world: &mut World) { " Creates a new [`PlaneMeshBuilder`] from the given length, with the normal pointing upwards,\n and the resulting [`PlaneMeshBuilder`] being a square.", &["length"], ) - .register_documented( - "from_size", - |size: Val<::bevy_math::Vec2>| { - let output: Val<::bevy_mesh::primitives::PlaneMeshBuilder> = { - { - let output: Val<::bevy_mesh::primitives::PlaneMeshBuilder> = ::bevy_mesh::primitives::PlaneMeshBuilder::from_size( - size.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Creates a new [`PlaneMeshBuilder`] from the given size, with the normal pointing upwards.", - &["size"], - ) - .register_documented( - "new", - |normal: Val<::bevy_math::Dir3>, size: Val<::bevy_math::Vec2>| { - let output: Val<::bevy_mesh::primitives::PlaneMeshBuilder> = { - { - let output: Val<::bevy_mesh::primitives::PlaneMeshBuilder> = ::bevy_mesh::primitives::PlaneMeshBuilder::new( - normal.into_inner(), - size.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Creates a new [`PlaneMeshBuilder`] from a given normal and size.", - &["normal", "size"], - ) .register_documented( "normal", | @@ -2400,68 +2223,6 @@ pub(crate) fn register_plane_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_polyline_3_d_mesh_builder_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::primitives::dim3::polyline3d::Polyline3dMeshBuilder, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::primitives::dim3::polyline3d::Polyline3dMeshBuilder>| { - let output: Val<::primitives::dim3::polyline3d::Polyline3dMeshBuilder> = { - { - let output: Val< - ::primitives::dim3::polyline3d::Polyline3dMeshBuilder, - > = <::primitives::dim3::polyline3d::Polyline3dMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::primitives::dim3::polyline3d::Polyline3dMeshBuilder, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_segment_3_d_mesh_builder_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::primitives::dim3::segment3d::Segment3dMeshBuilder, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::primitives::dim3::segment3d::Segment3dMeshBuilder>| { - let output: Val<::primitives::dim3::segment3d::Segment3dMeshBuilder> = { - { - let output: Val< - ::primitives::dim3::segment3d::Segment3dMeshBuilder, - > = <::primitives::dim3::segment3d::Segment3dMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::primitives::dim3::segment3d::Segment3dMeshBuilder, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} pub(crate) fn register_sphere_kind_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_mesh::primitives::SphereKind, @@ -2786,8 +2547,6 @@ impl Plugin for BevyMeshScriptingPlugin { register_cylinder_anchor_functions(&mut world); register_cylinder_mesh_builder_functions(&mut world); register_plane_mesh_builder_functions(&mut world); - register_polyline_3_d_mesh_builder_functions(&mut world); - register_segment_3_d_mesh_builder_functions(&mut world); register_sphere_kind_functions(&mut world); register_sphere_mesh_builder_functions(&mut world); register_tetrahedron_mesh_builder_functions(&mut world); diff --git a/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml b/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml index 63b006de77..0fe487789d 100644 --- a/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml @@ -52,7 +52,7 @@ bevy_shader = { version = "^0.17.2", features = [], default-features = true} bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml b/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml index 7430aec1de..a694159e18 100644 --- a/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml @@ -46,7 +46,7 @@ bevy_shader = { version = "^0.17.2", features = [], default-features = true} bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} diff --git a/crates/bindings/bevy_reflect_bms_bindings/Cargo.toml b/crates/bindings/bevy_reflect_bms_bindings/Cargo.toml index 1fb53448a4..3c7eeb6b2a 100644 --- a/crates/bindings/bevy_reflect_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_reflect_bms_bindings/Cargo.toml @@ -17,7 +17,7 @@ bevy_app = { workspace = true, features = ["std"] } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_reflect = { version = "0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} assert_type_match = { version = "^0.1.1", features = [], default-features = true} diff --git a/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs b/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs index f19b963038..14955f8b95 100644 --- a/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs @@ -14,18 +14,14 @@ use bevy_mod_scripting_derive::script_bindings; pub struct BevyReflectScriptingPlugin; pub(crate) fn register_atomic_bool_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool, + ::core::sync::atomic::AtomicBool, >::new(world) .register_documented( "into_inner", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool, - >| - { + |_self: Val<::core::sync::atomic::AtomicBool>| { let output: bool = { { - let output: bool = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool::into_inner( + let output: bool = ::core::sync::atomic::AtomicBool::into_inner( _self.into_inner(), ) .into(); @@ -40,13 +36,9 @@ pub(crate) fn register_atomic_bool_functions(world: &mut World) { .register_documented( "new", |v: bool| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool, - > = { + let output: Val<::core::sync::atomic::AtomicBool> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool::new( + let output: Val<::core::sync::atomic::AtomicBool> = ::core::sync::atomic::AtomicBool::new( v, ) .into(); @@ -62,24 +54,20 @@ pub(crate) fn register_atomic_bool_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicBool, + ::core::sync::atomic::AtomicBool, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_atomic_i_8_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8, + ::core::sync::atomic::AtomicI8, >::new(world) .register_documented( "into_inner", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8, - >| - { + |_self: Val<::core::sync::atomic::AtomicI8>| { let output: i8 = { { - let output: i8 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8::into_inner( + let output: i8 = ::core::sync::atomic::AtomicI8::into_inner( _self.into_inner(), ) .into(); @@ -94,13 +82,9 @@ pub(crate) fn register_atomic_i_8_functions(world: &mut World) { .register_documented( "new", |v: i8| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8, - > = { + let output: Val<::core::sync::atomic::AtomicI8> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8::new( + let output: Val<::core::sync::atomic::AtomicI8> = ::core::sync::atomic::AtomicI8::new( v, ) .into(); @@ -116,24 +100,20 @@ pub(crate) fn register_atomic_i_8_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI8, + ::core::sync::atomic::AtomicI8, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_atomic_i_16_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16, + ::core::sync::atomic::AtomicI16, >::new(world) .register_documented( "into_inner", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16, - >| - { + |_self: Val<::core::sync::atomic::AtomicI16>| { let output: i16 = { { - let output: i16 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16::into_inner( + let output: i16 = ::core::sync::atomic::AtomicI16::into_inner( _self.into_inner(), ) .into(); @@ -148,13 +128,9 @@ pub(crate) fn register_atomic_i_16_functions(world: &mut World) { .register_documented( "new", |v: i16| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16, - > = { + let output: Val<::core::sync::atomic::AtomicI16> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16::new( + let output: Val<::core::sync::atomic::AtomicI16> = ::core::sync::atomic::AtomicI16::new( v, ) .into(); @@ -170,24 +146,20 @@ pub(crate) fn register_atomic_i_16_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI16, + ::core::sync::atomic::AtomicI16, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_atomic_i_32_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32, + ::core::sync::atomic::AtomicI32, >::new(world) .register_documented( "into_inner", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32, - >| - { + |_self: Val<::core::sync::atomic::AtomicI32>| { let output: i32 = { { - let output: i32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32::into_inner( + let output: i32 = ::core::sync::atomic::AtomicI32::into_inner( _self.into_inner(), ) .into(); @@ -202,13 +174,9 @@ pub(crate) fn register_atomic_i_32_functions(world: &mut World) { .register_documented( "new", |v: i32| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32, - > = { + let output: Val<::core::sync::atomic::AtomicI32> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32::new( + let output: Val<::core::sync::atomic::AtomicI32> = ::core::sync::atomic::AtomicI32::new( v, ) .into(); @@ -224,24 +192,20 @@ pub(crate) fn register_atomic_i_32_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI32, + ::core::sync::atomic::AtomicI32, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_atomic_i_64_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64, + ::core::sync::atomic::AtomicI64, >::new(world) .register_documented( "into_inner", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64, - >| - { + |_self: Val<::core::sync::atomic::AtomicI64>| { let output: i64 = { { - let output: i64 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64::into_inner( + let output: i64 = ::core::sync::atomic::AtomicI64::into_inner( _self.into_inner(), ) .into(); @@ -256,13 +220,9 @@ pub(crate) fn register_atomic_i_64_functions(world: &mut World) { .register_documented( "new", |v: i64| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64, - > = { + let output: Val<::core::sync::atomic::AtomicI64> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64::new( + let output: Val<::core::sync::atomic::AtomicI64> = ::core::sync::atomic::AtomicI64::new( v, ) .into(); @@ -278,24 +238,20 @@ pub(crate) fn register_atomic_i_64_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicI64, + ::core::sync::atomic::AtomicI64, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_atomic_isize_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize, + ::core::sync::atomic::AtomicIsize, >::new(world) .register_documented( "into_inner", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize, - >| - { + |_self: Val<::core::sync::atomic::AtomicIsize>| { let output: isize = { { - let output: isize = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize::into_inner( + let output: isize = ::core::sync::atomic::AtomicIsize::into_inner( _self.into_inner(), ) .into(); @@ -310,13 +266,9 @@ pub(crate) fn register_atomic_isize_functions(world: &mut World) { .register_documented( "new", |v: isize| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize, - > = { + let output: Val<::core::sync::atomic::AtomicIsize> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize::new( + let output: Val<::core::sync::atomic::AtomicIsize> = ::core::sync::atomic::AtomicIsize::new( v, ) .into(); @@ -332,24 +284,20 @@ pub(crate) fn register_atomic_isize_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicIsize, + ::core::sync::atomic::AtomicIsize, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_atomic_u_8_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8, + ::core::sync::atomic::AtomicU8, >::new(world) .register_documented( "into_inner", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8, - >| - { + |_self: Val<::core::sync::atomic::AtomicU8>| { let output: u8 = { { - let output: u8 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8::into_inner( + let output: u8 = ::core::sync::atomic::AtomicU8::into_inner( _self.into_inner(), ) .into(); @@ -364,13 +312,9 @@ pub(crate) fn register_atomic_u_8_functions(world: &mut World) { .register_documented( "new", |v: u8| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8, - > = { + let output: Val<::core::sync::atomic::AtomicU8> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8::new( + let output: Val<::core::sync::atomic::AtomicU8> = ::core::sync::atomic::AtomicU8::new( v, ) .into(); @@ -386,24 +330,20 @@ pub(crate) fn register_atomic_u_8_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU8, + ::core::sync::atomic::AtomicU8, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_atomic_u_16_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16, + ::core::sync::atomic::AtomicU16, >::new(world) .register_documented( "into_inner", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16, - >| - { + |_self: Val<::core::sync::atomic::AtomicU16>| { let output: u16 = { { - let output: u16 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16::into_inner( + let output: u16 = ::core::sync::atomic::AtomicU16::into_inner( _self.into_inner(), ) .into(); @@ -418,13 +358,9 @@ pub(crate) fn register_atomic_u_16_functions(world: &mut World) { .register_documented( "new", |v: u16| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16, - > = { + let output: Val<::core::sync::atomic::AtomicU16> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16::new( + let output: Val<::core::sync::atomic::AtomicU16> = ::core::sync::atomic::AtomicU16::new( v, ) .into(); @@ -440,24 +376,20 @@ pub(crate) fn register_atomic_u_16_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU16, + ::core::sync::atomic::AtomicU16, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_atomic_u_32_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32, + ::core::sync::atomic::AtomicU32, >::new(world) .register_documented( "into_inner", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32, - >| - { + |_self: Val<::core::sync::atomic::AtomicU32>| { let output: u32 = { { - let output: u32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32::into_inner( + let output: u32 = ::core::sync::atomic::AtomicU32::into_inner( _self.into_inner(), ) .into(); @@ -472,13 +404,9 @@ pub(crate) fn register_atomic_u_32_functions(world: &mut World) { .register_documented( "new", |v: u32| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32, - > = { + let output: Val<::core::sync::atomic::AtomicU32> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32::new( + let output: Val<::core::sync::atomic::AtomicU32> = ::core::sync::atomic::AtomicU32::new( v, ) .into(); @@ -494,24 +422,20 @@ pub(crate) fn register_atomic_u_32_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU32, + ::core::sync::atomic::AtomicU32, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_atomic_u_64_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64, + ::core::sync::atomic::AtomicU64, >::new(world) .register_documented( "into_inner", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64, - >| - { + |_self: Val<::core::sync::atomic::AtomicU64>| { let output: u64 = { { - let output: u64 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64::into_inner( + let output: u64 = ::core::sync::atomic::AtomicU64::into_inner( _self.into_inner(), ) .into(); @@ -526,13 +450,9 @@ pub(crate) fn register_atomic_u_64_functions(world: &mut World) { .register_documented( "new", |v: u64| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64, - > = { + let output: Val<::core::sync::atomic::AtomicU64> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64::new( + let output: Val<::core::sync::atomic::AtomicU64> = ::core::sync::atomic::AtomicU64::new( v, ) .into(); @@ -548,24 +468,20 @@ pub(crate) fn register_atomic_u_64_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicU64, + ::core::sync::atomic::AtomicU64, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_atomic_usize_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize, + ::core::sync::atomic::AtomicUsize, >::new(world) .register_documented( "into_inner", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize, - >| - { + |_self: Val<::core::sync::atomic::AtomicUsize>| { let output: usize = { { - let output: usize = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize::into_inner( + let output: usize = ::core::sync::atomic::AtomicUsize::into_inner( _self.into_inner(), ) .into(); @@ -580,13 +496,9 @@ pub(crate) fn register_atomic_usize_functions(world: &mut World) { .register_documented( "new", |v: usize| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize, - > = { + let output: Val<::core::sync::atomic::AtomicUsize> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize::new( + let output: Val<::core::sync::atomic::AtomicUsize> = ::core::sync::atomic::AtomicUsize::new( v, ) .into(); @@ -602,31 +514,20 @@ pub(crate) fn register_atomic_usize_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::sync::atomic::AtomicUsize, + ::core::sync::atomic::AtomicUsize, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_duration_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + ::core::time::Duration, >::new(world) .register_documented( "abs_diff", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - other: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { + |_self: Val<::core::time::Duration>, other: Val<::core::time::Duration>| { + let output: Val<::core::time::Duration> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::abs_diff( + let output: Val<::core::time::Duration> = ::core::time::Duration::abs_diff( _self.into_inner(), other.into_inner(), ) @@ -641,22 +542,11 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "add", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - rhs: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + |_self: Val<::core::time::Duration>, rhs: Val<::core::time::Duration>| { + let output: Val<::core::time::Duration> = { + { + let output: Val<::core::time::Duration> = <::core::time::Duration as ::core::ops::Add< + ::core::time::Duration, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output @@ -669,16 +559,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "as_micros", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { + |_self: Ref<::core::time::Duration>| { let output: u128 = { { - let output: u128 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_micros( - &_self, - ) + let output: u128 = ::core::time::Duration::as_micros(&_self) .into(); output } @@ -690,16 +574,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "as_millis", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { + |_self: Ref<::core::time::Duration>| { let output: u128 = { { - let output: u128 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_millis( - &_self, - ) + let output: u128 = ::core::time::Duration::as_millis(&_self) .into(); output } @@ -711,16 +589,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "as_nanos", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { + |_self: Ref<::core::time::Duration>| { let output: u128 = { { - let output: u128 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_nanos( - &_self, - ) + let output: u128 = ::core::time::Duration::as_nanos(&_self) .into(); output } @@ -732,17 +604,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "as_secs", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { + |_self: Ref<::core::time::Duration>| { let output: u64 = { { - let output: u64 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_secs( - &_self, - ) - .into(); + let output: u64 = ::core::time::Duration::as_secs(&_self).into(); output } }; @@ -753,16 +618,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "as_secs_f32", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { + |_self: Ref<::core::time::Duration>| { let output: f32 = { { - let output: f32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_secs_f32( - &_self, - ) + let output: f32 = ::core::time::Duration::as_secs_f32(&_self) .into(); output } @@ -774,16 +633,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "as_secs_f64", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { + |_self: Ref<::core::time::Duration>| { let output: f64 = { { - let output: f64 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::as_secs_f64( - &_self, - ) + let output: f64 = ::core::time::Duration::as_secs_f64(&_self) .into(); output } @@ -795,14 +648,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "assert_receiver_is_total_eq", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { + |_self: Ref<::core::time::Duration>| { let output: () = { { - let output: () = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::core::time::Duration as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -816,18 +665,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "clone", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { + |_self: Ref<::core::time::Duration>| { + let output: Val<::core::time::Duration> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::core::time::Duration> = <::core::time::Duration as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -841,19 +682,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "div", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - rhs: u32| - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { + |_self: Val<::core::time::Duration>, rhs: u32| { + let output: Val<::core::time::Duration> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::core::time::Duration> = <::core::time::Duration as ::core::ops::Div< u32, >>::div(_self.into_inner(), rhs) .into(); @@ -867,17 +699,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "div_duration_f32", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - rhs: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { + |_self: Val<::core::time::Duration>, rhs: Val<::core::time::Duration>| { let output: f32 = { { - let output: f32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::div_duration_f32( + let output: f32 = ::core::time::Duration::div_duration_f32( _self.into_inner(), rhs.into_inner(), ) @@ -892,17 +717,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "div_duration_f64", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - rhs: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { + |_self: Val<::core::time::Duration>, rhs: Val<::core::time::Duration>| { let output: f64 = { { - let output: f64 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::div_duration_f64( + let output: f64 = ::core::time::Duration::div_duration_f64( _self.into_inner(), rhs.into_inner(), ) @@ -917,19 +735,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "div_f32", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - rhs: f32| - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { + |_self: Val<::core::time::Duration>, rhs: f32| { + let output: Val<::core::time::Duration> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::div_f32( + let output: Val<::core::time::Duration> = ::core::time::Duration::div_f32( _self.into_inner(), rhs, ) @@ -944,19 +753,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "div_f64", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - rhs: f64| - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { + |_self: Val<::core::time::Duration>, rhs: f64| { + let output: Val<::core::time::Duration> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::div_f64( + let output: Val<::core::time::Duration> = ::core::time::Duration::div_f64( _self.into_inner(), rhs, ) @@ -971,18 +771,11 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - other: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { + |_self: Ref<::core::time::Duration>, other: Ref<::core::time::Duration>| { let output: bool = { { - let output: bool = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + let output: bool = <::core::time::Duration as ::core::cmp::PartialEq< + ::core::time::Duration, >>::eq(&_self, &other) .into(); output @@ -996,13 +789,9 @@ pub(crate) fn register_duration_functions(world: &mut World) { .register_documented( "from_micros", |micros: u64| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { + let output: Val<::core::time::Duration> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_micros( + let output: Val<::core::time::Duration> = ::core::time::Duration::from_micros( micros, ) .into(); @@ -1017,13 +806,9 @@ pub(crate) fn register_duration_functions(world: &mut World) { .register_documented( "from_millis", |millis: u64| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { + let output: Val<::core::time::Duration> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_millis( + let output: Val<::core::time::Duration> = ::core::time::Duration::from_millis( millis, ) .into(); @@ -1038,13 +823,9 @@ pub(crate) fn register_duration_functions(world: &mut World) { .register_documented( "from_nanos", |nanos: u64| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { + let output: Val<::core::time::Duration> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_nanos( + let output: Val<::core::time::Duration> = ::core::time::Duration::from_nanos( nanos, ) .into(); @@ -1059,13 +840,9 @@ pub(crate) fn register_duration_functions(world: &mut World) { .register_documented( "from_secs", |secs: u64| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { + let output: Val<::core::time::Duration> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_secs( + let output: Val<::core::time::Duration> = ::core::time::Duration::from_secs( secs, ) .into(); @@ -1080,13 +857,9 @@ pub(crate) fn register_duration_functions(world: &mut World) { .register_documented( "from_secs_f32", |secs: f32| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { + let output: Val<::core::time::Duration> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_secs_f32( + let output: Val<::core::time::Duration> = ::core::time::Duration::from_secs_f32( secs, ) .into(); @@ -1101,13 +874,9 @@ pub(crate) fn register_duration_functions(world: &mut World) { .register_documented( "from_secs_f64", |secs: f64| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { + let output: Val<::core::time::Duration> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::from_secs_f64( + let output: Val<::core::time::Duration> = ::core::time::Duration::from_secs_f64( secs, ) .into(); @@ -1121,16 +890,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "is_zero", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { + |_self: Ref<::core::time::Duration>| { let output: bool = { { - let output: bool = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::is_zero( - &_self, - ) + let output: bool = ::core::time::Duration::is_zero(&_self) .into(); output } @@ -1142,19 +905,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "mul", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - rhs: u32| - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { + |_self: Val<::core::time::Duration>, rhs: u32| { + let output: Val<::core::time::Duration> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::core::time::Duration> = <::core::time::Duration as ::core::ops::Mul< u32, >>::mul(_self.into_inner(), rhs) .into(); @@ -1168,19 +922,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "mul_f32", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - rhs: f32| - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { + |_self: Val<::core::time::Duration>, rhs: f32| { + let output: Val<::core::time::Duration> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::mul_f32( + let output: Val<::core::time::Duration> = ::core::time::Duration::mul_f32( _self.into_inner(), rhs, ) @@ -1195,19 +940,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "mul_f64", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - rhs: f64| - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { + |_self: Val<::core::time::Duration>, rhs: f64| { + let output: Val<::core::time::Duration> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::mul_f64( + let output: Val<::core::time::Duration> = ::core::time::Duration::mul_f64( _self.into_inner(), rhs, ) @@ -1223,13 +959,9 @@ pub(crate) fn register_duration_functions(world: &mut World) { .register_documented( "new", |secs: u64, nanos: u32| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { + let output: Val<::core::time::Duration> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::new( + let output: Val<::core::time::Duration> = ::core::time::Duration::new( secs, nanos, ) @@ -1244,21 +976,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "saturating_add", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - rhs: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { + |_self: Val<::core::time::Duration>, rhs: Val<::core::time::Duration>| { + let output: Val<::core::time::Duration> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::saturating_add( + let output: Val<::core::time::Duration> = ::core::time::Duration::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -1273,19 +994,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "saturating_mul", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - rhs: u32| - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { + |_self: Val<::core::time::Duration>, rhs: u32| { + let output: Val<::core::time::Duration> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::saturating_mul( + let output: Val<::core::time::Duration> = ::core::time::Duration::saturating_mul( _self.into_inner(), rhs, ) @@ -1300,21 +1012,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "saturating_sub", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - rhs: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { + |_self: Val<::core::time::Duration>, rhs: Val<::core::time::Duration>| { + let output: Val<::core::time::Duration> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::saturating_sub( + let output: Val<::core::time::Duration> = ::core::time::Duration::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -1329,22 +1030,11 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "sub", - | - _self: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >, - rhs: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + |_self: Val<::core::time::Duration>, rhs: Val<::core::time::Duration>| { + let output: Val<::core::time::Duration> = { + { + let output: Val<::core::time::Duration> = <::core::time::Duration as ::core::ops::Sub< + ::core::time::Duration, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output @@ -1357,16 +1047,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "subsec_micros", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { + |_self: Ref<::core::time::Duration>| { let output: u32 = { { - let output: u32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::subsec_micros( - &_self, - ) + let output: u32 = ::core::time::Duration::subsec_micros(&_self) .into(); output } @@ -1378,16 +1062,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "subsec_millis", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { + |_self: Ref<::core::time::Duration>| { let output: u32 = { { - let output: u32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::subsec_millis( - &_self, - ) + let output: u32 = ::core::time::Duration::subsec_millis(&_self) .into(); output } @@ -1399,16 +1077,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { ) .register_documented( "subsec_nanos", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { + |_self: Ref<::core::time::Duration>| { let output: u32 = { { - let output: u32 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration::subsec_nanos( - &_self, - ) + let output: u32 = ::core::time::Duration::subsec_nanos(&_self) .into(); output } @@ -1421,10 +1093,8 @@ pub(crate) fn register_duration_functions(world: &mut World) { let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); + .register_type_data::<::core::time::Duration, bevy_mod_scripting_bindings::MarkAsGenerated>( + ); } pub(crate) fn register_instant_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -1432,16 +1102,11 @@ pub(crate) fn register_instant_functions(world: &mut World) { >::new(world) .register_documented( "add", - | - _self: Val<::std::time::Instant>, - other: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { + |_self: Val<::std::time::Instant>, other: Val<::core::time::Duration>| { let output: Val<::std::time::Instant> = { { - let output: Val<::std::time::Instant> = <::std::time::Instant as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + let output: Val<::std::time::Instant> = <::std::time::Instant as ::core::ops::Add< + ::core::time::Duration, >>::add(_self.into_inner(), other.into_inner()) .into(); output @@ -1457,7 +1122,7 @@ pub(crate) fn register_instant_functions(world: &mut World) { |_self: Ref<::std::time::Instant>| { let output: () = { { - let output: () = <::std::time::Instant as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::std::time::Instant as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -1474,7 +1139,7 @@ pub(crate) fn register_instant_functions(world: &mut World) { |_self: Ref<::std::time::Instant>| { let output: Val<::std::time::Instant> = { { - let output: Val<::std::time::Instant> = <::std::time::Instant as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::std::time::Instant> = <::std::time::Instant as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -1489,13 +1154,9 @@ pub(crate) fn register_instant_functions(world: &mut World) { .register_documented( "duration_since", |_self: Ref<::std::time::Instant>, earlier: Val<::std::time::Instant>| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { + let output: Val<::core::time::Duration> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::std::time::Instant::duration_since( + let output: Val<::core::time::Duration> = ::std::time::Instant::duration_since( &_self, earlier.into_inner(), ) @@ -1511,13 +1172,12 @@ pub(crate) fn register_instant_functions(world: &mut World) { .register_documented( "elapsed", |_self: Ref<::std::time::Instant>| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { + let output: Val<::core::time::Duration> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::std::time::Instant::elapsed(&_self).into(); + let output: Val<::core::time::Duration> = ::std::time::Instant::elapsed( + &_self, + ) + .into(); output } }; @@ -1531,7 +1191,7 @@ pub(crate) fn register_instant_functions(world: &mut World) { |_self: Ref<::std::time::Instant>, other: Ref<::std::time::Instant>| { let output: bool = { { - let output: bool = <::std::time::Instant as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::std::time::Instant as ::core::cmp::PartialEq< ::std::time::Instant, >>::eq(&_self, &other) .into(); @@ -1561,13 +1221,9 @@ pub(crate) fn register_instant_functions(world: &mut World) { .register_documented( "saturating_duration_since", |_self: Ref<::std::time::Instant>, earlier: Val<::std::time::Instant>| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { + let output: Val<::core::time::Duration> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = ::std::time::Instant::saturating_duration_since( + let output: Val<::core::time::Duration> = ::std::time::Instant::saturating_duration_since( &_self, earlier.into_inner(), ) @@ -1582,16 +1238,11 @@ pub(crate) fn register_instant_functions(world: &mut World) { ) .register_documented( "sub", - | - _self: Val<::std::time::Instant>, - other: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - >| - { + |_self: Val<::std::time::Instant>, other: Val<::core::time::Duration>| { let output: Val<::std::time::Instant> = { { - let output: Val<::std::time::Instant> = <::std::time::Instant as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, + let output: Val<::std::time::Instant> = <::std::time::Instant as ::core::ops::Sub< + ::core::time::Duration, >>::sub(_self.into_inner(), other.into_inner()) .into(); output @@ -1605,13 +1256,9 @@ pub(crate) fn register_instant_functions(world: &mut World) { .register_documented( "sub", |_self: Val<::std::time::Instant>, other: Val<::std::time::Instant>| { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = { + let output: Val<::core::time::Duration> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::time::Duration, - > = <::std::time::Instant as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::core::time::Duration> = <::std::time::Instant as ::core::ops::Sub< ::std::time::Instant, >>::sub(_self.into_inner(), other.into_inner()) .into(); @@ -1630,18 +1277,14 @@ pub(crate) fn register_instant_functions(world: &mut World) { } pub(crate) fn register_range_full_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull, + ::core::ops::RangeFull, >::new(world) .register_documented( "assert_receiver_is_total_eq", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull, - >| - { + |_self: Ref<::core::ops::RangeFull>| { let output: () = { { - let output: () = <::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::core::ops::RangeFull as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -1655,18 +1298,10 @@ pub(crate) fn register_range_full_functions(world: &mut World) { ) .register_documented( "clone", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull, - >| - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull, - > = { + |_self: Ref<::core::ops::RangeFull>| { + let output: Val<::core::ops::RangeFull> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull, - > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::core::ops::RangeFull> = <::core::ops::RangeFull as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -1680,18 +1315,11 @@ pub(crate) fn register_range_full_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull, - >, - other: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull, - >| - { + |_self: Ref<::core::ops::RangeFull>, other: Ref<::core::ops::RangeFull>| { let output: bool = { { - let output: bool = <::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull, + let output: bool = <::core::ops::RangeFull as ::core::cmp::PartialEq< + ::core::ops::RangeFull, >>::eq(&_self, &other) .into(); output @@ -1705,92 +1333,67 @@ pub(crate) fn register_range_full_functions(world: &mut World) { let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::RangeFull, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); + .register_type_data::<::core::ops::RangeFull, bevy_mod_scripting_bindings::MarkAsGenerated>( + ); } pub(crate) fn register_type_id_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId, - >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId, - >| - { - let output: () = { - { - let output: () = <::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId, - >| - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId, - > = { - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId, - > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId, - >, - other: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId, - >| - { - let output: bool = { - { - let output: bool = <::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<::core::any::TypeId>::new( + world, + ) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::core::any::TypeId>| { + let output: () = { + { + let output: () = + <::core::any::TypeId as ::core::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::core::any::TypeId>| { + let output: Val<::core::any::TypeId> = { + { + let output: Val<::core::any::TypeId> = + <::core::any::TypeId as ::core::clone::Clone>::clone(&_self).into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::core::any::TypeId>, other: Ref<::core::any::TypeId>| { + let output: bool = { + { + let output: bool = <::core::any::TypeId as ::core::cmp::PartialEq< + ::core::any::TypeId, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::any::TypeId, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); + .register_type_data::<::core::any::TypeId, bevy_mod_scripting_bindings::MarkAsGenerated>(); } pub(crate) fn register_quat_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -1820,7 +1423,7 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Ref<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Add< &::glam::Quat, >>::add(_self.into_inner(), &rhs) .into(); @@ -1837,7 +1440,7 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Val<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Add< ::glam::Quat, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -1889,7 +1492,7 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Ref<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::Quat> = <::glam::Quat as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -1923,7 +1526,7 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: f32| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -1958,7 +1561,7 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Ref<::glam::Quat>, rhs: Ref<::glam::Quat>| { let output: bool = { { - let output: bool = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::Quat as ::core::cmp::PartialEq< ::glam::Quat, >>::eq(&_self, &rhs) .into(); @@ -2468,7 +2071,7 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Ref<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Mul< &::glam::Quat, >>::mul(_self.into_inner(), &rhs) .into(); @@ -2485,7 +2088,7 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec3> = <::glam::Quat as ::core::ops::Mul< &::glam::Vec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -2502,7 +2105,7 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec3A> = <::glam::Quat as ::core::ops::Mul< &::glam::Vec3A, >>::mul(_self.into_inner(), &rhs) .into(); @@ -2519,7 +2122,7 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Val<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Mul< ::glam::Quat, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -2536,7 +2139,7 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec3> = <::glam::Quat as ::core::ops::Mul< ::glam::Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -2553,7 +2156,7 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec3A> = <::glam::Quat as ::core::ops::Mul< ::glam::Vec3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -2570,7 +2173,7 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: f32| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -2641,7 +2244,7 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -2713,7 +2316,7 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Ref<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Sub< &::glam::Quat, >>::sub(_self.into_inner(), &rhs) .into(); @@ -2730,7 +2333,7 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Val<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Sub< ::glam::Quat, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -2857,7 +2460,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Add< &::glam::Vec3, >>::add(_self.into_inner(), &rhs) .into(); @@ -2874,7 +2477,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Add< ::glam::Vec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -2891,7 +2494,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Add< f32, >>::add(_self.into_inner(), rhs) .into(); @@ -3194,7 +2797,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -3391,7 +2994,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Div< &::glam::Vec3, >>::div(_self.into_inner(), &rhs) .into(); @@ -3408,7 +3011,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Div< ::glam::Vec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -3425,7 +3028,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -3528,7 +3131,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Ref<::glam::Vec3>, other: Ref<::glam::Vec3>| { let output: bool = { { - let output: bool = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::Vec3 as ::core::cmp::PartialEq< ::glam::Vec3, >>::eq(&_self, &other) .into(); @@ -3947,7 +3550,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Mul< &::glam::Vec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -3964,7 +3567,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Mul< ::glam::Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -3981,7 +3584,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -4017,7 +3620,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -4245,7 +3848,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Rem< &::glam::Vec3, >>::rem(_self.into_inner(), &rhs) .into(); @@ -4262,7 +3865,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Rem< ::glam::Vec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -4279,7 +3882,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Rem< f32, >>::rem(_self.into_inner(), rhs) .into(); @@ -4496,7 +4099,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Sub< &::glam::Vec3, >>::sub(_self.into_inner(), &rhs) .into(); @@ -4513,7 +4116,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Sub< ::glam::Vec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -4530,7 +4133,7 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Sub< f32, >>::sub(_self.into_inner(), rhs) .into(); @@ -4667,18 +4270,14 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { } pub(crate) fn register_socket_addr_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, + ::core::net::SocketAddr, >::new(world) .register_documented( "assert_receiver_is_total_eq", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, - >| - { + |_self: Ref<::core::net::SocketAddr>| { let output: () = { { - let output: () = <::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::core::net::SocketAddr as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -4692,18 +4291,10 @@ pub(crate) fn register_socket_addr_functions(world: &mut World) { ) .register_documented( "clone", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, - >| - { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, - > = { + |_self: Ref<::core::net::SocketAddr>| { + let output: Val<::core::net::SocketAddr> = { { - let output: Val< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, - > = <::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::core::net::SocketAddr> = <::core::net::SocketAddr as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -4717,18 +4308,11 @@ pub(crate) fn register_socket_addr_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, - >, - other: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, - >| - { + |_self: Ref<::core::net::SocketAddr>, other: Ref<::core::net::SocketAddr>| { let output: bool = { { - let output: bool = <::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, + let output: bool = <::core::net::SocketAddr as ::core::cmp::PartialEq< + ::core::net::SocketAddr, >>::eq(&_self, &other) .into(); output @@ -4741,16 +4325,10 @@ pub(crate) fn register_socket_addr_functions(world: &mut World) { ) .register_documented( "is_ipv4", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, - >| - { + |_self: Ref<::core::net::SocketAddr>| { let output: bool = { { - let output: bool = ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr::is_ipv4( - &_self, - ) + let output: bool = ::core::net::SocketAddr::is_ipv4(&_self) .into(); output } @@ -4762,16 +4340,10 @@ pub(crate) fn register_socket_addr_functions(world: &mut World) { ) .register_documented( "is_ipv6", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, - >| - { + |_self: Ref<::core::net::SocketAddr>| { let output: bool = { { - let output: bool = ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr::is_ipv6( - &_self, - ) + let output: bool = ::core::net::SocketAddr::is_ipv6(&_self) .into(); output } @@ -4783,17 +4355,10 @@ pub(crate) fn register_socket_addr_functions(world: &mut World) { ) .register_documented( "port", - | - _self: Ref< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, - >| - { + |_self: Ref<::core::net::SocketAddr>| { let output: u16 = { { - let output: u16 = ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr::port( - &_self, - ) - .into(); + let output: u16 = ::core::net::SocketAddr::port(&_self).into(); output } }; @@ -4804,15 +4369,10 @@ pub(crate) fn register_socket_addr_functions(world: &mut World) { ) .register_documented( "set_port", - | - mut _self: Mut< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, - >, - new_port: u16| - { + |mut _self: Mut<::core::net::SocketAddr>, new_port: u16| { let output: () = { { - let output: () = ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr::set_port( + let output: () = ::core::net::SocketAddr::set_port( &mut _self, new_port, ) @@ -4829,7 +4389,7 @@ pub(crate) fn register_socket_addr_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_reflect::__macro_exports::auto_register::inventory::core::net::SocketAddr, + ::core::net::SocketAddr, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -4859,7 +4419,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Ref<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Add< &::glam::IVec2, >>::add(_self.into_inner(), &rhs) .into(); @@ -4876,7 +4436,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Add< ::glam::IVec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -4893,7 +4453,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: i32| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Add< i32, >>::add(_self.into_inner(), rhs) .into(); @@ -5057,7 +4617,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Ref<::glam::IVec2>| { let output: () = { { - let output: () = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::IVec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -5090,13 +4650,9 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u32, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u32, - > = ::glam::IVec2::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::IVec2::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -5137,7 +4693,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Ref<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -5280,7 +4836,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Ref<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Div< &::glam::IVec2, >>::div(_self.into_inner(), &rhs) .into(); @@ -5297,7 +4853,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Div< ::glam::IVec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -5314,7 +4870,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: i32| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Div< i32, >>::div(_self.into_inner(), rhs) .into(); @@ -5417,7 +4973,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Ref<::glam::IVec2>, other: Ref<::glam::IVec2>| { let output: bool = { { - let output: bool = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::IVec2 as ::core::cmp::PartialEq< ::glam::IVec2, >>::eq(&_self, &other) .into(); @@ -5619,7 +5175,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Ref<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Mul< &::glam::IVec2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -5636,7 +5192,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Mul< ::glam::IVec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -5653,7 +5209,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: i32| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Mul< i32, >>::mul(_self.into_inner(), rhs) .into(); @@ -5670,7 +5226,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -5736,7 +5292,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Ref<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Rem< &::glam::IVec2, >>::rem(_self.into_inner(), &rhs) .into(); @@ -5753,7 +5309,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Rem< ::glam::IVec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -5770,7 +5326,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: i32| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Rem< i32, >>::rem(_self.into_inner(), rhs) .into(); @@ -5985,7 +5541,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Ref<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Sub< &::glam::IVec2, >>::sub(_self.into_inner(), &rhs) .into(); @@ -6002,7 +5558,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Sub< ::glam::IVec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -6019,7 +5575,7 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: i32| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Sub< i32, >>::sub(_self.into_inner(), rhs) .into(); @@ -6219,7 +5775,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Ref<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Add< &::glam::IVec3, >>::add(_self.into_inner(), &rhs) .into(); @@ -6236,7 +5792,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Add< ::glam::IVec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -6253,7 +5809,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: i32| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Add< i32, >>::add(_self.into_inner(), rhs) .into(); @@ -6432,7 +5988,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Ref<::glam::IVec3>| { let output: () = { { - let output: () = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::IVec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -6465,13 +6021,9 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u32, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u32, - > = ::glam::IVec3::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::IVec3::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -6512,7 +6064,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Ref<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -6673,7 +6225,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Ref<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Div< &::glam::IVec3, >>::div(_self.into_inner(), &rhs) .into(); @@ -6690,7 +6242,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Div< ::glam::IVec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -6707,7 +6259,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: i32| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Div< i32, >>::div(_self.into_inner(), rhs) .into(); @@ -6810,7 +6362,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Ref<::glam::IVec3>, other: Ref<::glam::IVec3>| { let output: bool = { { - let output: bool = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::IVec3 as ::core::cmp::PartialEq< ::glam::IVec3, >>::eq(&_self, &other) .into(); @@ -7012,7 +6564,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Ref<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Mul< &::glam::IVec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -7029,7 +6581,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Mul< ::glam::IVec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -7046,7 +6598,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: i32| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Mul< i32, >>::mul(_self.into_inner(), rhs) .into(); @@ -7063,7 +6615,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -7095,7 +6647,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Ref<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Rem< &::glam::IVec3, >>::rem(_self.into_inner(), &rhs) .into(); @@ -7112,7 +6664,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Rem< ::glam::IVec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -7129,7 +6681,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: i32| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Rem< i32, >>::rem(_self.into_inner(), rhs) .into(); @@ -7326,7 +6878,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Ref<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Sub< &::glam::IVec3, >>::sub(_self.into_inner(), &rhs) .into(); @@ -7343,7 +6895,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Sub< ::glam::IVec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -7360,7 +6912,7 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: i32| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Sub< i32, >>::sub(_self.into_inner(), rhs) .into(); @@ -7595,7 +7147,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Ref<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Add< &::glam::IVec4, >>::add(_self.into_inner(), &rhs) .into(); @@ -7612,7 +7164,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Add< ::glam::IVec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -7629,7 +7181,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: i32| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Add< i32, >>::add(_self.into_inner(), rhs) .into(); @@ -7793,7 +7345,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Ref<::glam::IVec4>| { let output: () = { { - let output: () = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::IVec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -7826,13 +7378,9 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u32, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u32, - > = ::glam::IVec4::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::IVec4::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -7873,7 +7421,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Ref<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -8016,7 +7564,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Ref<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Div< &::glam::IVec4, >>::div(_self.into_inner(), &rhs) .into(); @@ -8033,7 +7581,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Div< ::glam::IVec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -8050,7 +7598,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: i32| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Div< i32, >>::div(_self.into_inner(), rhs) .into(); @@ -8153,7 +7701,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Ref<::glam::IVec4>, other: Ref<::glam::IVec4>| { let output: bool = { { - let output: bool = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::IVec4 as ::core::cmp::PartialEq< ::glam::IVec4, >>::eq(&_self, &other) .into(); @@ -8337,7 +7885,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Ref<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Mul< &::glam::IVec4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -8354,7 +7902,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Mul< ::glam::IVec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -8371,7 +7919,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: i32| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Mul< i32, >>::mul(_self.into_inner(), rhs) .into(); @@ -8388,7 +7936,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -8420,7 +7968,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Ref<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Rem< &::glam::IVec4, >>::rem(_self.into_inner(), &rhs) .into(); @@ -8437,7 +7985,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Rem< ::glam::IVec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -8454,7 +8002,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: i32| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Rem< i32, >>::rem(_self.into_inner(), rhs) .into(); @@ -8651,7 +8199,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Ref<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Sub< &::glam::IVec4, >>::sub(_self.into_inner(), &rhs) .into(); @@ -8668,7 +8216,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Sub< ::glam::IVec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -8685,7 +8233,7 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: i32| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Sub< i32, >>::sub(_self.into_inner(), rhs) .into(); @@ -8938,7 +8486,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Ref<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Add< &::glam::I8Vec2, >>::add(_self.into_inner(), &rhs) .into(); @@ -8955,7 +8503,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Add< ::glam::I8Vec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -8972,7 +8520,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: i8| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Add< i8, >>::add(_self.into_inner(), rhs) .into(); @@ -9134,7 +8682,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I8Vec2>| { let output: () = { { - let output: () = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::I8Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -9167,13 +8715,9 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u8, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u8, - > = ::glam::I8Vec2::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::I8Vec2::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -9214,7 +8758,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -9357,7 +8901,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Ref<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Div< &::glam::I8Vec2, >>::div(_self.into_inner(), &rhs) .into(); @@ -9374,7 +8918,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Div< ::glam::I8Vec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -9391,7 +8935,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: i8| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Div< i8, >>::div(_self.into_inner(), rhs) .into(); @@ -9494,7 +9038,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I8Vec2>, other: Ref<::glam::I8Vec2>| { let output: bool = { { - let output: bool = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::I8Vec2 as ::core::cmp::PartialEq< ::glam::I8Vec2, >>::eq(&_self, &other) .into(); @@ -9696,7 +9240,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Ref<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Mul< &::glam::I8Vec2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -9713,7 +9257,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Mul< ::glam::I8Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -9730,7 +9274,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: i8| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Mul< i8, >>::mul(_self.into_inner(), rhs) .into(); @@ -9747,7 +9291,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -9814,7 +9358,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Ref<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Rem< &::glam::I8Vec2, >>::rem(_self.into_inner(), &rhs) .into(); @@ -9831,7 +9375,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Rem< ::glam::I8Vec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -9848,7 +9392,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: i8| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Rem< i8, >>::rem(_self.into_inner(), rhs) .into(); @@ -10064,7 +9608,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Ref<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Sub< &::glam::I8Vec2, >>::sub(_self.into_inner(), &rhs) .into(); @@ -10081,7 +9625,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Sub< ::glam::I8Vec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -10098,7 +9642,7 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: i8| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Sub< i8, >>::sub(_self.into_inner(), rhs) .into(); @@ -10298,7 +9842,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Ref<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Add< &::glam::I8Vec3, >>::add(_self.into_inner(), &rhs) .into(); @@ -10315,7 +9859,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Add< ::glam::I8Vec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -10332,7 +9876,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: i8| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Add< i8, >>::add(_self.into_inner(), rhs) .into(); @@ -10509,7 +10053,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I8Vec3>| { let output: () = { { - let output: () = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::I8Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -10542,13 +10086,9 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u8, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u8, - > = ::glam::I8Vec3::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::I8Vec3::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -10589,7 +10129,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -10750,7 +10290,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Ref<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Div< &::glam::I8Vec3, >>::div(_self.into_inner(), &rhs) .into(); @@ -10767,7 +10307,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Div< ::glam::I8Vec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -10784,7 +10324,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: i8| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Div< i8, >>::div(_self.into_inner(), rhs) .into(); @@ -10887,7 +10427,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I8Vec3>, other: Ref<::glam::I8Vec3>| { let output: bool = { { - let output: bool = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::I8Vec3 as ::core::cmp::PartialEq< ::glam::I8Vec3, >>::eq(&_self, &other) .into(); @@ -11089,7 +10629,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Ref<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Mul< &::glam::I8Vec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -11106,7 +10646,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Mul< ::glam::I8Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -11123,7 +10663,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: i8| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Mul< i8, >>::mul(_self.into_inner(), rhs) .into(); @@ -11140,7 +10680,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -11172,7 +10712,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Ref<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Rem< &::glam::I8Vec3, >>::rem(_self.into_inner(), &rhs) .into(); @@ -11189,7 +10729,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Rem< ::glam::I8Vec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -11206,7 +10746,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: i8| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Rem< i8, >>::rem(_self.into_inner(), rhs) .into(); @@ -11404,7 +10944,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Ref<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Sub< &::glam::I8Vec3, >>::sub(_self.into_inner(), &rhs) .into(); @@ -11421,7 +10961,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Sub< ::glam::I8Vec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -11438,7 +10978,7 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: i8| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Sub< i8, >>::sub(_self.into_inner(), rhs) .into(); @@ -11673,7 +11213,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Ref<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Add< &::glam::I8Vec4, >>::add(_self.into_inner(), &rhs) .into(); @@ -11690,7 +11230,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Add< ::glam::I8Vec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -11707,7 +11247,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: i8| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Add< i8, >>::add(_self.into_inner(), rhs) .into(); @@ -11869,7 +11409,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I8Vec4>| { let output: () = { { - let output: () = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::I8Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -11902,13 +11442,9 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u8, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u8, - > = ::glam::I8Vec4::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::I8Vec4::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -11949,7 +11485,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -12092,7 +11628,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Ref<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Div< &::glam::I8Vec4, >>::div(_self.into_inner(), &rhs) .into(); @@ -12109,7 +11645,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Div< ::glam::I8Vec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -12126,7 +11662,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: i8| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Div< i8, >>::div(_self.into_inner(), rhs) .into(); @@ -12229,7 +11765,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I8Vec4>, other: Ref<::glam::I8Vec4>| { let output: bool = { { - let output: bool = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::I8Vec4 as ::core::cmp::PartialEq< ::glam::I8Vec4, >>::eq(&_self, &other) .into(); @@ -12413,7 +11949,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Ref<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Mul< &::glam::I8Vec4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -12430,7 +11966,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Mul< ::glam::I8Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -12447,7 +11983,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: i8| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Mul< i8, >>::mul(_self.into_inner(), rhs) .into(); @@ -12464,7 +12000,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -12496,7 +12032,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Ref<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Rem< &::glam::I8Vec4, >>::rem(_self.into_inner(), &rhs) .into(); @@ -12513,7 +12049,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Rem< ::glam::I8Vec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -12530,7 +12066,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: i8| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Rem< i8, >>::rem(_self.into_inner(), rhs) .into(); @@ -12728,7 +12264,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Ref<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Sub< &::glam::I8Vec4, >>::sub(_self.into_inner(), &rhs) .into(); @@ -12745,7 +12281,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Sub< ::glam::I8Vec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -12762,7 +12298,7 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: i8| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Sub< i8, >>::sub(_self.into_inner(), rhs) .into(); @@ -13015,7 +12551,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Ref<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Add< &::glam::I16Vec2, >>::add(_self.into_inner(), &rhs) .into(); @@ -13032,7 +12568,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Add< ::glam::I16Vec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -13049,7 +12585,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: i16| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Add< i16, >>::add(_self.into_inner(), rhs) .into(); @@ -13217,7 +12753,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I16Vec2>| { let output: () = { { - let output: () = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::I16Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -13250,13 +12786,9 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u16, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u16, - > = ::glam::I16Vec2::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::I16Vec2::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -13297,7 +12829,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -13440,7 +12972,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Ref<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Div< &::glam::I16Vec2, >>::div(_self.into_inner(), &rhs) .into(); @@ -13457,7 +12989,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Div< ::glam::I16Vec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -13474,7 +13006,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: i16| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Div< i16, >>::div(_self.into_inner(), rhs) .into(); @@ -13579,7 +13111,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I16Vec2>, other: Ref<::glam::I16Vec2>| { let output: bool = { { - let output: bool = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::I16Vec2 as ::core::cmp::PartialEq< ::glam::I16Vec2, >>::eq(&_self, &other) .into(); @@ -13785,7 +13317,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Ref<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Mul< &::glam::I16Vec2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -13802,7 +13334,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Mul< ::glam::I16Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -13819,7 +13351,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: i16| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Mul< i16, >>::mul(_self.into_inner(), rhs) .into(); @@ -13836,7 +13368,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -13903,7 +13435,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Ref<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Rem< &::glam::I16Vec2, >>::rem(_self.into_inner(), &rhs) .into(); @@ -13920,7 +13452,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Rem< ::glam::I16Vec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -13937,7 +13469,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: i16| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Rem< i16, >>::rem(_self.into_inner(), rhs) .into(); @@ -14153,7 +13685,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Ref<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Sub< &::glam::I16Vec2, >>::sub(_self.into_inner(), &rhs) .into(); @@ -14170,7 +13702,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Sub< ::glam::I16Vec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -14187,7 +13719,7 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: i16| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Sub< i16, >>::sub(_self.into_inner(), rhs) .into(); @@ -14387,7 +13919,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Ref<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Add< &::glam::I16Vec3, >>::add(_self.into_inner(), &rhs) .into(); @@ -14404,7 +13936,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Add< ::glam::I16Vec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -14421,7 +13953,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: i16| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Add< i16, >>::add(_self.into_inner(), rhs) .into(); @@ -14606,7 +14138,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I16Vec3>| { let output: () = { { - let output: () = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::I16Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -14639,13 +14171,9 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u16, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u16, - > = ::glam::I16Vec3::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::I16Vec3::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -14686,7 +14214,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -14847,7 +14375,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Ref<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Div< &::glam::I16Vec3, >>::div(_self.into_inner(), &rhs) .into(); @@ -14864,7 +14392,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Div< ::glam::I16Vec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -14881,7 +14409,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: i16| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Div< i16, >>::div(_self.into_inner(), rhs) .into(); @@ -14986,7 +14514,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I16Vec3>, other: Ref<::glam::I16Vec3>| { let output: bool = { { - let output: bool = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::I16Vec3 as ::core::cmp::PartialEq< ::glam::I16Vec3, >>::eq(&_self, &other) .into(); @@ -15192,7 +14720,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Ref<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Mul< &::glam::I16Vec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -15209,7 +14737,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Mul< ::glam::I16Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -15226,7 +14754,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: i16| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Mul< i16, >>::mul(_self.into_inner(), rhs) .into(); @@ -15243,7 +14771,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -15275,7 +14803,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Ref<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Rem< &::glam::I16Vec3, >>::rem(_self.into_inner(), &rhs) .into(); @@ -15292,7 +14820,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Rem< ::glam::I16Vec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -15309,7 +14837,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: i16| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Rem< i16, >>::rem(_self.into_inner(), rhs) .into(); @@ -15507,7 +15035,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Ref<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Sub< &::glam::I16Vec3, >>::sub(_self.into_inner(), &rhs) .into(); @@ -15524,7 +15052,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Sub< ::glam::I16Vec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -15541,7 +15069,7 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: i16| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Sub< i16, >>::sub(_self.into_inner(), rhs) .into(); @@ -15776,7 +15304,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Ref<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Add< &::glam::I16Vec4, >>::add(_self.into_inner(), &rhs) .into(); @@ -15793,7 +15321,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Add< ::glam::I16Vec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -15810,7 +15338,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: i16| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Add< i16, >>::add(_self.into_inner(), rhs) .into(); @@ -15978,7 +15506,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I16Vec4>| { let output: () = { { - let output: () = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::I16Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -16011,13 +15539,9 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u16, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u16, - > = ::glam::I16Vec4::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::I16Vec4::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -16058,7 +15582,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -16201,7 +15725,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Ref<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Div< &::glam::I16Vec4, >>::div(_self.into_inner(), &rhs) .into(); @@ -16218,7 +15742,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Div< ::glam::I16Vec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -16235,7 +15759,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: i16| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Div< i16, >>::div(_self.into_inner(), rhs) .into(); @@ -16340,7 +15864,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I16Vec4>, other: Ref<::glam::I16Vec4>| { let output: bool = { { - let output: bool = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::I16Vec4 as ::core::cmp::PartialEq< ::glam::I16Vec4, >>::eq(&_self, &other) .into(); @@ -16528,7 +16052,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Ref<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Mul< &::glam::I16Vec4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -16545,7 +16069,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Mul< ::glam::I16Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -16562,7 +16086,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: i16| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Mul< i16, >>::mul(_self.into_inner(), rhs) .into(); @@ -16579,7 +16103,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -16616,7 +16140,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Ref<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Rem< &::glam::I16Vec4, >>::rem(_self.into_inner(), &rhs) .into(); @@ -16633,7 +16157,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Rem< ::glam::I16Vec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -16650,7 +16174,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: i16| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Rem< i16, >>::rem(_self.into_inner(), rhs) .into(); @@ -16848,7 +16372,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Ref<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Sub< &::glam::I16Vec4, >>::sub(_self.into_inner(), &rhs) .into(); @@ -16865,7 +16389,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Sub< ::glam::I16Vec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -16882,7 +16406,7 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: i16| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Sub< i16, >>::sub(_self.into_inner(), rhs) .into(); @@ -17135,7 +16659,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Ref<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Add< &::glam::I64Vec2, >>::add(_self.into_inner(), &rhs) .into(); @@ -17152,7 +16676,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Add< ::glam::I64Vec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -17169,7 +16693,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: i64| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Add< i64, >>::add(_self.into_inner(), rhs) .into(); @@ -17337,7 +16861,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I64Vec2>| { let output: () = { { - let output: () = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::I64Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -17370,13 +16894,9 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u64, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u64, - > = ::glam::I64Vec2::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::I64Vec2::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -17417,7 +16937,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -17560,7 +17080,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Ref<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Div< &::glam::I64Vec2, >>::div(_self.into_inner(), &rhs) .into(); @@ -17577,7 +17097,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Div< ::glam::I64Vec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -17594,7 +17114,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: i64| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Div< i64, >>::div(_self.into_inner(), rhs) .into(); @@ -17699,7 +17219,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I64Vec2>, other: Ref<::glam::I64Vec2>| { let output: bool = { { - let output: bool = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::I64Vec2 as ::core::cmp::PartialEq< ::glam::I64Vec2, >>::eq(&_self, &other) .into(); @@ -17905,7 +17425,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Ref<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Mul< &::glam::I64Vec2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -17922,7 +17442,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Mul< ::glam::I64Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -17939,7 +17459,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: i64| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Mul< i64, >>::mul(_self.into_inner(), rhs) .into(); @@ -17956,7 +17476,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -18023,7 +17543,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Ref<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Rem< &::glam::I64Vec2, >>::rem(_self.into_inner(), &rhs) .into(); @@ -18040,7 +17560,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Rem< ::glam::I64Vec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -18057,7 +17577,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: i64| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Rem< i64, >>::rem(_self.into_inner(), rhs) .into(); @@ -18273,7 +17793,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Ref<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Sub< &::glam::I64Vec2, >>::sub(_self.into_inner(), &rhs) .into(); @@ -18290,7 +17810,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Sub< ::glam::I64Vec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -18307,7 +17827,7 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: i64| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Sub< i64, >>::sub(_self.into_inner(), rhs) .into(); @@ -18507,7 +18027,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Ref<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Add< &::glam::I64Vec3, >>::add(_self.into_inner(), &rhs) .into(); @@ -18524,7 +18044,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Add< ::glam::I64Vec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -18541,7 +18061,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: i64| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Add< i64, >>::add(_self.into_inner(), rhs) .into(); @@ -18726,7 +18246,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I64Vec3>| { let output: () = { { - let output: () = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::I64Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -18759,13 +18279,9 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u64, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u64, - > = ::glam::I64Vec3::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::I64Vec3::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -18806,7 +18322,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -18967,7 +18483,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Ref<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Div< &::glam::I64Vec3, >>::div(_self.into_inner(), &rhs) .into(); @@ -18984,7 +18500,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Div< ::glam::I64Vec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -19001,7 +18517,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: i64| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Div< i64, >>::div(_self.into_inner(), rhs) .into(); @@ -19106,7 +18622,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I64Vec3>, other: Ref<::glam::I64Vec3>| { let output: bool = { { - let output: bool = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::I64Vec3 as ::core::cmp::PartialEq< ::glam::I64Vec3, >>::eq(&_self, &other) .into(); @@ -19312,7 +18828,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Ref<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Mul< &::glam::I64Vec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -19329,7 +18845,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Mul< ::glam::I64Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -19346,7 +18862,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: i64| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Mul< i64, >>::mul(_self.into_inner(), rhs) .into(); @@ -19363,7 +18879,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -19395,7 +18911,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Ref<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Rem< &::glam::I64Vec3, >>::rem(_self.into_inner(), &rhs) .into(); @@ -19412,7 +18928,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Rem< ::glam::I64Vec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -19429,7 +18945,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: i64| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Rem< i64, >>::rem(_self.into_inner(), rhs) .into(); @@ -19627,7 +19143,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Ref<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Sub< &::glam::I64Vec3, >>::sub(_self.into_inner(), &rhs) .into(); @@ -19644,7 +19160,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Sub< ::glam::I64Vec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -19661,7 +19177,7 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: i64| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Sub< i64, >>::sub(_self.into_inner(), rhs) .into(); @@ -19896,7 +19412,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Ref<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Add< &::glam::I64Vec4, >>::add(_self.into_inner(), &rhs) .into(); @@ -19913,7 +19429,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Add< ::glam::I64Vec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -19930,7 +19446,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: i64| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Add< i64, >>::add(_self.into_inner(), rhs) .into(); @@ -20098,7 +19614,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I64Vec4>| { let output: () = { { - let output: () = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::I64Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -20131,13 +19647,9 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u64, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u64, - > = ::glam::I64Vec4::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::I64Vec4::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -20178,7 +19690,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -20321,7 +19833,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Ref<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Div< &::glam::I64Vec4, >>::div(_self.into_inner(), &rhs) .into(); @@ -20338,7 +19850,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Div< ::glam::I64Vec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -20355,7 +19867,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: i64| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Div< i64, >>::div(_self.into_inner(), rhs) .into(); @@ -20460,7 +19972,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I64Vec4>, other: Ref<::glam::I64Vec4>| { let output: bool = { { - let output: bool = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::I64Vec4 as ::core::cmp::PartialEq< ::glam::I64Vec4, >>::eq(&_self, &other) .into(); @@ -20648,7 +20160,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Ref<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Mul< &::glam::I64Vec4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -20665,7 +20177,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Mul< ::glam::I64Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -20682,7 +20194,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: i64| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Mul< i64, >>::mul(_self.into_inner(), rhs) .into(); @@ -20699,7 +20211,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -20736,7 +20248,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Ref<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Rem< &::glam::I64Vec4, >>::rem(_self.into_inner(), &rhs) .into(); @@ -20753,7 +20265,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Rem< ::glam::I64Vec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -20770,7 +20282,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: i64| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Rem< i64, >>::rem(_self.into_inner(), rhs) .into(); @@ -20968,7 +20480,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Ref<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Sub< &::glam::I64Vec4, >>::sub(_self.into_inner(), &rhs) .into(); @@ -20985,7 +20497,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Sub< ::glam::I64Vec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -21002,7 +20514,7 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: i64| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Sub< i64, >>::sub(_self.into_inner(), rhs) .into(); @@ -21238,7 +20750,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Ref<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Add< &::glam::UVec2, >>::add(_self.into_inner(), &rhs) .into(); @@ -21255,7 +20767,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Add< ::glam::UVec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -21272,7 +20784,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: u32| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Add< u32, >>::add(_self.into_inner(), rhs) .into(); @@ -21436,7 +20948,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Ref<::glam::UVec2>| { let output: () = { { - let output: () = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::UVec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -21469,13 +20981,9 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u32, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u32, - > = ::glam::UVec2::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::UVec2::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -21516,7 +21024,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Ref<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -21641,7 +21149,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Ref<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Div< &::glam::UVec2, >>::div(_self.into_inner(), &rhs) .into(); @@ -21658,7 +21166,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Div< ::glam::UVec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -21675,7 +21183,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: u32| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Div< u32, >>::div(_self.into_inner(), rhs) .into(); @@ -21760,7 +21268,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Ref<::glam::UVec2>, other: Ref<::glam::UVec2>| { let output: bool = { { - let output: bool = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::UVec2 as ::core::cmp::PartialEq< ::glam::UVec2, >>::eq(&_self, &other) .into(); @@ -21945,7 +21453,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Ref<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Mul< &::glam::UVec2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -21962,7 +21470,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Mul< ::glam::UVec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -21979,7 +21487,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: u32| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Mul< u32, >>::mul(_self.into_inner(), rhs) .into(); @@ -22010,7 +21518,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Ref<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Rem< &::glam::UVec2, >>::rem(_self.into_inner(), &rhs) .into(); @@ -22027,7 +21535,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Rem< ::glam::UVec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -22044,7 +21552,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: u32| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Rem< u32, >>::rem(_self.into_inner(), rhs) .into(); @@ -22188,7 +21696,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Ref<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Sub< &::glam::UVec2, >>::sub(_self.into_inner(), &rhs) .into(); @@ -22205,7 +21713,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Sub< ::glam::UVec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -22222,7 +21730,7 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: u32| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Sub< u32, >>::sub(_self.into_inner(), rhs) .into(); @@ -22387,7 +21895,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Ref<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Add< &::glam::UVec3, >>::add(_self.into_inner(), &rhs) .into(); @@ -22404,7 +21912,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Add< ::glam::UVec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -22421,7 +21929,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: u32| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Add< u32, >>::add(_self.into_inner(), rhs) .into(); @@ -22600,7 +22108,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Ref<::glam::UVec3>| { let output: () = { { - let output: () = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::UVec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -22633,13 +22141,9 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u32, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u32, - > = ::glam::UVec3::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::UVec3::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -22680,7 +22184,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Ref<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -22823,7 +22327,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Ref<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Div< &::glam::UVec3, >>::div(_self.into_inner(), &rhs) .into(); @@ -22840,7 +22344,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Div< ::glam::UVec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -22857,7 +22361,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: u32| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Div< u32, >>::div(_self.into_inner(), rhs) .into(); @@ -22942,7 +22446,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Ref<::glam::UVec3>, other: Ref<::glam::UVec3>| { let output: bool = { { - let output: bool = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::UVec3 as ::core::cmp::PartialEq< ::glam::UVec3, >>::eq(&_self, &other) .into(); @@ -23127,7 +22631,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Ref<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Mul< &::glam::UVec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -23144,7 +22648,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Mul< ::glam::UVec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -23161,7 +22665,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: u32| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Mul< u32, >>::mul(_self.into_inner(), rhs) .into(); @@ -23193,7 +22697,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Ref<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Rem< &::glam::UVec3, >>::rem(_self.into_inner(), &rhs) .into(); @@ -23210,7 +22714,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Rem< ::glam::UVec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -23227,7 +22731,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: u32| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Rem< u32, >>::rem(_self.into_inner(), rhs) .into(); @@ -23371,7 +22875,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Ref<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Sub< &::glam::UVec3, >>::sub(_self.into_inner(), &rhs) .into(); @@ -23388,7 +22892,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Sub< ::glam::UVec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -23405,7 +22909,7 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: u32| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Sub< u32, >>::sub(_self.into_inner(), rhs) .into(); @@ -23605,7 +23109,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Ref<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Add< &::glam::UVec4, >>::add(_self.into_inner(), &rhs) .into(); @@ -23622,7 +23126,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Add< ::glam::UVec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -23639,7 +23143,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: u32| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Add< u32, >>::add(_self.into_inner(), rhs) .into(); @@ -23803,7 +23307,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Ref<::glam::UVec4>| { let output: () = { { - let output: () = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::UVec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -23836,13 +23340,9 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u32, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u32, - > = ::glam::UVec4::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::UVec4::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -23883,7 +23383,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Ref<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -24008,7 +23508,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Ref<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Div< &::glam::UVec4, >>::div(_self.into_inner(), &rhs) .into(); @@ -24025,7 +23525,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Div< ::glam::UVec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -24042,7 +23542,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: u32| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Div< u32, >>::div(_self.into_inner(), rhs) .into(); @@ -24127,7 +23627,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Ref<::glam::UVec4>, other: Ref<::glam::UVec4>| { let output: bool = { { - let output: bool = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::UVec4 as ::core::cmp::PartialEq< ::glam::UVec4, >>::eq(&_self, &other) .into(); @@ -24294,7 +23794,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Ref<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Mul< &::glam::UVec4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -24311,7 +23811,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Mul< ::glam::UVec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -24328,7 +23828,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: u32| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Mul< u32, >>::mul(_self.into_inner(), rhs) .into(); @@ -24360,7 +23860,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Ref<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Rem< &::glam::UVec4, >>::rem(_self.into_inner(), &rhs) .into(); @@ -24377,7 +23877,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Rem< ::glam::UVec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -24394,7 +23894,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: u32| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Rem< u32, >>::rem(_self.into_inner(), rhs) .into(); @@ -24538,7 +24038,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Ref<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Sub< &::glam::UVec4, >>::sub(_self.into_inner(), &rhs) .into(); @@ -24555,7 +24055,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Sub< ::glam::UVec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -24572,7 +24072,7 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: u32| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Sub< u32, >>::sub(_self.into_inner(), rhs) .into(); @@ -24790,7 +24290,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Ref<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Add< &::glam::U8Vec2, >>::add(_self.into_inner(), &rhs) .into(); @@ -24807,7 +24307,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Add< ::glam::U8Vec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -24824,7 +24324,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: u8| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Add< u8, >>::add(_self.into_inner(), rhs) .into(); @@ -24986,7 +24486,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U8Vec2>| { let output: () = { { - let output: () = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::U8Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -25019,13 +24519,9 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u8, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u8, - > = ::glam::U8Vec2::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::U8Vec2::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -25066,7 +24562,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -25191,7 +24687,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Ref<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Div< &::glam::U8Vec2, >>::div(_self.into_inner(), &rhs) .into(); @@ -25208,7 +24704,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Div< ::glam::U8Vec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -25225,7 +24721,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: u8| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Div< u8, >>::div(_self.into_inner(), rhs) .into(); @@ -25310,7 +24806,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U8Vec2>, other: Ref<::glam::U8Vec2>| { let output: bool = { { - let output: bool = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::U8Vec2 as ::core::cmp::PartialEq< ::glam::U8Vec2, >>::eq(&_self, &other) .into(); @@ -25495,7 +24991,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Ref<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Mul< &::glam::U8Vec2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -25512,7 +25008,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Mul< ::glam::U8Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -25529,7 +25025,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: u8| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Mul< u8, >>::mul(_self.into_inner(), rhs) .into(); @@ -25561,7 +25057,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Ref<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Rem< &::glam::U8Vec2, >>::rem(_self.into_inner(), &rhs) .into(); @@ -25578,7 +25074,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Rem< ::glam::U8Vec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -25595,7 +25091,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: u8| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Rem< u8, >>::rem(_self.into_inner(), rhs) .into(); @@ -25740,7 +25236,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Ref<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Sub< &::glam::U8Vec2, >>::sub(_self.into_inner(), &rhs) .into(); @@ -25757,7 +25253,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Sub< ::glam::U8Vec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -25774,7 +25270,7 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: u8| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Sub< u8, >>::sub(_self.into_inner(), rhs) .into(); @@ -25939,7 +25435,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Ref<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Add< &::glam::U8Vec3, >>::add(_self.into_inner(), &rhs) .into(); @@ -25956,7 +25452,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Add< ::glam::U8Vec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -25973,7 +25469,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: u8| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Add< u8, >>::add(_self.into_inner(), rhs) .into(); @@ -26150,7 +25646,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U8Vec3>| { let output: () = { { - let output: () = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::U8Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -26183,13 +25679,9 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u8, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u8, - > = ::glam::U8Vec3::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::U8Vec3::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -26230,7 +25722,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -26373,7 +25865,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Ref<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Div< &::glam::U8Vec3, >>::div(_self.into_inner(), &rhs) .into(); @@ -26390,7 +25882,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Div< ::glam::U8Vec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -26407,7 +25899,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: u8| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Div< u8, >>::div(_self.into_inner(), rhs) .into(); @@ -26492,7 +25984,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U8Vec3>, other: Ref<::glam::U8Vec3>| { let output: bool = { { - let output: bool = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::U8Vec3 as ::core::cmp::PartialEq< ::glam::U8Vec3, >>::eq(&_self, &other) .into(); @@ -26677,7 +26169,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Ref<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Mul< &::glam::U8Vec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -26694,7 +26186,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Mul< ::glam::U8Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -26711,7 +26203,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: u8| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Mul< u8, >>::mul(_self.into_inner(), rhs) .into(); @@ -26743,7 +26235,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Ref<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Rem< &::glam::U8Vec3, >>::rem(_self.into_inner(), &rhs) .into(); @@ -26760,7 +26252,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Rem< ::glam::U8Vec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -26777,7 +26269,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: u8| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Rem< u8, >>::rem(_self.into_inner(), rhs) .into(); @@ -26922,7 +26414,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Ref<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Sub< &::glam::U8Vec3, >>::sub(_self.into_inner(), &rhs) .into(); @@ -26939,7 +26431,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Sub< ::glam::U8Vec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -26956,7 +26448,7 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: u8| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Sub< u8, >>::sub(_self.into_inner(), rhs) .into(); @@ -27156,7 +26648,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Ref<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Add< &::glam::U8Vec4, >>::add(_self.into_inner(), &rhs) .into(); @@ -27173,7 +26665,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Add< ::glam::U8Vec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -27190,7 +26682,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: u8| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Add< u8, >>::add(_self.into_inner(), rhs) .into(); @@ -27352,7 +26844,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U8Vec4>| { let output: () = { { - let output: () = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::U8Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -27385,13 +26877,9 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u8, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u8, - > = ::glam::U8Vec4::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::U8Vec4::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -27432,7 +26920,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -27557,7 +27045,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Ref<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Div< &::glam::U8Vec4, >>::div(_self.into_inner(), &rhs) .into(); @@ -27574,7 +27062,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Div< ::glam::U8Vec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -27591,7 +27079,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: u8| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Div< u8, >>::div(_self.into_inner(), rhs) .into(); @@ -27676,7 +27164,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U8Vec4>, other: Ref<::glam::U8Vec4>| { let output: bool = { { - let output: bool = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::U8Vec4 as ::core::cmp::PartialEq< ::glam::U8Vec4, >>::eq(&_self, &other) .into(); @@ -27843,7 +27331,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Ref<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Mul< &::glam::U8Vec4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -27860,7 +27348,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Mul< ::glam::U8Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -27877,7 +27365,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: u8| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Mul< u8, >>::mul(_self.into_inner(), rhs) .into(); @@ -27909,7 +27397,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Ref<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Rem< &::glam::U8Vec4, >>::rem(_self.into_inner(), &rhs) .into(); @@ -27926,7 +27414,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Rem< ::glam::U8Vec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -27943,7 +27431,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: u8| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Rem< u8, >>::rem(_self.into_inner(), rhs) .into(); @@ -28088,7 +27576,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Ref<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Sub< &::glam::U8Vec4, >>::sub(_self.into_inner(), &rhs) .into(); @@ -28105,7 +27593,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Sub< ::glam::U8Vec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -28122,7 +27610,7 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: u8| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Sub< u8, >>::sub(_self.into_inner(), rhs) .into(); @@ -28340,7 +27828,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Ref<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Add< &::glam::U16Vec2, >>::add(_self.into_inner(), &rhs) .into(); @@ -28357,7 +27845,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Add< ::glam::U16Vec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -28374,7 +27862,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: u16| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Add< u16, >>::add(_self.into_inner(), rhs) .into(); @@ -28542,7 +28030,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U16Vec2>| { let output: () = { { - let output: () = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::U16Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -28575,13 +28063,9 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u16, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u16, - > = ::glam::U16Vec2::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::U16Vec2::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -28622,7 +28106,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -28747,7 +28231,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Ref<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Div< &::glam::U16Vec2, >>::div(_self.into_inner(), &rhs) .into(); @@ -28764,7 +28248,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Div< ::glam::U16Vec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -28781,7 +28265,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: u16| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Div< u16, >>::div(_self.into_inner(), rhs) .into(); @@ -28868,7 +28352,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U16Vec2>, other: Ref<::glam::U16Vec2>| { let output: bool = { { - let output: bool = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::U16Vec2 as ::core::cmp::PartialEq< ::glam::U16Vec2, >>::eq(&_self, &other) .into(); @@ -29057,7 +28541,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Ref<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Mul< &::glam::U16Vec2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -29074,7 +28558,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Mul< ::glam::U16Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -29091,7 +28575,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: u16| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Mul< u16, >>::mul(_self.into_inner(), rhs) .into(); @@ -29123,7 +28607,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Ref<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Rem< &::glam::U16Vec2, >>::rem(_self.into_inner(), &rhs) .into(); @@ -29140,7 +28624,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Rem< ::glam::U16Vec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -29157,7 +28641,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: u16| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Rem< u16, >>::rem(_self.into_inner(), rhs) .into(); @@ -29302,7 +28786,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Ref<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Sub< &::glam::U16Vec2, >>::sub(_self.into_inner(), &rhs) .into(); @@ -29319,7 +28803,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Sub< ::glam::U16Vec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -29336,7 +28820,7 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: u16| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Sub< u16, >>::sub(_self.into_inner(), rhs) .into(); @@ -29501,7 +28985,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Ref<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Add< &::glam::U16Vec3, >>::add(_self.into_inner(), &rhs) .into(); @@ -29518,7 +29002,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Add< ::glam::U16Vec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -29535,7 +29019,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: u16| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Add< u16, >>::add(_self.into_inner(), rhs) .into(); @@ -29720,7 +29204,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U16Vec3>| { let output: () = { { - let output: () = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::U16Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -29753,13 +29237,9 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u16, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u16, - > = ::glam::U16Vec3::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::U16Vec3::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -29800,7 +29280,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -29943,7 +29423,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Ref<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Div< &::glam::U16Vec3, >>::div(_self.into_inner(), &rhs) .into(); @@ -29960,7 +29440,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Div< ::glam::U16Vec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -29977,7 +29457,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: u16| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Div< u16, >>::div(_self.into_inner(), rhs) .into(); @@ -30064,7 +29544,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U16Vec3>, other: Ref<::glam::U16Vec3>| { let output: bool = { { - let output: bool = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::U16Vec3 as ::core::cmp::PartialEq< ::glam::U16Vec3, >>::eq(&_self, &other) .into(); @@ -30253,7 +29733,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Ref<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Mul< &::glam::U16Vec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -30270,7 +29750,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Mul< ::glam::U16Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -30287,7 +29767,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: u16| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Mul< u16, >>::mul(_self.into_inner(), rhs) .into(); @@ -30319,7 +29799,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Ref<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Rem< &::glam::U16Vec3, >>::rem(_self.into_inner(), &rhs) .into(); @@ -30336,7 +29816,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Rem< ::glam::U16Vec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -30353,7 +29833,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: u16| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Rem< u16, >>::rem(_self.into_inner(), rhs) .into(); @@ -30498,7 +29978,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Ref<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Sub< &::glam::U16Vec3, >>::sub(_self.into_inner(), &rhs) .into(); @@ -30515,7 +29995,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Sub< ::glam::U16Vec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -30532,7 +30012,7 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: u16| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Sub< u16, >>::sub(_self.into_inner(), rhs) .into(); @@ -30732,7 +30212,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Ref<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Add< &::glam::U16Vec4, >>::add(_self.into_inner(), &rhs) .into(); @@ -30749,7 +30229,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Add< ::glam::U16Vec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -30766,7 +30246,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: u16| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Add< u16, >>::add(_self.into_inner(), rhs) .into(); @@ -30934,7 +30414,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U16Vec4>| { let output: () = { { - let output: () = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::U16Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -30967,13 +30447,9 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u16, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u16, - > = ::glam::U16Vec4::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::U16Vec4::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -31014,7 +30490,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -31139,7 +30615,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Ref<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Div< &::glam::U16Vec4, >>::div(_self.into_inner(), &rhs) .into(); @@ -31156,7 +30632,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Div< ::glam::U16Vec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -31173,7 +30649,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: u16| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Div< u16, >>::div(_self.into_inner(), rhs) .into(); @@ -31260,7 +30736,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U16Vec4>, other: Ref<::glam::U16Vec4>| { let output: bool = { { - let output: bool = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::U16Vec4 as ::core::cmp::PartialEq< ::glam::U16Vec4, >>::eq(&_self, &other) .into(); @@ -31431,7 +30907,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Ref<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Mul< &::glam::U16Vec4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -31448,7 +30924,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Mul< ::glam::U16Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -31465,7 +30941,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: u16| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Mul< u16, >>::mul(_self.into_inner(), rhs) .into(); @@ -31502,7 +30978,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Ref<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Rem< &::glam::U16Vec4, >>::rem(_self.into_inner(), &rhs) .into(); @@ -31519,7 +30995,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Rem< ::glam::U16Vec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -31536,7 +31012,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: u16| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Rem< u16, >>::rem(_self.into_inner(), rhs) .into(); @@ -31681,7 +31157,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Ref<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Sub< &::glam::U16Vec4, >>::sub(_self.into_inner(), &rhs) .into(); @@ -31698,7 +31174,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Sub< ::glam::U16Vec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -31715,7 +31191,7 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: u16| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Sub< u16, >>::sub(_self.into_inner(), rhs) .into(); @@ -31933,7 +31409,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Ref<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Add< &::glam::U64Vec2, >>::add(_self.into_inner(), &rhs) .into(); @@ -31950,7 +31426,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Add< ::glam::U64Vec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -31967,7 +31443,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: u64| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Add< u64, >>::add(_self.into_inner(), rhs) .into(); @@ -32135,7 +31611,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U64Vec2>| { let output: () = { { - let output: () = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::U64Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -32168,13 +31644,9 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u64, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u64, - > = ::glam::U64Vec2::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::U64Vec2::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -32215,7 +31687,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -32340,7 +31812,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Ref<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Div< &::glam::U64Vec2, >>::div(_self.into_inner(), &rhs) .into(); @@ -32357,7 +31829,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Div< ::glam::U64Vec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -32374,7 +31846,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: u64| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Div< u64, >>::div(_self.into_inner(), rhs) .into(); @@ -32461,7 +31933,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U64Vec2>, other: Ref<::glam::U64Vec2>| { let output: bool = { { - let output: bool = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::U64Vec2 as ::core::cmp::PartialEq< ::glam::U64Vec2, >>::eq(&_self, &other) .into(); @@ -32650,7 +32122,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Ref<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Mul< &::glam::U64Vec2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -32667,7 +32139,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Mul< ::glam::U64Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -32684,7 +32156,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: u64| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Mul< u64, >>::mul(_self.into_inner(), rhs) .into(); @@ -32716,7 +32188,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Ref<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Rem< &::glam::U64Vec2, >>::rem(_self.into_inner(), &rhs) .into(); @@ -32733,7 +32205,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Rem< ::glam::U64Vec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -32750,7 +32222,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: u64| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Rem< u64, >>::rem(_self.into_inner(), rhs) .into(); @@ -32895,7 +32367,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Ref<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Sub< &::glam::U64Vec2, >>::sub(_self.into_inner(), &rhs) .into(); @@ -32912,7 +32384,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Sub< ::glam::U64Vec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -32929,7 +32401,7 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: u64| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Sub< u64, >>::sub(_self.into_inner(), rhs) .into(); @@ -33094,7 +32566,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Ref<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Add< &::glam::U64Vec3, >>::add(_self.into_inner(), &rhs) .into(); @@ -33111,7 +32583,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Add< ::glam::U64Vec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -33128,7 +32600,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: u64| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Add< u64, >>::add(_self.into_inner(), rhs) .into(); @@ -33313,7 +32785,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U64Vec3>| { let output: () = { { - let output: () = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::U64Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -33346,13 +32818,9 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u64, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u64, - > = ::glam::U64Vec3::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::U64Vec3::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -33393,7 +32861,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -33536,7 +33004,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Ref<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Div< &::glam::U64Vec3, >>::div(_self.into_inner(), &rhs) .into(); @@ -33553,7 +33021,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Div< ::glam::U64Vec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -33570,7 +33038,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: u64| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Div< u64, >>::div(_self.into_inner(), rhs) .into(); @@ -33657,7 +33125,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U64Vec3>, other: Ref<::glam::U64Vec3>| { let output: bool = { { - let output: bool = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::U64Vec3 as ::core::cmp::PartialEq< ::glam::U64Vec3, >>::eq(&_self, &other) .into(); @@ -33846,7 +33314,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Ref<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Mul< &::glam::U64Vec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -33863,7 +33331,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Mul< ::glam::U64Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -33880,7 +33348,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: u64| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Mul< u64, >>::mul(_self.into_inner(), rhs) .into(); @@ -33912,7 +33380,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Ref<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Rem< &::glam::U64Vec3, >>::rem(_self.into_inner(), &rhs) .into(); @@ -33929,7 +33397,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Rem< ::glam::U64Vec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -33946,7 +33414,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: u64| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Rem< u64, >>::rem(_self.into_inner(), rhs) .into(); @@ -34091,7 +33559,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Ref<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Sub< &::glam::U64Vec3, >>::sub(_self.into_inner(), &rhs) .into(); @@ -34108,7 +33576,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Sub< ::glam::U64Vec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -34125,7 +33593,7 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: u64| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Sub< u64, >>::sub(_self.into_inner(), rhs) .into(); @@ -34325,7 +33793,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Ref<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Add< &::glam::U64Vec4, >>::add(_self.into_inner(), &rhs) .into(); @@ -34342,7 +33810,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Add< ::glam::U64Vec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -34359,7 +33827,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: u64| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Add< u64, >>::add(_self.into_inner(), rhs) .into(); @@ -34527,7 +33995,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U64Vec4>| { let output: () = { { - let output: () = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::U64Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -34560,13 +34028,9 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { .register_documented( "checked_manhattan_distance", |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u64, - > = { + let output: ::core::option::Option = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - u64, - > = ::glam::U64Vec4::checked_manhattan_distance( + let output: ::core::option::Option = ::glam::U64Vec4::checked_manhattan_distance( _self.into_inner(), rhs.into_inner(), ) @@ -34607,7 +34071,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -34732,7 +34196,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Ref<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Div< &::glam::U64Vec4, >>::div(_self.into_inner(), &rhs) .into(); @@ -34749,7 +34213,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Div< ::glam::U64Vec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -34766,7 +34230,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: u64| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Div< u64, >>::div(_self.into_inner(), rhs) .into(); @@ -34853,7 +34317,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U64Vec4>, other: Ref<::glam::U64Vec4>| { let output: bool = { { - let output: bool = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::U64Vec4 as ::core::cmp::PartialEq< ::glam::U64Vec4, >>::eq(&_self, &other) .into(); @@ -35024,7 +34488,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Ref<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Mul< &::glam::U64Vec4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -35041,7 +34505,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Mul< ::glam::U64Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -35058,7 +34522,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: u64| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Mul< u64, >>::mul(_self.into_inner(), rhs) .into(); @@ -35095,7 +34559,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Ref<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Rem< &::glam::U64Vec4, >>::rem(_self.into_inner(), &rhs) .into(); @@ -35112,7 +34576,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Rem< ::glam::U64Vec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -35129,7 +34593,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: u64| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Rem< u64, >>::rem(_self.into_inner(), rhs) .into(); @@ -35274,7 +34738,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Ref<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Sub< &::glam::U64Vec4, >>::sub(_self.into_inner(), &rhs) .into(); @@ -35291,7 +34755,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Sub< ::glam::U64Vec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -35308,7 +34772,7 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: u64| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Sub< u64, >>::sub(_self.into_inner(), rhs) .into(); @@ -35562,7 +35026,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Ref<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Add< &::glam::Vec2, >>::add(_self.into_inner(), &rhs) .into(); @@ -35579,7 +35043,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Add< ::glam::Vec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -35596,7 +35060,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Add< f32, >>::add(_self.into_inner(), rhs) .into(); @@ -35883,7 +35347,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Ref<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -36062,7 +35526,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Ref<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Div< &::glam::Vec2, >>::div(_self.into_inner(), &rhs) .into(); @@ -36079,7 +35543,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Div< ::glam::Vec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -36096,7 +35560,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -36199,7 +35663,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Ref<::glam::Vec2>, other: Ref<::glam::Vec2>| { let output: bool = { { - let output: bool = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::Vec2 as ::core::cmp::PartialEq< ::glam::Vec2, >>::eq(&_self, &other) .into(); @@ -36633,7 +36097,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Ref<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Mul< &::glam::Vec2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -36650,7 +36114,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Mul< ::glam::Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -36667,7 +36131,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -36703,7 +36167,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -36965,7 +36429,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Ref<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Rem< &::glam::Vec2, >>::rem(_self.into_inner(), &rhs) .into(); @@ -36982,7 +36446,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Rem< ::glam::Vec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -36999,7 +36463,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Rem< f32, >>::rem(_self.into_inner(), rhs) .into(); @@ -37142,7 +36606,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Ref<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Sub< &::glam::Vec2, >>::sub(_self.into_inner(), &rhs) .into(); @@ -37159,7 +36623,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Sub< ::glam::Vec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -37176,7 +36640,7 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Sub< f32, >>::sub(_self.into_inner(), rhs) .into(); @@ -37319,7 +36783,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Add< &::glam::Vec3A, >>::add(_self.into_inner(), &rhs) .into(); @@ -37336,7 +36800,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Add< ::glam::Vec3A, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -37353,7 +36817,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Add< f32, >>::add(_self.into_inner(), rhs) .into(); @@ -37664,7 +37128,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -37861,7 +37325,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Div< &::glam::Vec3A, >>::div(_self.into_inner(), &rhs) .into(); @@ -37878,7 +37342,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Div< ::glam::Vec3A, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -37895,7 +37359,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -37998,7 +37462,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::Vec3A>, rhs: Ref<::glam::Vec3A>| { let output: bool = { { - let output: bool = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::Vec3A as ::core::cmp::PartialEq< ::glam::Vec3A, >>::eq(&_self, &rhs) .into(); @@ -38434,7 +37898,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Mul< &::glam::Vec3A, >>::mul(_self.into_inner(), &rhs) .into(); @@ -38451,7 +37915,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Mul< ::glam::Vec3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -38468,7 +37932,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -38504,7 +37968,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -38732,7 +38196,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Rem< &::glam::Vec3A, >>::rem(_self.into_inner(), &rhs) .into(); @@ -38749,7 +38213,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Rem< ::glam::Vec3A, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -38766,7 +38230,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Rem< f32, >>::rem(_self.into_inner(), rhs) .into(); @@ -38983,7 +38447,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Sub< &::glam::Vec3A, >>::sub(_self.into_inner(), &rhs) .into(); @@ -39000,7 +38464,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Sub< ::glam::Vec3A, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -39017,7 +38481,7 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Sub< f32, >>::sub(_self.into_inner(), rhs) .into(); @@ -39197,7 +38661,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Ref<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Add< &::glam::Vec4, >>::add(_self.into_inner(), &rhs) .into(); @@ -39214,7 +38678,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Add< ::glam::Vec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -39231,7 +38695,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Add< f32, >>::add(_self.into_inner(), rhs) .into(); @@ -39482,7 +38946,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Ref<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -39661,7 +39125,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Ref<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Div< &::glam::Vec4, >>::div(_self.into_inner(), &rhs) .into(); @@ -39678,7 +39142,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Div< ::glam::Vec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -39695,7 +39159,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -39798,7 +39262,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Ref<::glam::Vec4>, rhs: Ref<::glam::Vec4>| { let output: bool = { { - let output: bool = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::Vec4 as ::core::cmp::PartialEq< ::glam::Vec4, >>::eq(&_self, &rhs) .into(); @@ -40199,7 +39663,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Ref<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Mul< &::glam::Vec4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -40216,7 +39680,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Mul< ::glam::Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -40233,7 +39697,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -40269,7 +39733,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -40497,7 +39961,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Ref<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Rem< &::glam::Vec4, >>::rem(_self.into_inner(), &rhs) .into(); @@ -40514,7 +39978,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Rem< ::glam::Vec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -40531,7 +39995,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Rem< f32, >>::rem(_self.into_inner(), rhs) .into(); @@ -40637,7 +40101,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Ref<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Sub< &::glam::Vec4, >>::sub(_self.into_inner(), &rhs) .into(); @@ -40654,7 +40118,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Sub< ::glam::Vec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -40671,7 +40135,7 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Sub< f32, >>::sub(_self.into_inner(), rhs) .into(); @@ -40844,7 +40308,7 @@ pub(crate) fn register_b_vec_2_functions(world: &mut World) { |_self: Ref<::glam::BVec2>| { let output: () = { { - let output: () = <::glam::BVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::BVec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -40876,7 +40340,7 @@ pub(crate) fn register_b_vec_2_functions(world: &mut World) { |_self: Ref<::glam::BVec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = <::glam::BVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::BVec2> = <::glam::BVec2 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -40893,7 +40357,7 @@ pub(crate) fn register_b_vec_2_functions(world: &mut World) { |_self: Ref<::glam::BVec2>, other: Ref<::glam::BVec2>| { let output: bool = { { - let output: bool = <::glam::BVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::BVec2 as ::core::cmp::PartialEq< ::glam::BVec2, >>::eq(&_self, &other) .into(); @@ -41018,7 +40482,7 @@ pub(crate) fn register_b_vec_3_functions(world: &mut World) { |_self: Ref<::glam::BVec3>| { let output: () = { { - let output: () = <::glam::BVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::BVec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -41050,7 +40514,7 @@ pub(crate) fn register_b_vec_3_functions(world: &mut World) { |_self: Ref<::glam::BVec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = <::glam::BVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::BVec3> = <::glam::BVec3 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -41067,7 +40531,7 @@ pub(crate) fn register_b_vec_3_functions(world: &mut World) { |_self: Ref<::glam::BVec3>, other: Ref<::glam::BVec3>| { let output: bool = { { - let output: bool = <::glam::BVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::BVec3 as ::core::cmp::PartialEq< ::glam::BVec3, >>::eq(&_self, &other) .into(); @@ -41193,7 +40657,7 @@ pub(crate) fn register_b_vec_4_functions(world: &mut World) { |_self: Ref<::glam::BVec4>| { let output: () = { { - let output: () = <::glam::BVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::glam::BVec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -41225,7 +40689,7 @@ pub(crate) fn register_b_vec_4_functions(world: &mut World) { |_self: Ref<::glam::BVec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = <::glam::BVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::BVec4> = <::glam::BVec4 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -41242,7 +40706,7 @@ pub(crate) fn register_b_vec_4_functions(world: &mut World) { |_self: Ref<::glam::BVec4>, other: Ref<::glam::BVec4>| { let output: bool = { { - let output: bool = <::glam::BVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::BVec4 as ::core::cmp::PartialEq< ::glam::BVec4, >>::eq(&_self, &other) .into(); @@ -41376,7 +40840,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Ref<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Add< &::glam::DVec2, >>::add(_self.into_inner(), &rhs) .into(); @@ -41393,7 +40857,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Add< ::glam::DVec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -41410,7 +40874,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Add< f64, >>::add(_self.into_inner(), rhs) .into(); @@ -41705,7 +41169,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Ref<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -41884,7 +41348,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Ref<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Div< &::glam::DVec2, >>::div(_self.into_inner(), &rhs) .into(); @@ -41901,7 +41365,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Div< ::glam::DVec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -41918,7 +41382,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Div< f64, >>::div(_self.into_inner(), rhs) .into(); @@ -42021,7 +41485,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Ref<::glam::DVec2>, other: Ref<::glam::DVec2>| { let output: bool = { { - let output: bool = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::DVec2 as ::core::cmp::PartialEq< ::glam::DVec2, >>::eq(&_self, &other) .into(); @@ -42455,7 +41919,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Ref<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Mul< &::glam::DVec2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -42472,7 +41936,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Mul< ::glam::DVec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -42489,7 +41953,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Mul< f64, >>::mul(_self.into_inner(), rhs) .into(); @@ -42525,7 +41989,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -42787,7 +42251,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Ref<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Rem< &::glam::DVec2, >>::rem(_self.into_inner(), &rhs) .into(); @@ -42804,7 +42268,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Rem< ::glam::DVec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -42821,7 +42285,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Rem< f64, >>::rem(_self.into_inner(), rhs) .into(); @@ -42964,7 +42428,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Ref<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Sub< &::glam::DVec2, >>::sub(_self.into_inner(), &rhs) .into(); @@ -42981,7 +42445,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Sub< ::glam::DVec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -42998,7 +42462,7 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Sub< f64, >>::sub(_self.into_inner(), rhs) .into(); @@ -43141,7 +42605,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Add< &::glam::DVec3, >>::add(_self.into_inner(), &rhs) .into(); @@ -43158,7 +42622,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Add< ::glam::DVec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -43175,7 +42639,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Add< f64, >>::add(_self.into_inner(), rhs) .into(); @@ -43501,7 +42965,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -43698,7 +43162,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Div< &::glam::DVec3, >>::div(_self.into_inner(), &rhs) .into(); @@ -43715,7 +43179,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Div< ::glam::DVec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -43732,7 +43196,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Div< f64, >>::div(_self.into_inner(), rhs) .into(); @@ -43835,7 +43299,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Ref<::glam::DVec3>, other: Ref<::glam::DVec3>| { let output: bool = { { - let output: bool = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::DVec3 as ::core::cmp::PartialEq< ::glam::DVec3, >>::eq(&_self, &other) .into(); @@ -44254,7 +43718,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Mul< &::glam::DVec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -44271,7 +43735,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Mul< ::glam::DVec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -44288,7 +43752,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Mul< f64, >>::mul(_self.into_inner(), rhs) .into(); @@ -44324,7 +43788,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -44552,7 +44016,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Rem< &::glam::DVec3, >>::rem(_self.into_inner(), &rhs) .into(); @@ -44569,7 +44033,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Rem< ::glam::DVec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -44586,7 +44050,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Rem< f64, >>::rem(_self.into_inner(), rhs) .into(); @@ -44803,7 +44267,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Sub< &::glam::DVec3, >>::sub(_self.into_inner(), &rhs) .into(); @@ -44820,7 +44284,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Sub< ::glam::DVec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -44837,7 +44301,7 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Sub< f64, >>::sub(_self.into_inner(), rhs) .into(); @@ -45000,7 +44464,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Ref<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Add< &::glam::DVec4, >>::add(_self.into_inner(), &rhs) .into(); @@ -45017,7 +44481,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Add< ::glam::DVec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -45034,7 +44498,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Add< f64, >>::add(_self.into_inner(), rhs) .into(); @@ -45293,7 +44757,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Ref<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -45472,7 +44936,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Ref<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Div< &::glam::DVec4, >>::div(_self.into_inner(), &rhs) .into(); @@ -45489,7 +44953,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Div< ::glam::DVec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); @@ -45506,7 +44970,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Div< f64, >>::div(_self.into_inner(), rhs) .into(); @@ -45609,7 +45073,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Ref<::glam::DVec4>, other: Ref<::glam::DVec4>| { let output: bool = { { - let output: bool = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::DVec4 as ::core::cmp::PartialEq< ::glam::DVec4, >>::eq(&_self, &other) .into(); @@ -46010,7 +45474,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Ref<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Mul< &::glam::DVec4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -46027,7 +45491,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Mul< ::glam::DVec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -46044,7 +45508,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Mul< f64, >>::mul(_self.into_inner(), rhs) .into(); @@ -46080,7 +45544,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -46308,7 +45772,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Ref<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Rem< &::glam::DVec4, >>::rem(_self.into_inner(), &rhs) .into(); @@ -46325,7 +45789,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Rem< ::glam::DVec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); @@ -46342,7 +45806,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Rem< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Rem< f64, >>::rem(_self.into_inner(), rhs) .into(); @@ -46448,7 +45912,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Ref<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Sub< &::glam::DVec4, >>::sub(_self.into_inner(), &rhs) .into(); @@ -46465,7 +45929,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Sub< ::glam::DVec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -46482,7 +45946,7 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Sub< f64, >>::sub(_self.into_inner(), rhs) .into(); @@ -46660,7 +46124,7 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>, rhs: Ref<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Add< &::glam::Mat2, >>::add(_self.into_inner(), &rhs) .into(); @@ -46677,7 +46141,7 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>, rhs: Val<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Add< ::glam::Mat2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -46727,7 +46191,7 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Ref<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -46773,7 +46237,7 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>, rhs: f32| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -46808,7 +46272,7 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Ref<::glam::Mat2>, rhs: Ref<::glam::Mat2>| { let output: bool = { { - let output: bool = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::Mat2 as ::core::cmp::PartialEq< ::glam::Mat2, >>::eq(&_self, &rhs) .into(); @@ -47008,7 +46472,7 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>, rhs: Ref<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Mul< &::glam::Mat2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -47025,7 +46489,7 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>, rhs: Ref<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec2> = <::glam::Mat2 as ::core::ops::Mul< &::glam::Vec2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -47042,7 +46506,7 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>, rhs: Val<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Mul< ::glam::Mat2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -47059,7 +46523,7 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec2> = <::glam::Mat2 as ::core::ops::Mul< ::glam::Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -47076,7 +46540,7 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>, rhs: f32| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -47147,7 +46611,7 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -47179,7 +46643,7 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>, rhs: Ref<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Sub< &::glam::Mat2, >>::sub(_self.into_inner(), &rhs) .into(); @@ -47196,7 +46660,7 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>, rhs: Val<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Sub< ::glam::Mat2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -47319,7 +46783,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Ref<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Add< &::glam::Mat3, >>::add(_self.into_inner(), &rhs) .into(); @@ -47336,7 +46800,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Val<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Add< ::glam::Mat3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -47386,7 +46850,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -47432,7 +46896,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: f32| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -47467,7 +46931,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>, rhs: Ref<::glam::Mat3>| { let output: bool = { { - let output: bool = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::Mat3 as ::core::cmp::PartialEq< ::glam::Mat3, >>::eq(&_self, &rhs) .into(); @@ -47868,7 +47332,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Ref<::glam::Affine2>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Mul< &::glam::Affine2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -47885,7 +47349,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Ref<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Mul< &::glam::Mat3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -47902,7 +47366,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec3> = <::glam::Mat3 as ::core::ops::Mul< &::glam::Vec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -47919,7 +47383,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec3A> = <::glam::Mat3 as ::core::ops::Mul< &::glam::Vec3A, >>::mul(_self.into_inner(), &rhs) .into(); @@ -47936,7 +47400,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Val<::glam::Affine2>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Mul< ::glam::Affine2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -47953,7 +47417,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Val<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Mul< ::glam::Mat3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -47970,7 +47434,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec3> = <::glam::Mat3 as ::core::ops::Mul< ::glam::Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -47987,7 +47451,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec3A> = <::glam::Mat3 as ::core::ops::Mul< ::glam::Vec3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -48004,7 +47468,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: f32| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -48093,7 +47557,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -48125,7 +47589,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Ref<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Sub< &::glam::Mat3, >>::sub(_self.into_inner(), &rhs) .into(); @@ -48142,7 +47606,7 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Val<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Sub< ::glam::Mat3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -48320,7 +47784,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Ref<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Add< &::glam::Mat3A, >>::add(_self.into_inner(), &rhs) .into(); @@ -48337,7 +47801,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Val<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Add< ::glam::Mat3A, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -48387,7 +47851,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -48436,7 +47900,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: f32| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -48471,7 +47935,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>, rhs: Ref<::glam::Mat3A>| { let output: bool = { { - let output: bool = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::Mat3A as ::core::cmp::PartialEq< ::glam::Mat3A, >>::eq(&_self, &rhs) .into(); @@ -48872,7 +48336,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Ref<::glam::Affine2>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Mul< &::glam::Affine2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -48889,7 +48353,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Ref<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Mul< &::glam::Mat3A, >>::mul(_self.into_inner(), &rhs) .into(); @@ -48906,7 +48370,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec3> = <::glam::Mat3A as ::core::ops::Mul< &::glam::Vec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -48923,7 +48387,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec3A> = <::glam::Mat3A as ::core::ops::Mul< &::glam::Vec3A, >>::mul(_self.into_inner(), &rhs) .into(); @@ -48940,7 +48404,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Val<::glam::Affine2>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Mul< ::glam::Affine2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -48957,7 +48421,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Val<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Mul< ::glam::Mat3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -48974,7 +48438,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec3> = <::glam::Mat3A as ::core::ops::Mul< ::glam::Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -48991,7 +48455,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec3A> = <::glam::Mat3A as ::core::ops::Mul< ::glam::Vec3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -49008,7 +48472,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: f32| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -49097,7 +48561,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -49132,7 +48596,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Ref<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Sub< &::glam::Mat3A, >>::sub(_self.into_inner(), &rhs) .into(); @@ -49149,7 +48613,7 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Val<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Sub< ::glam::Mat3A, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -49326,7 +48790,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: Ref<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Add< &::glam::Mat4, >>::add(_self.into_inner(), &rhs) .into(); @@ -49343,7 +48807,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: Val<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Add< ::glam::Mat4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -49393,7 +48857,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -49439,7 +48903,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -49474,7 +48938,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>, rhs: Ref<::glam::Mat4>| { let output: bool = { { - let output: bool = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::Mat4 as ::core::cmp::PartialEq< ::glam::Mat4, >>::eq(&_self, &rhs) .into(); @@ -49951,7 +49415,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: Ref<::glam::Affine3A>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Mul< &::glam::Affine3A, >>::mul(_self.into_inner(), &rhs) .into(); @@ -49968,7 +49432,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: Ref<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Mul< &::glam::Mat4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -49985,7 +49449,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: Ref<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec4> = <::glam::Mat4 as ::core::ops::Mul< &::glam::Vec4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -50002,7 +49466,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: Val<::glam::Affine3A>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Mul< ::glam::Affine3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -50019,7 +49483,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: Val<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Mul< ::glam::Mat4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -50036,7 +49500,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Vec4> = <::glam::Mat4 as ::core::ops::Mul< ::glam::Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -50053,7 +49517,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -50124,7 +49588,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -50394,7 +49858,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: Ref<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Sub< &::glam::Mat4, >>::sub(_self.into_inner(), &rhs) .into(); @@ -50411,7 +49875,7 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: Val<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Sub< ::glam::Mat4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -50625,7 +50089,7 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>, rhs: Ref<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Add< &::glam::DMat2, >>::add(_self.into_inner(), &rhs) .into(); @@ -50642,7 +50106,7 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>, rhs: Val<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Add< ::glam::DMat2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -50692,7 +50156,7 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Ref<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -50741,7 +50205,7 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>, rhs: f64| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Div< f64, >>::div(_self.into_inner(), rhs) .into(); @@ -50776,7 +50240,7 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Ref<::glam::DMat2>, rhs: Ref<::glam::DMat2>| { let output: bool = { { - let output: bool = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::DMat2 as ::core::cmp::PartialEq< ::glam::DMat2, >>::eq(&_self, &rhs) .into(); @@ -50940,7 +50404,7 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>, rhs: Ref<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Mul< &::glam::DMat2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -50957,7 +50421,7 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>, rhs: Ref<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DVec2> = <::glam::DMat2 as ::core::ops::Mul< &::glam::DVec2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -50974,7 +50438,7 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>, rhs: Val<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Mul< ::glam::DMat2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -50991,7 +50455,7 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DVec2> = <::glam::DMat2 as ::core::ops::Mul< ::glam::DVec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -51008,7 +50472,7 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>, rhs: f64| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Mul< f64, >>::mul(_self.into_inner(), rhs) .into(); @@ -51079,7 +50543,7 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -51114,7 +50578,7 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>, rhs: Ref<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Sub< &::glam::DMat2, >>::sub(_self.into_inner(), &rhs) .into(); @@ -51131,7 +50595,7 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>, rhs: Val<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Sub< ::glam::DMat2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -51255,7 +50719,7 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: Ref<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Add< &::glam::DMat3, >>::add(_self.into_inner(), &rhs) .into(); @@ -51272,7 +50736,7 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: Val<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Add< ::glam::DMat3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -51322,7 +50786,7 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Ref<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -51371,7 +50835,7 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: f64| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Div< f64, >>::div(_self.into_inner(), rhs) .into(); @@ -51406,7 +50870,7 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Ref<::glam::DMat3>, rhs: Ref<::glam::DMat3>| { let output: bool = { { - let output: bool = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::DMat3 as ::core::cmp::PartialEq< ::glam::DMat3, >>::eq(&_self, &rhs) .into(); @@ -51815,7 +51279,7 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: Ref<::glam::DAffine2>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Mul< &::glam::DAffine2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -51832,7 +51296,7 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: Ref<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Mul< &::glam::DMat3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -51849,7 +51313,7 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DVec3> = <::glam::DMat3 as ::core::ops::Mul< &::glam::DVec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -51866,7 +51330,7 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: Val<::glam::DAffine2>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Mul< ::glam::DAffine2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -51883,7 +51347,7 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: Val<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Mul< ::glam::DMat3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -51900,7 +51364,7 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DVec3> = <::glam::DMat3 as ::core::ops::Mul< ::glam::DVec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -51917,7 +51381,7 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: f64| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Mul< f64, >>::mul(_self.into_inner(), rhs) .into(); @@ -51988,7 +51452,7 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -52023,7 +51487,7 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: Ref<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Sub< &::glam::DMat3, >>::sub(_self.into_inner(), &rhs) .into(); @@ -52040,7 +51504,7 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: Val<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Sub< ::glam::DMat3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -52218,7 +51682,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: Ref<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Add< &::glam::DMat4, >>::add(_self.into_inner(), &rhs) .into(); @@ -52235,7 +51699,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: Val<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Add< ::glam::DMat4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -52285,7 +51749,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -52334,7 +51798,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Div< f64, >>::div(_self.into_inner(), rhs) .into(); @@ -52369,7 +51833,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>, rhs: Ref<::glam::DMat4>| { let output: bool = { { - let output: bool = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::DMat4 as ::core::cmp::PartialEq< ::glam::DMat4, >>::eq(&_self, &rhs) .into(); @@ -52837,7 +52301,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: Ref<::glam::DAffine3>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Mul< &::glam::DAffine3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -52854,7 +52318,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: Ref<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Mul< &::glam::DMat4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -52871,7 +52335,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: Ref<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DVec4> = <::glam::DMat4 as ::core::ops::Mul< &::glam::DVec4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -52888,7 +52352,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: Val<::glam::DAffine3>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Mul< ::glam::DAffine3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -52905,7 +52369,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: Val<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Mul< ::glam::DMat4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -52922,7 +52386,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DVec4> = <::glam::DMat4 as ::core::ops::Mul< ::glam::DVec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -52939,7 +52403,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Mul< f64, >>::mul(_self.into_inner(), rhs) .into(); @@ -53010,7 +52474,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -53265,7 +52729,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: Ref<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Sub< &::glam::DMat4, >>::sub(_self.into_inner(), &rhs) .into(); @@ -53282,7 +52746,7 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: Val<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Sub< ::glam::DMat4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -53462,7 +52926,7 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Ref<::glam::Affine2>| { let output: Val<::glam::Affine2> = { { - let output: Val<::glam::Affine2> = <::glam::Affine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::Affine2> = <::glam::Affine2 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -53479,7 +52943,7 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Ref<::glam::Affine2>, rhs: Ref<::glam::Affine2>| { let output: bool = { { - let output: bool = <::glam::Affine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::Affine2 as ::core::cmp::PartialEq< ::glam::Affine2, >>::eq(&_self, &rhs) .into(); @@ -53721,7 +53185,7 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Val<::glam::Affine2>, rhs: Ref<::glam::Affine2>| { let output: Val<::glam::Affine2> = { { - let output: Val<::glam::Affine2> = <::glam::Affine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Affine2> = <::glam::Affine2 as ::core::ops::Mul< &::glam::Affine2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -53738,7 +53202,7 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Val<::glam::Affine2>, rhs: Ref<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Affine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat3> = <::glam::Affine2 as ::core::ops::Mul< &::glam::Mat3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -53755,7 +53219,7 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Val<::glam::Affine2>, rhs: Ref<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Affine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat3A> = <::glam::Affine2 as ::core::ops::Mul< &::glam::Mat3A, >>::mul(_self.into_inner(), &rhs) .into(); @@ -53772,7 +53236,7 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Val<::glam::Affine2>, rhs: Val<::glam::Affine2>| { let output: Val<::glam::Affine2> = { { - let output: Val<::glam::Affine2> = <::glam::Affine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Affine2> = <::glam::Affine2 as ::core::ops::Mul< ::glam::Affine2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -53789,7 +53253,7 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Val<::glam::Affine2>, rhs: Val<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Affine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat3> = <::glam::Affine2 as ::core::ops::Mul< ::glam::Mat3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -53806,7 +53270,7 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Val<::glam::Affine2>, rhs: Val<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Affine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat3A> = <::glam::Affine2 as ::core::ops::Mul< ::glam::Mat3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -53939,7 +53403,7 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |_self: Ref<::glam::Affine3A>| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = <::glam::Affine3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::Affine3A> = <::glam::Affine3A as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -53956,7 +53420,7 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |_self: Ref<::glam::Affine3A>, rhs: Ref<::glam::Affine3A>| { let output: bool = { { - let output: bool = <::glam::Affine3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::Affine3A as ::core::cmp::PartialEq< ::glam::Affine3A, >>::eq(&_self, &rhs) .into(); @@ -54332,7 +53796,7 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |_self: Val<::glam::Affine3A>, rhs: Ref<::glam::Affine3A>| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = <::glam::Affine3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Affine3A> = <::glam::Affine3A as ::core::ops::Mul< &::glam::Affine3A, >>::mul(_self.into_inner(), &rhs) .into(); @@ -54349,7 +53813,7 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |_self: Val<::glam::Affine3A>, rhs: Ref<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Affine3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat4> = <::glam::Affine3A as ::core::ops::Mul< &::glam::Mat4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -54366,7 +53830,7 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |_self: Val<::glam::Affine3A>, rhs: Val<::glam::Affine3A>| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = <::glam::Affine3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Affine3A> = <::glam::Affine3A as ::core::ops::Mul< ::glam::Affine3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -54383,7 +53847,7 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |_self: Val<::glam::Affine3A>, rhs: Val<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Affine3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::Mat4> = <::glam::Affine3A as ::core::ops::Mul< ::glam::Mat4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -54552,7 +54016,7 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |_self: Ref<::glam::DAffine2>| { let output: Val<::glam::DAffine2> = { { - let output: Val<::glam::DAffine2> = <::glam::DAffine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::DAffine2> = <::glam::DAffine2 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -54569,7 +54033,7 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |_self: Ref<::glam::DAffine2>, rhs: Ref<::glam::DAffine2>| { let output: bool = { { - let output: bool = <::glam::DAffine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::DAffine2 as ::core::cmp::PartialEq< ::glam::DAffine2, >>::eq(&_self, &rhs) .into(); @@ -54794,7 +54258,7 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |_self: Val<::glam::DAffine2>, rhs: Ref<::glam::DAffine2>| { let output: Val<::glam::DAffine2> = { { - let output: Val<::glam::DAffine2> = <::glam::DAffine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DAffine2> = <::glam::DAffine2 as ::core::ops::Mul< &::glam::DAffine2, >>::mul(_self.into_inner(), &rhs) .into(); @@ -54811,7 +54275,7 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |_self: Val<::glam::DAffine2>, rhs: Ref<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DAffine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DMat3> = <::glam::DAffine2 as ::core::ops::Mul< &::glam::DMat3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -54828,7 +54292,7 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |_self: Val<::glam::DAffine2>, rhs: Val<::glam::DAffine2>| { let output: Val<::glam::DAffine2> = { { - let output: Val<::glam::DAffine2> = <::glam::DAffine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DAffine2> = <::glam::DAffine2 as ::core::ops::Mul< ::glam::DAffine2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -54845,7 +54309,7 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |_self: Val<::glam::DAffine2>, rhs: Val<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DAffine2 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DMat3> = <::glam::DAffine2 as ::core::ops::Mul< ::glam::DMat3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -54978,7 +54442,7 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |_self: Ref<::glam::DAffine3>| { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = <::glam::DAffine3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::DAffine3> = <::glam::DAffine3 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -54995,7 +54459,7 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |_self: Ref<::glam::DAffine3>, rhs: Ref<::glam::DAffine3>| { let output: bool = { { - let output: bool = <::glam::DAffine3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::DAffine3 as ::core::cmp::PartialEq< ::glam::DAffine3, >>::eq(&_self, &rhs) .into(); @@ -55379,7 +54843,7 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |_self: Val<::glam::DAffine3>, rhs: Ref<::glam::DAffine3>| { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = <::glam::DAffine3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DAffine3> = <::glam::DAffine3 as ::core::ops::Mul< &::glam::DAffine3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -55396,7 +54860,7 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |_self: Val<::glam::DAffine3>, rhs: Ref<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DAffine3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DMat4> = <::glam::DAffine3 as ::core::ops::Mul< &::glam::DMat4, >>::mul(_self.into_inner(), &rhs) .into(); @@ -55413,7 +54877,7 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |_self: Val<::glam::DAffine3>, rhs: Val<::glam::DAffine3>| { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = <::glam::DAffine3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DAffine3> = <::glam::DAffine3 as ::core::ops::Mul< ::glam::DAffine3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -55430,7 +54894,7 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |_self: Val<::glam::DAffine3>, rhs: Val<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DAffine3 as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DMat4> = <::glam::DAffine3 as ::core::ops::Mul< ::glam::DMat4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -55542,7 +55006,7 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: Ref<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Add< &::glam::DQuat, >>::add(_self.into_inner(), &rhs) .into(); @@ -55559,7 +55023,7 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: Val<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Add< + let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Add< ::glam::DQuat, >>::add(_self.into_inner(), rhs.into_inner()) .into(); @@ -55611,7 +55075,7 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Ref<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -55645,7 +55109,7 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: f64| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Div< + let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Div< f64, >>::div(_self.into_inner(), rhs) .into(); @@ -55680,7 +55144,7 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Ref<::glam::DQuat>, rhs: Ref<::glam::DQuat>| { let output: bool = { { - let output: bool = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::DQuat as ::core::cmp::PartialEq< ::glam::DQuat, >>::eq(&_self, &rhs) .into(); @@ -56183,7 +55647,7 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: Ref<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Mul< &::glam::DQuat, >>::mul(_self.into_inner(), &rhs) .into(); @@ -56200,7 +55664,7 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DVec3> = <::glam::DQuat as ::core::ops::Mul< &::glam::DVec3, >>::mul(_self.into_inner(), &rhs) .into(); @@ -56217,7 +55681,7 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: Val<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Mul< ::glam::DQuat, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -56234,7 +55698,7 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DVec3> = <::glam::DQuat as ::core::ops::Mul< ::glam::DVec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); @@ -56251,7 +55715,7 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: f64| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Mul< + let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Mul< f64, >>::mul(_self.into_inner(), rhs) .into(); @@ -56304,7 +55768,7 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Neg>::neg( + let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -56376,7 +55840,7 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: Ref<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Sub< &::glam::DQuat, >>::sub(_self.into_inner(), &rhs) .into(); @@ -56393,7 +55857,7 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: Val<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::bevy_reflect::__macro_exports::auto_register::inventory::core::ops::Sub< + let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Sub< ::glam::DQuat, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); @@ -56476,60 +55940,57 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { registry.register_type_data::<::glam::DQuat, bevy_mod_scripting_bindings::MarkAsGenerated>(); } pub(crate) fn register_euler_rot_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::glam::EulerRot, - >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::glam::EulerRot>| { - let output: () = { - { - let output: () = <::glam::EulerRot as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::glam::EulerRot>| { - let output: Val<::glam::EulerRot> = { - { - let output: Val<::glam::EulerRot> = <::glam::EulerRot as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::glam::EulerRot>, other: Ref<::glam::EulerRot>| { - let output: bool = { - { - let output: bool = <::glam::EulerRot as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< - ::glam::EulerRot, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<::glam::EulerRot>::new( + world, + ) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::glam::EulerRot>| { + let output: () = { + { + let output: () = + <::glam::EulerRot as ::core::cmp::Eq>::assert_receiver_is_total_eq(&_self) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::glam::EulerRot>| { + let output: Val<::glam::EulerRot> = { + { + let output: Val<::glam::EulerRot> = + <::glam::EulerRot as ::core::clone::Clone>::clone(&_self).into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::glam::EulerRot>, other: Ref<::glam::EulerRot>| { + let output: bool = { + { + let output: bool = <::glam::EulerRot as ::core::cmp::PartialEq< + ::glam::EulerRot, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry.register_type_data::<::glam::EulerRot, bevy_mod_scripting_bindings::MarkAsGenerated>(); @@ -56588,7 +56049,7 @@ pub(crate) fn register_b_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::BVec3A>| { let output: Val<::glam::BVec3A> = { { - let output: Val<::glam::BVec3A> = <::glam::BVec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::BVec3A> = <::glam::BVec3A as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -56605,7 +56066,7 @@ pub(crate) fn register_b_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::BVec3A>, rhs: Ref<::glam::BVec3A>| { let output: bool = { { - let output: bool = <::glam::BVec3A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::BVec3A as ::core::cmp::PartialEq< ::glam::BVec3A, >>::eq(&_self, &rhs) .into(); @@ -56749,7 +56210,7 @@ pub(crate) fn register_b_vec_4_a_functions(world: &mut World) { |_self: Ref<::glam::BVec4A>| { let output: Val<::glam::BVec4A> = { { - let output: Val<::glam::BVec4A> = <::glam::BVec4A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::glam::BVec4A> = <::glam::BVec4A as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -56766,7 +56227,7 @@ pub(crate) fn register_b_vec_4_a_functions(world: &mut World) { |_self: Ref<::glam::BVec4A>, rhs: Ref<::glam::BVec4A>| { let output: bool = { { - let output: bool = <::glam::BVec4A as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::glam::BVec4A as ::core::cmp::PartialEq< ::glam::BVec4A, >>::eq(&_self, &rhs) .into(); @@ -56857,103 +56318,98 @@ pub(crate) fn register_b_vec_4_a_functions(world: &mut World) { registry.register_type_data::<::glam::BVec4A, bevy_mod_scripting_bindings::MarkAsGenerated>(); } pub(crate) fn register_smol_str_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::smol_str::SmolStr, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::smol_str::SmolStr>| { - let output: Val<::smol_str::SmolStr> = { - { - let output: Val<::smol_str::SmolStr> = <::smol_str::SmolStr as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::smol_str::SmolStr>, other: Ref<::smol_str::SmolStr>| { - let output: bool = { - { - let output: bool = <::smol_str::SmolStr as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< - ::smol_str::SmolStr, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "is_empty", - |_self: Ref<::smol_str::SmolStr>| { - let output: bool = { - { - let output: bool = ::smol_str::SmolStr::is_empty(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "is_heap_allocated", - |_self: Ref<::smol_str::SmolStr>| { - let output: bool = { - { - let output: bool = ::smol_str::SmolStr::is_heap_allocated(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "len", - |_self: Ref<::smol_str::SmolStr>| { - let output: usize = { - { - let output: usize = ::smol_str::SmolStr::len(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "to_string", - |_self: Ref<::smol_str::SmolStr>| { - let output: ::std::string::String = { - { - let output: ::std::string::String = ::smol_str::SmolStr::to_string( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<::smol_str::SmolStr>::new( + world, + ) + .register_documented( + "clone", + |_self: Ref<::smol_str::SmolStr>| { + let output: Val<::smol_str::SmolStr> = { + { + let output: Val<::smol_str::SmolStr> = + <::smol_str::SmolStr as ::core::clone::Clone>::clone(&_self).into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::smol_str::SmolStr>, other: Ref<::smol_str::SmolStr>| { + let output: bool = { + { + let output: bool = <::smol_str::SmolStr as ::core::cmp::PartialEq< + ::smol_str::SmolStr, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "is_empty", + |_self: Ref<::smol_str::SmolStr>| { + let output: bool = { + { + let output: bool = ::smol_str::SmolStr::is_empty(&_self).into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "is_heap_allocated", + |_self: Ref<::smol_str::SmolStr>| { + let output: bool = { + { + let output: bool = ::smol_str::SmolStr::is_heap_allocated(&_self).into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "len", + |_self: Ref<::smol_str::SmolStr>| { + let output: usize = { + { + let output: usize = ::smol_str::SmolStr::len(&_self).into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "to_string", + |_self: Ref<::smol_str::SmolStr>| { + let output: ::std::string::String = { + { + let output: ::std::string::String = + ::smol_str::SmolStr::to_string(&_self).into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -56997,7 +56453,7 @@ pub(crate) fn register_uuid_functions(world: &mut World) { |_self: Ref<::uuid::Uuid>| { let output: () = { { - let output: () = <::uuid::Uuid as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( + let output: () = <::uuid::Uuid as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -57014,7 +56470,7 @@ pub(crate) fn register_uuid_functions(world: &mut World) { |_self: Ref<::uuid::Uuid>| { let output: Val<::uuid::Uuid> = { { - let output: Val<::uuid::Uuid> = <::uuid::Uuid as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( + let output: Val<::uuid::Uuid> = <::uuid::Uuid as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -57045,7 +56501,7 @@ pub(crate) fn register_uuid_functions(world: &mut World) { |_self: Ref<::uuid::Uuid>, other: Ref<::uuid::NonNilUuid>| { let output: bool = { { - let output: bool = <::uuid::Uuid as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::uuid::Uuid as ::core::cmp::PartialEq< ::uuid::NonNilUuid, >>::eq(&_self, &other) .into(); @@ -57062,7 +56518,7 @@ pub(crate) fn register_uuid_functions(world: &mut World) { |_self: Ref<::uuid::Uuid>, other: Ref<::uuid::Uuid>| { let output: bool = { { - let output: bool = <::uuid::Uuid as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< + let output: bool = <::uuid::Uuid as ::core::cmp::PartialEq< ::uuid::Uuid, >>::eq(&_self, &other) .into(); @@ -57155,13 +56611,12 @@ pub(crate) fn register_uuid_functions(world: &mut World) { .register_documented( "get_node_id", |_self: Ref<::uuid::Uuid>| { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - [u8; 6], - > = { + let output: ::core::option::Option<[u8; 6]> = { { - let output: ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Option< - [u8; 6], - > = ::uuid::Uuid::get_node_id(&_self).into(); + let output: ::core::option::Option<[u8; 6]> = ::uuid::Uuid::get_node_id( + &_self, + ) + .into(); output } }; @@ -57304,94 +56759,91 @@ pub(crate) fn register_uuid_functions(world: &mut World) { registry.register_type_data::<::uuid::Uuid, bevy_mod_scripting_bindings::MarkAsGenerated>(); } pub(crate) fn register_non_nil_uuid_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::uuid::NonNilUuid, - >::new(world) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::uuid::NonNilUuid>| { - let output: () = { - { - let output: () = <::uuid::NonNilUuid as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::uuid::NonNilUuid>| { - let output: Val<::uuid::NonNilUuid> = { - { - let output: Val<::uuid::NonNilUuid> = <::uuid::NonNilUuid as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::uuid::NonNilUuid>, other: Ref<::uuid::NonNilUuid>| { - let output: bool = { - { - let output: bool = <::uuid::NonNilUuid as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< - ::uuid::NonNilUuid, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "eq", - |_self: Ref<::uuid::NonNilUuid>, other: Ref<::uuid::Uuid>| { - let output: bool = { - { - let output: bool = <::uuid::NonNilUuid as ::bevy_reflect::__macro_exports::auto_register::inventory::core::prelude::v1::PartialEq< - ::uuid::Uuid, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "get", - |_self: Val<::uuid::NonNilUuid>| { - let output: Val<::uuid::Uuid> = { - { - let output: Val<::uuid::Uuid> = ::uuid::NonNilUuid::get( - _self.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Get the underlying [`Uuid`] value.", - &["_self"], - ); + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<::uuid::NonNilUuid>::new( + world, + ) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::uuid::NonNilUuid>| { + let output: () = { + { + let output: () = + <::uuid::NonNilUuid as ::core::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::uuid::NonNilUuid>| { + let output: Val<::uuid::NonNilUuid> = { + { + let output: Val<::uuid::NonNilUuid> = + <::uuid::NonNilUuid as ::core::clone::Clone>::clone(&_self).into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::uuid::NonNilUuid>, other: Ref<::uuid::NonNilUuid>| { + let output: bool = { + { + let output: bool = <::uuid::NonNilUuid as ::core::cmp::PartialEq< + ::uuid::NonNilUuid, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "eq", + |_self: Ref<::uuid::NonNilUuid>, other: Ref<::uuid::Uuid>| { + let output: bool = { + { + let output: bool = <::uuid::NonNilUuid as ::core::cmp::PartialEq< + ::uuid::Uuid, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "get", + |_self: Val<::uuid::NonNilUuid>| { + let output: Val<::uuid::Uuid> = { + { + let output: Val<::uuid::Uuid> = + ::uuid::NonNilUuid::get(_self.into_inner()).into(); + output + } + }; + output + }, + " Get the underlying [`Uuid`] value.", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry diff --git a/crates/bindings/bevy_render_bms_bindings/Cargo.toml b/crates/bindings/bevy_render_bms_bindings/Cargo.toml index 2f5dcf3226..00a707b93a 100644 --- a/crates/bindings/bevy_render_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_render_bms_bindings/Cargo.toml @@ -56,7 +56,7 @@ bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-f bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} diff --git a/crates/bindings/bevy_render_bms_bindings/src/lib.rs b/crates/bindings/bevy_render_bms_bindings/src/lib.rs index 050655fe7a..2fdb6b509d 100644 --- a/crates/bindings/bevy_render_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_render_bms_bindings/src/lib.rs @@ -585,27 +585,6 @@ pub(crate) fn register_temporal_jitter_functions(world: &mut World) { }, "", &["_self"], - ) - .register_documented( - "jitter_projection", - |_self: Ref<::bevy_render::camera::TemporalJitter>, - mut clip_from_view: Mut<::bevy_math::Mat4>, - view_size: Val<::bevy_math::Vec2>| { - let output: () = { - { - let output: () = ::bevy_render::camera::TemporalJitter::jitter_projection( - &_self, - &mut clip_from_view, - view_size.into_inner(), - ) - .into(); - output - } - }; - output - }, - "", - &["_self", "clip_from_view", "view_size"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); diff --git a/crates/bindings/bevy_scene_bms_bindings/Cargo.toml b/crates/bindings/bevy_scene_bms_bindings/Cargo.toml index 16d3bd9906..334a1766ff 100644 --- a/crates/bindings/bevy_scene_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_scene_bms_bindings/Cargo.toml @@ -36,7 +36,7 @@ bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "a bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} serde = { version = "^1.0", features = [], default-features = true} diff --git a/crates/bindings/bevy_sprite_bms_bindings/src/lib.rs b/crates/bindings/bevy_sprite_bms_bindings/src/lib.rs index f47b492175..03c8955388 100644 --- a/crates/bindings/bevy_sprite_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_sprite_bms_bindings/src/lib.rs @@ -130,21 +130,6 @@ pub(crate) fn register_sprite_functions(world: &mut World) { }, "", &["_self"], - ) - .register_documented( - "sized", - |custom_size: Val<::bevy_math::Vec2>| { - let output: Val<::bevy_sprite::prelude::Sprite> = { - { - let output: Val<::bevy_sprite::prelude::Sprite> = - ::bevy_sprite::prelude::Sprite::sized(custom_size.into_inner()).into(); - output - } - }; - output - }, - " Create a Sprite with a custom size", - &["custom_size"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -527,23 +512,6 @@ pub(crate) fn register_anchor_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_sprite::Anchor, >::new(world) - .register_documented( - "as_vec", - |_self: Ref<::bevy_sprite::Anchor>| { - let output: Val<::bevy_math::Vec2> = { - { - let output: Val<::bevy_math::Vec2> = ::bevy_sprite::Anchor::as_vec( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) .register_documented( "clone", |_self: Ref<::bevy_sprite::Anchor>| { diff --git a/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml b/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml index c8f098bf41..c037728a5f 100644 --- a/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml @@ -52,7 +52,7 @@ bevy_text = { version = "^0.17.2", features = ["default_font"], default-features bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_sprite_render_bms_bindings/src/lib.rs b/crates/bindings/bevy_sprite_render_bms_bindings/src/lib.rs index 1886204657..d4be6265be 100644 --- a/crates/bindings/bevy_sprite_render_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_sprite_render_bms_bindings/src/lib.rs @@ -392,25 +392,6 @@ pub(crate) fn register_tilemap_chunk_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_sprite_render::TilemapChunk, >::new(world) - .register_documented( - "calculate_tile_transform", - |_self: Ref<::bevy_sprite_render::TilemapChunk>, position: Val<::bevy_math::UVec2>| { - let output: Val<::bevy_transform::components::Transform> = { - { - let output: Val<::bevy_transform::components::Transform> = - ::bevy_sprite_render::TilemapChunk::calculate_tile_transform( - &_self, - position.into_inner(), - ) - .into(); - output - } - }; - output - }, - "", - &["_self", "position"], - ) .register_documented( "clone", |_self: Ref<::bevy_sprite_render::TilemapChunk>| { diff --git a/crates/bindings/bevy_text_bms_bindings/Cargo.toml b/crates/bindings/bevy_text_bms_bindings/Cargo.toml index 5f2b1ef284..1fab9a0ad3 100644 --- a/crates/bindings/bevy_text_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_text_bms_bindings/Cargo.toml @@ -38,7 +38,7 @@ bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} cosmic-text = { version = "^0.14", features = [], default-features = true} diff --git a/crates/bindings/bevy_time_bms_bindings/src/lib.rs b/crates/bindings/bevy_time_bms_bindings/src/lib.rs index 10a323f092..c9aa40bb85 100644 --- a/crates/bindings/bevy_time_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_time_bms_bindings/src/lib.rs @@ -108,40 +108,6 @@ pub(crate) fn register_timer_functions(world: &mut World) { "", &["_self"], ) - .register_documented( - "duration", - |_self: Ref<::bevy_time::prelude::Timer>| { - let output: Val<::core::time::Duration> = { - { - let output: Val<::core::time::Duration> = ::bevy_time::prelude::Timer::duration( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the duration of the timer.\n # Examples\n ```\n # use bevy_time::*;\n use std::time::Duration;\n let timer = Timer::new(Duration::from_secs(1), TimerMode::Once);\n assert_eq!(timer.duration(), Duration::from_secs(1));\n ```", - &["_self"], - ) - .register_documented( - "elapsed", - |_self: Ref<::bevy_time::prelude::Timer>| { - let output: Val<::core::time::Duration> = { - { - let output: Val<::core::time::Duration> = ::bevy_time::prelude::Timer::elapsed( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the time elapsed on the timer. Guaranteed to be between 0.0 and `duration`.\n Will only equal `duration` when the timer is finished and non repeating.\n See also [`Stopwatch::elapsed`](Stopwatch::elapsed).\n # Examples\n ```\n # use bevy_time::*;\n use std::time::Duration;\n let mut timer = Timer::from_seconds(1.0, TimerMode::Once);\n timer.tick(Duration::from_secs_f32(0.5));\n assert_eq!(timer.elapsed(), Duration::from_secs_f32(0.5));\n ```", - &["_self"], - ) .register_documented( "elapsed_secs", |_self: Ref<::bevy_time::prelude::Timer>| { @@ -342,27 +308,6 @@ pub(crate) fn register_timer_functions(world: &mut World) { " Returns the mode of the timer.\n # Examples\n ```\n # use bevy_time::*;\n let mut timer = Timer::from_seconds(1.0, TimerMode::Repeating);\n assert_eq!(timer.mode(), TimerMode::Repeating);\n ```", &["_self"], ) - .register_documented( - "new", - | - duration: Val<::core::time::Duration>, - mode: Val<::bevy_time::prelude::TimerMode>| - { - let output: Val<::bevy_time::prelude::Timer> = { - { - let output: Val<::bevy_time::prelude::Timer> = ::bevy_time::prelude::Timer::new( - duration.into_inner(), - mode.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Creates a new timer with a given duration.\n See also [`Timer::from_seconds`](Timer::from_seconds).", - &["duration", "mode"], - ) .register_documented( "pause", |mut _self: Mut<::bevy_time::prelude::Timer>| { @@ -393,23 +338,6 @@ pub(crate) fn register_timer_functions(world: &mut World) { " Returns `true` if the timer is paused.\n See also [`Stopwatch::is_paused`](Stopwatch::is_paused).\n # Examples\n ```\n # use bevy_time::*;\n let mut timer = Timer::from_seconds(1.0, TimerMode::Once);\n assert!(!timer.paused());\n timer.pause();\n assert!(timer.paused());\n timer.unpause();\n assert!(!timer.paused());\n ```", &["_self"], ) - .register_documented( - "remaining", - |_self: Ref<::bevy_time::prelude::Timer>| { - let output: Val<::core::time::Duration> = { - { - let output: Val<::core::time::Duration> = ::bevy_time::prelude::Timer::remaining( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the remaining time using Duration\n # Examples\n ```\n # use bevy_time::*;\n use std::time::Duration;\n let mut timer = Timer::from_seconds(2.0, TimerMode::Once);\n timer.tick(Duration::from_secs_f32(0.5));\n assert_eq!(timer.remaining(), Duration::from_secs_f32(1.5));\n ```", - &["_self"], - ) .register_documented( "remaining_secs", |_self: Ref<::bevy_time::prelude::Timer>| { @@ -442,48 +370,6 @@ pub(crate) fn register_timer_functions(world: &mut World) { " Resets the timer. The reset doesn't affect the `paused` state of the timer.\n See also [`Stopwatch::reset`](Stopwatch::reset).\n Examples\n ```\n # use bevy_time::*;\n use std::time::Duration;\n let mut timer = Timer::from_seconds(1.0, TimerMode::Once);\n timer.tick(Duration::from_secs_f32(1.5));\n timer.reset();\n assert!(!timer.is_finished());\n assert!(!timer.just_finished());\n assert_eq!(timer.elapsed_secs(), 0.0);\n ```", &["_self"], ) - .register_documented( - "set_duration", - | - mut _self: Mut<::bevy_time::prelude::Timer>, - duration: Val<::core::time::Duration>| - { - let output: () = { - { - let output: () = ::bevy_time::prelude::Timer::set_duration( - &mut _self, - duration.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Sets the duration of the timer.\n # Examples\n ```\n # use bevy_time::*;\n use std::time::Duration;\n let mut timer = Timer::from_seconds(1.5, TimerMode::Once);\n timer.set_duration(Duration::from_secs(1));\n assert_eq!(timer.duration(), Duration::from_secs(1));\n ```", - &["_self", "duration"], - ) - .register_documented( - "set_elapsed", - | - mut _self: Mut<::bevy_time::prelude::Timer>, - time: Val<::core::time::Duration>| - { - let output: () = { - { - let output: () = ::bevy_time::prelude::Timer::set_elapsed( - &mut _self, - time.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Sets the elapsed time of the timer without any other considerations.\n See also [`Stopwatch::set`](Stopwatch::set).\n #\n ```\n # use bevy_time::*;\n use std::time::Duration;\n let mut timer = Timer::from_seconds(1.0, TimerMode::Once);\n timer.set_elapsed(Duration::from_secs(2));\n assert_eq!(timer.elapsed(), Duration::from_secs(2));\n // the timer is not finished even if the elapsed time is greater than the duration.\n assert!(!timer.is_finished());\n ```", - &["_self", "time"], - ) .register_documented( "set_mode", | @@ -677,23 +563,6 @@ pub(crate) fn register_stopwatch_functions(world: &mut World) { "", &["_self"], ) - .register_documented( - "elapsed", - |_self: Ref<::bevy_time::Stopwatch>| { - let output: Val<::core::time::Duration> = { - { - let output: Val<::core::time::Duration> = ::bevy_time::Stopwatch::elapsed( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the elapsed time since the last [`reset`](Stopwatch::reset)\n of the stopwatch.\n # Examples\n ```\n # use bevy_time::*;\n use std::time::Duration;\n let mut stopwatch = Stopwatch::new();\n stopwatch.tick(Duration::from_secs(1));\n assert_eq!(stopwatch.elapsed(), Duration::from_secs(1));\n ```\n # See Also\n [`elapsed_secs`](Stopwatch::elapsed_secs) - if an `f32` value is desirable instead.\n [`elapsed_secs_f64`](Stopwatch::elapsed_secs_f64) - if an `f64` is desirable instead.", - &["_self"], - ) .register_documented( "elapsed_secs", |_self: Ref<::bevy_time::Stopwatch>| { @@ -803,24 +672,6 @@ pub(crate) fn register_stopwatch_functions(world: &mut World) { " Resets the stopwatch. The reset doesn't affect the paused state of the stopwatch.\n # Examples\n ```\n # use bevy_time::*;\n use std::time::Duration;\n let mut stopwatch = Stopwatch::new();\n stopwatch.tick(Duration::from_secs_f32(1.5));\n stopwatch.reset();\n assert_eq!(stopwatch.elapsed_secs(), 0.0);\n ```", &["_self"], ) - .register_documented( - "set_elapsed", - |mut _self: Mut<::bevy_time::Stopwatch>, time: Val<::core::time::Duration>| { - let output: () = { - { - let output: () = ::bevy_time::Stopwatch::set_elapsed( - &mut _self, - time.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Sets the elapsed time of the stopwatch.\n # Examples\n ```\n # use bevy_time::*;\n use std::time::Duration;\n let mut stopwatch = Stopwatch::new();\n stopwatch.set_elapsed(Duration::from_secs_f32(1.0));\n assert_eq!(stopwatch.elapsed_secs(), 1.0);\n ```", - &["_self", "time"], - ) .register_documented( "unpause", |mut _self: Mut<::bevy_time::Stopwatch>| { diff --git a/crates/bindings/bevy_transform_bms_bindings/src/lib.rs b/crates/bindings/bevy_transform_bms_bindings/src/lib.rs index 3e376cb112..63b3cc064c 100644 --- a/crates/bindings/bevy_transform_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_transform_bms_bindings/src/lib.rs @@ -16,23 +16,6 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_transform::components::GlobalTransform, >::new(world) - .register_documented( - "affine", - |_self: Ref<::bevy_transform::components::GlobalTransform>| { - let output: Val<::bevy_math::Affine3A> = { - { - let output: Val<::bevy_math::Affine3A> = ::bevy_transform::components::GlobalTransform::affine( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the 3d affine transformation matrix as an [`Affine3A`].", - &["_self"], - ) .register_documented( "back", |_self: Ref<::bevy_transform::components::GlobalTransform>| { @@ -155,57 +138,6 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { "", &["iso"], ) - .register_documented( - "from_rotation", - |rotation: Val<::bevy_math::Quat>| { - let output: Val<::bevy_transform::components::GlobalTransform> = { - { - let output: Val<::bevy_transform::components::GlobalTransform> = ::bevy_transform::components::GlobalTransform::from_rotation( - rotation.into_inner(), - ) - .into(); - output - } - }; - output - }, - "", - &["rotation"], - ) - .register_documented( - "from_scale", - |scale: Val<::bevy_math::Vec3>| { - let output: Val<::bevy_transform::components::GlobalTransform> = { - { - let output: Val<::bevy_transform::components::GlobalTransform> = ::bevy_transform::components::GlobalTransform::from_scale( - scale.into_inner(), - ) - .into(); - output - } - }; - output - }, - "", - &["scale"], - ) - .register_documented( - "from_translation", - |translation: Val<::bevy_math::Vec3>| { - let output: Val<::bevy_transform::components::GlobalTransform> = { - { - let output: Val<::bevy_transform::components::GlobalTransform> = ::bevy_transform::components::GlobalTransform::from_translation( - translation.into_inner(), - ) - .into(); - output - } - }; - output - }, - "", - &["translation"], - ) .register_documented( "from_xyz", |x: f32, y: f32, z: f32| { @@ -242,26 +174,6 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { "Return the local left vector (-X).", &["_self"], ) - .register_documented( - "mul", - | - _self: Val<::bevy_transform::components::GlobalTransform>, - value: Val<::bevy_math::Vec3>| - { - let output: Val<::bevy_math::Vec3> = { - { - let output: Val<::bevy_math::Vec3> = <::bevy_transform::components::GlobalTransform as ::core::ops::Mul< - ::bevy_math::Vec3, - >>::mul(_self.into_inner(), value.into_inner()) - .into(); - output - } - }; - output - }, - "", - &["_self", "value"], - ) .register_documented( "mul", | @@ -323,27 +235,6 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { " Multiplies `self` with `transform` component by component, returning the\n resulting [`GlobalTransform`]", &["_self", "transform"], ) - .register_documented( - "radius_vec3a", - | - _self: Ref<::bevy_transform::components::GlobalTransform>, - extents: Val<::bevy_math::Vec3A>| - { - let output: f32 = { - { - let output: f32 = ::bevy_transform::components::GlobalTransform::radius_vec3a( - &_self, - extents.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Get an upper bound of the radius from the given `extents`.", - &["_self", "extents"], - ) .register_documented( "reparented_to", | @@ -382,40 +273,6 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { "Return the local right vector (X).", &["_self"], ) - .register_documented( - "rotation", - |_self: Ref<::bevy_transform::components::GlobalTransform>| { - let output: Val<::bevy_math::Quat> = { - { - let output: Val<::bevy_math::Quat> = ::bevy_transform::components::GlobalTransform::rotation( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the rotation as a [`Quat`].\n The transform is expected to be non-degenerate and without shearing, or the output will be invalid.\n # Warning\n This is calculated using `to_scale_rotation_translation`, meaning that you\n should probably use it directly if you also need translation or scale.", - &["_self"], - ) - .register_documented( - "scale", - |_self: Ref<::bevy_transform::components::GlobalTransform>| { - let output: Val<::bevy_math::Vec3> = { - { - let output: Val<::bevy_math::Vec3> = ::bevy_transform::components::GlobalTransform::scale( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the scale as a [`Vec3`].\n The transform is expected to be non-degenerate and without shearing, or the output will be invalid.\n Some of the computations overlap with `to_scale_rotation_translation`, which means you should use\n it instead if you also need rotation.", - &["_self"], - ) .register_documented( "to_isometry", |_self: Ref<::bevy_transform::components::GlobalTransform>| { @@ -433,78 +290,6 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { " Computes a Scale-Rotation-Translation decomposition of the transformation and returns\n the isometric part as an [isometry]. Any scaling done by the transformation will be ignored.\n Note: this is a somewhat costly and lossy conversion.\n The transform is expected to be non-degenerate and without shearing, or the output\n will be invalid.\n [isometry]: Isometry3d", &["_self"], ) - .register_documented( - "to_matrix", - |_self: Ref<::bevy_transform::components::GlobalTransform>| { - let output: Val<::bevy_math::Mat4> = { - { - let output: Val<::bevy_math::Mat4> = ::bevy_transform::components::GlobalTransform::to_matrix( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the 3d affine transformation matrix as a [`Mat4`].", - &["_self"], - ) - .register_documented( - "transform_point", - | - _self: Ref<::bevy_transform::components::GlobalTransform>, - point: Val<::bevy_math::Vec3>| - { - let output: Val<::bevy_math::Vec3> = { - { - let output: Val<::bevy_math::Vec3> = ::bevy_transform::components::GlobalTransform::transform_point( - &_self, - point.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Transforms the given point from local space to global space, applying shear, scale, rotation and translation.\n It can be used like this:\n ```\n # use bevy_transform::prelude::{GlobalTransform};\n # use bevy_math::prelude::Vec3;\n let global_transform = GlobalTransform::from_xyz(1., 2., 3.);\n let local_point = Vec3::new(1., 2., 3.);\n let global_point = global_transform.transform_point(local_point);\n assert_eq!(global_point, Vec3::new(2., 4., 6.));\n ```\n ```\n # use bevy_transform::prelude::{GlobalTransform};\n # use bevy_math::Vec3;\n let global_point = Vec3::new(2., 4., 6.);\n let global_transform = GlobalTransform::from_xyz(1., 2., 3.);\n let local_point = global_transform.affine().inverse().transform_point3(global_point);\n assert_eq!(local_point, Vec3::new(1., 2., 3.))\n ```\n To apply shear, scale, and rotation *without* applying translation, different functions are available:\n ```\n # use bevy_transform::prelude::{GlobalTransform};\n # use bevy_math::prelude::Vec3;\n let global_transform = GlobalTransform::from_xyz(1., 2., 3.);\n let local_direction = Vec3::new(1., 2., 3.);\n let global_direction = global_transform.affine().transform_vector3(local_direction);\n assert_eq!(global_direction, Vec3::new(1., 2., 3.));\n let roundtripped_local_direction = global_transform.affine().inverse().transform_vector3(global_direction);\n assert_eq!(roundtripped_local_direction, local_direction);\n ```", - &["_self", "point"], - ) - .register_documented( - "translation", - |_self: Ref<::bevy_transform::components::GlobalTransform>| { - let output: Val<::bevy_math::Vec3> = { - { - let output: Val<::bevy_math::Vec3> = ::bevy_transform::components::GlobalTransform::translation( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the translation as a [`Vec3`].", - &["_self"], - ) - .register_documented( - "translation_vec3a", - |_self: Ref<::bevy_transform::components::GlobalTransform>| { - let output: Val<::bevy_math::Vec3A> = { - { - let output: Val<::bevy_math::Vec3A> = ::bevy_transform::components::GlobalTransform::translation_vec3a( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the translation as a [`Vec3A`].", - &["_self"], - ) .register_documented( "up", |_self: Ref<::bevy_transform::components::GlobalTransform>| { @@ -568,23 +353,6 @@ pub(crate) fn register_transform_functions(world: &mut World) { "", &["_self"], ) - .register_documented( - "compute_affine", - |_self: Ref<::bevy_transform::components::Transform>| { - let output: Val<::bevy_math::Affine3A> = { - { - let output: Val<::bevy_math::Affine3A> = ::bevy_transform::components::Transform::compute_affine( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the 3d affine transformation matrix from this transforms translation,\n rotation, and scale.", - &["_self"], - ) .register_documented( "down", |_self: Ref<::bevy_transform::components::Transform>| { @@ -656,74 +424,6 @@ pub(crate) fn register_transform_functions(world: &mut World) { " Creates a new [`Transform`] that is equivalent to the given [isometry].\n [isometry]: Isometry3d", &["iso"], ) - .register_documented( - "from_matrix", - |world_from_local: Val<::bevy_math::Mat4>| { - let output: Val<::bevy_transform::components::Transform> = { - { - let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::from_matrix( - world_from_local.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Extracts the translation, rotation, and scale from `matrix`. It must be a 3d affine\n transformation matrix.", - &["world_from_local"], - ) - .register_documented( - "from_rotation", - |rotation: Val<::bevy_math::Quat>| { - let output: Val<::bevy_transform::components::Transform> = { - { - let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::from_rotation( - rotation.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Creates a new [`Transform`], with `rotation`. Translation will be 0 and scale 1 on\n all axes.", - &["rotation"], - ) - .register_documented( - "from_scale", - |scale: Val<::bevy_math::Vec3>| { - let output: Val<::bevy_transform::components::Transform> = { - { - let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::from_scale( - scale.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Creates a new [`Transform`], with `scale`. Translation will be 0 and rotation 0 on\n all axes.", - &["scale"], - ) - .register_documented( - "from_translation", - |translation: Val<::bevy_math::Vec3>| { - let output: Val<::bevy_transform::components::Transform> = { - { - let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::from_translation( - translation.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Creates a new [`Transform`], with `translation`. Rotation will be 0 and scale 1 on\n all axes.", - &["translation"], - ) .register_documented( "from_xyz", |x: f32, y: f32, z: f32| { @@ -828,26 +528,6 @@ pub(crate) fn register_transform_functions(world: &mut World) { " Get the unit vector in the local `Z` direction.", &["_self"], ) - .register_documented( - "mul", - | - _self: Val<::bevy_transform::components::Transform>, - value: Val<::bevy_math::Vec3>| - { - let output: Val<::bevy_math::Vec3> = { - { - let output: Val<::bevy_math::Vec3> = <::bevy_transform::components::Transform as ::core::ops::Mul< - ::bevy_math::Vec3, - >>::mul(_self.into_inner(), value.into_inner()) - .into(); - output - } - }; - output - }, - "", - &["_self", "value"], - ) .register_documented( "mul", | @@ -926,50 +606,6 @@ pub(crate) fn register_transform_functions(world: &mut World) { " Equivalent to [`local_x()`][Transform::local_x()]", &["_self"], ) - .register_documented( - "rotate", - | - mut _self: Mut<::bevy_transform::components::Transform>, - rotation: Val<::bevy_math::Quat>| - { - let output: () = { - { - let output: () = ::bevy_transform::components::Transform::rotate( - &mut _self, - rotation.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Rotates this [`Transform`] by the given rotation.\n If this [`Transform`] has a parent, the `rotation` is relative to the rotation of the parent.\n # Examples\n - [`3d_rotation`]\n [`3d_rotation`]: https://github.com/bevyengine/bevy/blob/latest/examples/transforms/3d_rotation.rs", - &["_self", "rotation"], - ) - .register_documented( - "rotate_around", - | - mut _self: Mut<::bevy_transform::components::Transform>, - point: Val<::bevy_math::Vec3>, - rotation: Val<::bevy_math::Quat>| - { - let output: () = { - { - let output: () = ::bevy_transform::components::Transform::rotate_around( - &mut _self, - point.into_inner(), - rotation.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Rotates this [`Transform`] around a `point` in space.\n If this [`Transform`] has a parent, the `point` is relative to the [`Transform`] of the parent.", - &["_self", "point", "rotation"], - ) .register_documented( "rotate_axis", | @@ -993,27 +629,6 @@ pub(crate) fn register_transform_functions(world: &mut World) { " Rotates this [`Transform`] around the given `axis` by `angle` (in radians).\n If this [`Transform`] has a parent, the `axis` is relative to the rotation of the parent.\n # Warning\n If you pass in an `axis` based on the current rotation (e.g. obtained via [`Transform::local_x`]),\n floating point errors can accumulate exponentially when applying rotations repeatedly this way. This will\n result in a denormalized rotation. In this case, it is recommended to normalize the [`Transform::rotation`] after\n each call to this method.", &["_self", "axis", "angle"], ) - .register_documented( - "rotate_local", - | - mut _self: Mut<::bevy_transform::components::Transform>, - rotation: Val<::bevy_math::Quat>| - { - let output: () = { - { - let output: () = ::bevy_transform::components::Transform::rotate_local( - &mut _self, - rotation.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Rotates this [`Transform`] by the given `rotation`.\n The `rotation` is relative to this [`Transform`]'s current rotation.", - &["_self", "rotation"], - ) .register_documented( "rotate_local_axis", | @@ -1162,67 +777,6 @@ pub(crate) fn register_transform_functions(world: &mut World) { " Get the [isometry] defined by this transform's rotation and translation, ignoring scale.\n [isometry]: Isometry3d", &["_self"], ) - .register_documented( - "to_matrix", - |_self: Ref<::bevy_transform::components::Transform>| { - let output: Val<::bevy_math::Mat4> = { - { - let output: Val<::bevy_math::Mat4> = ::bevy_transform::components::Transform::to_matrix( - &_self, - ) - .into(); - output - } - }; - output - }, - " Computes the 3d affine transformation matrix from this transform's translation,\n rotation, and scale.", - &["_self"], - ) - .register_documented( - "transform_point", - | - _self: Ref<::bevy_transform::components::Transform>, - point: Val<::bevy_math::Vec3>| - { - let output: Val<::bevy_math::Vec3> = { - { - let output: Val<::bevy_math::Vec3> = ::bevy_transform::components::Transform::transform_point( - &_self, - point.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Transforms the given `point`, applying scale, rotation and translation.\n If this [`Transform`] has an ancestor entity with a [`Transform`] component,\n [`Transform::transform_point`] will transform a point in local space into its\n parent transform's space.\n If this [`Transform`] does not have a parent, [`Transform::transform_point`] will\n transform a point in local space into worldspace coordinates.\n If you always want to transform a point in local space to worldspace, or if you need\n the inverse transformations, see [`GlobalTransform::transform_point()`].", - &["_self", "point"], - ) - .register_documented( - "translate_around", - | - mut _self: Mut<::bevy_transform::components::Transform>, - point: Val<::bevy_math::Vec3>, - rotation: Val<::bevy_math::Quat>| - { - let output: () = { - { - let output: () = ::bevy_transform::components::Transform::translate_around( - &mut _self, - point.into_inner(), - rotation.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Translates this [`Transform`] around a `point` in space.\n If this [`Transform`] has a parent, the `point` is relative to the [`Transform`] of the parent.", - &["_self", "point", "rotation"], - ) .register_documented( "up", |_self: Ref<::bevy_transform::components::Transform>| { @@ -1239,69 +793,6 @@ pub(crate) fn register_transform_functions(world: &mut World) { }, " Equivalent to [`local_y()`][Transform::local_y]", &["_self"], - ) - .register_documented( - "with_rotation", - | - _self: Val<::bevy_transform::components::Transform>, - rotation: Val<::bevy_math::Quat>| - { - let output: Val<::bevy_transform::components::Transform> = { - { - let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::with_rotation( - _self.into_inner(), - rotation.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Returns this [`Transform`] with a new rotation.", - &["_self", "rotation"], - ) - .register_documented( - "with_scale", - | - _self: Val<::bevy_transform::components::Transform>, - scale: Val<::bevy_math::Vec3>| - { - let output: Val<::bevy_transform::components::Transform> = { - { - let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::with_scale( - _self.into_inner(), - scale.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Returns this [`Transform`] with a new scale.", - &["_self", "scale"], - ) - .register_documented( - "with_translation", - | - _self: Val<::bevy_transform::components::Transform>, - translation: Val<::bevy_math::Vec3>| - { - let output: Val<::bevy_transform::components::Transform> = { - { - let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::with_translation( - _self.into_inner(), - translation.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Returns this [`Transform`] with a new translation.", - &["_self", "translation"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); diff --git a/crates/bindings/bevy_ui_bms_bindings/Cargo.toml b/crates/bindings/bevy_ui_bms_bindings/Cargo.toml index 6d45864df4..80a8023ab6 100644 --- a/crates/bindings/bevy_ui_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_ui_bms_bindings/Cargo.toml @@ -52,7 +52,7 @@ bevy_text = { version = "^0.17.2", features = ["default_font"], default-features bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} diff --git a/crates/bindings/bevy_ui_bms_bindings/src/lib.rs b/crates/bindings/bevy_ui_bms_bindings/src/lib.rs index 107dc8f562..c489f86ae0 100644 --- a/crates/bindings/bevy_ui_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_ui_bms_bindings/src/lib.rs @@ -721,40 +721,6 @@ pub(crate) fn register_computed_ui_render_target_info_functions(world: &mut Worl "", &["_self", "other"], ) - .register_documented( - "logical_size", - |_self: Ref<::bevy_ui::prelude::ComputedUiRenderTargetInfo>| { - let output: Val<::bevy_math::Vec2> = { - { - let output: Val<::bevy_math::Vec2> = ::bevy_ui::prelude::ComputedUiRenderTargetInfo::logical_size( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the size of the target camera's viewport in logical pixels.", - &["_self"], - ) - .register_documented( - "physical_size", - |_self: Ref<::bevy_ui::prelude::ComputedUiRenderTargetInfo>| { - let output: Val<::bevy_math::UVec2> = { - { - let output: Val<::bevy_math::UVec2> = ::bevy_ui::prelude::ComputedUiRenderTargetInfo::physical_size( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the size of the target camera's viewport in physical pixels.", - &["_self"], - ) .register_documented( "scale_factor", |_self: Ref<::bevy_ui::prelude::ComputedUiRenderTargetInfo>| { @@ -783,24 +749,7 @@ pub(crate) fn register_computed_ui_render_target_info_functions(world: &mut Worl pub(crate) fn register_content_size_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_ui::measurement::ContentSize, - >::new(world) - .register_documented( - "fixed_size", - |size: Val<::bevy_math::Vec2>| { - let output: Val<::bevy_ui::measurement::ContentSize> = { - { - let output: Val<::bevy_ui::measurement::ContentSize> = ::bevy_ui::measurement::ContentSize::fixed_size( - size.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Creates a `ContentSize` with a `Measure` that always returns given `size` argument, regardless of the UI layout's constraints.", - &["size"], - ); + >::new(world); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1105,9 +1054,9 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { .register_documented( "border", |_self: Ref<::bevy_ui::prelude::ComputedNode>| { - let output: Val<::bevy_ui::prelude::BorderRect> = { + let output: Val<::bevy_sprite::BorderRect> = { { - let output: Val<::bevy_ui::prelude::BorderRect> = ::bevy_ui::prelude::ComputedNode::border( + let output: Val<::bevy_sprite::BorderRect> = ::bevy_ui::prelude::ComputedNode::border( &_self, ) .into(); @@ -1153,35 +1102,12 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { "", &["_self"], ) - .register_documented( - "contains_point", - | - _self: Ref<::bevy_ui::prelude::ComputedNode>, - transform: Val<::bevy_ui::ui_transform::UiGlobalTransform>, - point: Val<::bevy_math::Vec2>| - { - let output: bool = { - { - let output: bool = ::bevy_ui::prelude::ComputedNode::contains_point( - &_self, - transform.into_inner(), - point.into_inner(), - ) - .into(); - output - } - }; - output - }, - "", - &["_self", "transform", "point"], - ) .register_documented( "content_inset", |_self: Ref<::bevy_ui::prelude::ComputedNode>| { - let output: Val<::bevy_ui::prelude::BorderRect> = { + let output: Val<::bevy_sprite::BorderRect> = { { - let output: Val<::bevy_ui::prelude::BorderRect> = ::bevy_ui::prelude::ComputedNode::content_inset( + let output: Val<::bevy_sprite::BorderRect> = ::bevy_ui::prelude::ComputedNode::content_inset( &_self, ) .into(); @@ -1193,23 +1119,6 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { " Returns the combined inset on each edge including both padding and border thickness in physical pixels.", &["_self"], ) - .register_documented( - "content_size", - |_self: Ref<::bevy_ui::prelude::ComputedNode>| { - let output: Val<::bevy_math::Vec2> = { - { - let output: Val<::bevy_math::Vec2> = ::bevy_ui::prelude::ComputedNode::content_size( - &_self, - ) - .into(); - output - } - }; - output - }, - " The calculated node content size as width and height in physical pixels.\n Automatically calculated by [`ui_layout_system`](`super::layout::ui_layout_system`).", - &["_self"], - ) .register_documented( "eq", | @@ -1332,29 +1241,12 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { " Returns the thickness of the UI node's outline in physical pixels.\n If this value is negative or `0.` then no outline will be rendered.\n Automatically calculated by [`ui_layout_system`](`super::layout::ui_layout_system`).", &["_self"], ) - .register_documented( - "outlined_node_size", - |_self: Ref<::bevy_ui::prelude::ComputedNode>| { - let output: Val<::bevy_math::Vec2> = { - { - let output: Val<::bevy_math::Vec2> = ::bevy_ui::prelude::ComputedNode::outlined_node_size( - &_self, - ) - .into(); - output - } - }; - output - }, - " Returns the size of the node when including its outline.\n Automatically calculated by [`ui_layout_system`](`super::layout::ui_layout_system`).", - &["_self"], - ) .register_documented( "padding", |_self: Ref<::bevy_ui::prelude::ComputedNode>| { - let output: Val<::bevy_ui::prelude::BorderRect> = { + let output: Val<::bevy_sprite::BorderRect> = { { - let output: Val<::bevy_ui::prelude::BorderRect> = ::bevy_ui::prelude::ComputedNode::padding( + let output: Val<::bevy_sprite::BorderRect> = ::bevy_ui::prelude::ComputedNode::padding( &_self, ) .into(); @@ -1389,23 +1281,6 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { " Resolve the node's clipping rect in local space", &["_self", "overflow", "overflow_clip_margin"], ) - .register_documented( - "size", - |_self: Ref<::bevy_ui::prelude::ComputedNode>| { - let output: Val<::bevy_math::Vec2> = { - { - let output: Val<::bevy_math::Vec2> = ::bevy_ui::prelude::ComputedNode::size( - &_self, - ) - .into(); - output - } - }; - output - }, - " The calculated node size as width and height in physical pixels.\n Automatically calculated by [`ui_layout_system`](`super::layout::ui_layout_system`).", - &["_self"], - ) .register_documented( "stack_index", |_self: Ref<::bevy_ui::prelude::ComputedNode>| { @@ -1422,23 +1297,6 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { }, " The order of the node in the UI layout.\n Nodes with a higher stack index are drawn on top of and receive interactions before nodes with lower stack indices.\n Automatically calculated in [`UiSystems::Stack`](super::UiSystems::Stack).", &["_self"], - ) - .register_documented( - "unrounded_size", - |_self: Ref<::bevy_ui::prelude::ComputedNode>| { - let output: Val<::bevy_math::Vec2> = { - { - let output: Val<::bevy_math::Vec2> = ::bevy_ui::prelude::ComputedNode::unrounded_size( - &_self, - ) - .into(); - output - } - }; - output - }, - " The calculated node size as width and height in physical pixels before rounding.\n Automatically calculated by [`ui_layout_system`](`super::layout::ui_layout_system`).", - &["_self"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -1594,21 +1452,6 @@ pub(crate) fn register_image_node_size_functions(world: &mut World) { }, "", &["_self"], - ) - .register_documented( - "size", - |_self: Ref<::bevy_ui::widget::ImageNodeSize>| { - let output: Val<::bevy_math::UVec2> = { - { - let output: Val<::bevy_math::UVec2> = - ::bevy_ui::widget::ImageNodeSize::size(&_self).into(); - output - } - }; - output - }, - " The size of the image's texture", - &["_self"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -1650,21 +1493,6 @@ pub(crate) fn register_ui_position_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_ui::prelude::UiPosition, >::new(world) - .register_documented( - "anchor", - |anchor: Val<::bevy_math::Vec2>| { - let output: Val<::bevy_ui::prelude::UiPosition> = { - { - let output: Val<::bevy_ui::prelude::UiPosition> = - ::bevy_ui::prelude::UiPosition::anchor(anchor.into_inner()).into(); - output - } - }; - output - }, - " Position at the given normalized anchor point", - &["anchor"], - ) .register_documented( "at", |_self: Val<::bevy_ui::prelude::UiPosition>, @@ -1864,56 +1692,6 @@ pub(crate) fn register_ui_position_functions(world: &mut World) { " Position relative to the left edge", &["x", "y"], ) - .register_documented( - "new", - |anchor: Val<::bevy_math::Vec2>, - x: Val<::bevy_ui::prelude::Val>, - y: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiPosition> = { - { - let output: Val<::bevy_ui::prelude::UiPosition> = - ::bevy_ui::prelude::UiPosition::new( - anchor.into_inner(), - x.into_inner(), - y.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Create a new position", - &["anchor", "x", "y"], - ) - .register_documented( - "resolve", - |_self: Val<::bevy_ui::prelude::UiPosition>, - scale_factor: f32, - physical_size: Val<::bevy_math::Vec2>, - physical_target_size: Val<::bevy_math::Vec2>| { - let output: Val<::bevy_math::Vec2> = { - { - let output: Val<::bevy_math::Vec2> = ::bevy_ui::prelude::UiPosition::resolve( - _self.into_inner(), - scale_factor, - physical_size.into_inner(), - physical_target_size.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Resolves the `Position` into physical coordinates.", - &[ - "_self", - "scale_factor", - "physical_size", - "physical_target_size", - ], - ) .register_documented( "right", |x: Val<::bevy_ui::prelude::Val>, y: Val<::bevy_ui::prelude::Val>| { @@ -1976,25 +1754,6 @@ pub(crate) fn register_ui_position_functions(world: &mut World) { }, " Position relative to the top-right corner", &["x", "y"], - ) - .register_documented( - "with_anchor", - |_self: Val<::bevy_ui::prelude::UiPosition>, anchor: Val<::bevy_math::Vec2>| { - let output: Val<::bevy_ui::prelude::UiPosition> = { - { - let output: Val<::bevy_ui::prelude::UiPosition> = - ::bevy_ui::prelude::UiPosition::with_anchor( - _self.into_inner(), - anchor.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Creates a position from self with the given `anchor` point", - &["_self", "anchor"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -2048,7 +1807,7 @@ pub(crate) fn register_val_functions(world: &mut World) { let output: Val<::bevy_ui::prelude::Val> = { { let output: Val<::bevy_ui::prelude::Val> = <::bevy_ui::prelude::Val as ::std::clone::Clone>::clone( - &_self.into_inner(), + &_self, ) .into(); output @@ -2083,7 +1842,7 @@ pub(crate) fn register_val_functions(world: &mut World) { { let output: bool = <::bevy_ui::prelude::Val as ::std::cmp::PartialEq< ::bevy_ui::prelude::Val, - >>::eq(&_self.into_inner(), &other.into_inner()) + >>::eq(&_self, &other) .into(); output } @@ -2590,38 +2349,6 @@ pub(crate) fn register_radial_gradient_shape_functions(world: &mut World) { }, "", &["_self", "other"], - ) - .register_documented( - "resolve", - |_self: Val<::bevy_ui::gradients::RadialGradientShape>, - position: Val<::bevy_math::Vec2>, - scale_factor: f32, - physical_size: Val<::bevy_math::Vec2>, - physical_target_size: Val<::bevy_math::Vec2>| { - let output: Val<::bevy_math::Vec2> = { - { - let output: Val<::bevy_math::Vec2> = - ::bevy_ui::gradients::RadialGradientShape::resolve( - _self.into_inner(), - position.into_inner(), - scale_factor, - physical_size.into_inner(), - physical_target_size.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Resolve the physical dimensions of the end shape of the radial gradient", - &[ - "_self", - "position", - "scale_factor", - "physical_size", - "physical_target_size", - ], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -2895,122 +2622,84 @@ pub(crate) fn register_val_2_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_ui::ui_transform::Val2, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::ui_transform::Val2>| { - let output: Val<::bevy_ui::ui_transform::Val2> = { - { - let output: Val<::bevy_ui::ui_transform::Val2> = <::bevy_ui::ui_transform::Val2 as ::std::clone::Clone>::clone( - &_self.into_inner(), - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_ui::ui_transform::Val2>, - other: Ref<::bevy_ui::ui_transform::Val2>| - { - let output: bool = { - { - let output: bool = <::bevy_ui::ui_transform::Val2 as ::std::cmp::PartialEq< - ::bevy_ui::ui_transform::Val2, - >>::eq(&_self.into_inner(), &other.into_inner()) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "new", - |x: Val<::bevy_ui::prelude::Val>, y: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::ui_transform::Val2> = { - { - let output: Val<::bevy_ui::ui_transform::Val2> = ::bevy_ui::ui_transform::Val2::new( - x.into_inner(), - y.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Creates a new [`Val2`]", - &["x", "y"], - ) - .register_documented( - "percent", - |x: f32, y: f32| { - let output: Val<::bevy_ui::ui_transform::Val2> = { - { - let output: Val<::bevy_ui::ui_transform::Val2> = ::bevy_ui::ui_transform::Val2::percent( - x, - y, - ) - .into(); - output - } - }; - output - }, - " Creates a new [`Val2`] where both components are percentage values", - &["x", "y"], - ) - .register_documented( - "px", - |x: f32, y: f32| { - let output: Val<::bevy_ui::ui_transform::Val2> = { - { - let output: Val<::bevy_ui::ui_transform::Val2> = ::bevy_ui::ui_transform::Val2::px( - x, - y, - ) - .into(); - output - } - }; - output - }, - " Creates a new [`Val2`] where both components are in logical pixels", - &["x", "y"], - ) - .register_documented( - "resolve", - | - _self: Ref<::bevy_ui::ui_transform::Val2>, - scale_factor: f32, - base_size: Val<::bevy_math::Vec2>, - viewport_size: Val<::bevy_math::Vec2>| - { - let output: Val<::bevy_math::Vec2> = { - { - let output: Val<::bevy_math::Vec2> = ::bevy_ui::ui_transform::Val2::resolve( - &_self.into_inner(), - scale_factor, - base_size.into_inner(), - viewport_size.into_inner(), - ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::ui_transform::Val2>| { + let output: Val<::bevy_ui::ui_transform::Val2> = { + { + let output: Val<::bevy_ui::ui_transform::Val2> = + <::bevy_ui::ui_transform::Val2 as ::std::clone::Clone>::clone(&_self) .into(); - output - } - }; - output - }, - " Resolves this [`Val2`] from the given `scale_factor`, `parent_size`,\n and `viewport_size`.\n Component values of [`Val::Auto`] are resolved to 0.", - &["_self", "scale_factor", "base_size", "viewport_size"], - ); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::ui_transform::Val2>, other: Ref<::bevy_ui::ui_transform::Val2>| { + let output: bool = { + { + let output: bool = <::bevy_ui::ui_transform::Val2 as ::std::cmp::PartialEq< + ::bevy_ui::ui_transform::Val2, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "new", + |x: Val<::bevy_ui::prelude::Val>, y: Val<::bevy_ui::prelude::Val>| { + let output: Val<::bevy_ui::ui_transform::Val2> = { + { + let output: Val<::bevy_ui::ui_transform::Val2> = + ::bevy_ui::ui_transform::Val2::new(x.into_inner(), y.into_inner()).into(); + output + } + }; + output + }, + " Creates a new [`Val2`]", + &["x", "y"], + ) + .register_documented( + "percent", + |x: f32, y: f32| { + let output: Val<::bevy_ui::ui_transform::Val2> = { + { + let output: Val<::bevy_ui::ui_transform::Val2> = + ::bevy_ui::ui_transform::Val2::percent(x, y).into(); + output + } + }; + output + }, + " Creates a new [`Val2`] where both components are percentage values", + &["x", "y"], + ) + .register_documented( + "px", + |x: f32, y: f32| { + let output: Val<::bevy_ui::ui_transform::Val2> = { + { + let output: Val<::bevy_ui::ui_transform::Val2> = + ::bevy_ui::ui_transform::Val2::px(x, y).into(); + output + } + }; + output + }, + " Creates a new [`Val2`] where both components are in logical pixels", + &["x", "y"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -3023,119 +2712,77 @@ pub(crate) fn register_ui_transform_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_ui::ui_transform::UiTransform, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::ui_transform::UiTransform>| { - let output: Val<::bevy_ui::ui_transform::UiTransform> = { - { - let output: Val<::bevy_ui::ui_transform::UiTransform> = <::bevy_ui::ui_transform::UiTransform as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "compute_affine", - | - _self: Ref<::bevy_ui::ui_transform::UiTransform>, - scale_factor: f32, - base_size: Val<::bevy_math::Vec2>, - target_size: Val<::bevy_math::Vec2>| - { - let output: Val<::bevy_math::Affine2> = { - { - let output: Val<::bevy_math::Affine2> = ::bevy_ui::ui_transform::UiTransform::compute_affine( - &_self, - scale_factor, - base_size.into_inner(), - target_size.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Resolves the translation from the given `scale_factor`, `base_value`, and `target_size`\n and returns a 2d affine transform from the resolved translation, and the `UiTransform`'s rotation, and scale.", - &["_self", "scale_factor", "base_size", "target_size"], - ) - .register_documented( - "eq", - | - _self: Ref<::bevy_ui::ui_transform::UiTransform>, - other: Ref<::bevy_ui::ui_transform::UiTransform>| - { - let output: bool = { - { - let output: bool = <::bevy_ui::ui_transform::UiTransform as ::std::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_ui::ui_transform::UiTransform>| { + let output: Val<::bevy_ui::ui_transform::UiTransform> = { + { + let output: Val<::bevy_ui::ui_transform::UiTransform> = + <::bevy_ui::ui_transform::UiTransform as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::ui_transform::UiTransform>, + other: Ref<::bevy_ui::ui_transform::UiTransform>| { + let output: bool = { + { + let output: bool = + <::bevy_ui::ui_transform::UiTransform as ::std::cmp::PartialEq< ::bevy_ui::ui_transform::UiTransform, >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "from_rotation", + |rotation: Val<::bevy_math::Rot2>| { + let output: Val<::bevy_ui::ui_transform::UiTransform> = { + { + let output: Val<::bevy_ui::ui_transform::UiTransform> = + ::bevy_ui::ui_transform::UiTransform::from_rotation(rotation.into_inner()) .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "from_rotation", - |rotation: Val<::bevy_math::Rot2>| { - let output: Val<::bevy_ui::ui_transform::UiTransform> = { - { - let output: Val<::bevy_ui::ui_transform::UiTransform> = ::bevy_ui::ui_transform::UiTransform::from_rotation( - rotation.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Creates a UI transform representing a rotation.", - &["rotation"], - ) - .register_documented( - "from_scale", - |scale: Val<::bevy_math::Vec2>| { - let output: Val<::bevy_ui::ui_transform::UiTransform> = { - { - let output: Val<::bevy_ui::ui_transform::UiTransform> = ::bevy_ui::ui_transform::UiTransform::from_scale( - scale.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Creates a UI transform representing a scaling.", - &["scale"], - ) - .register_documented( - "from_translation", - |translation: Val<::bevy_ui::ui_transform::Val2>| { - let output: Val<::bevy_ui::ui_transform::UiTransform> = { - { - let output: Val<::bevy_ui::ui_transform::UiTransform> = ::bevy_ui::ui_transform::UiTransform::from_translation( - translation.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Creates a UI transform representing a responsive translation.", - &["translation"], - ); + output + } + }; + output + }, + " Creates a UI transform representing a rotation.", + &["rotation"], + ) + .register_documented( + "from_translation", + |translation: Val<::bevy_ui::ui_transform::Val2>| { + let output: Val<::bevy_ui::ui_transform::UiTransform> = { + { + let output: Val<::bevy_ui::ui_transform::UiTransform> = + ::bevy_ui::ui_transform::UiTransform::from_translation( + translation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a UI transform representing a responsive translation.", + &["translation"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -3729,56 +3376,6 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { " Sets the radii to logical pixel values.", &["top_left", "top_right", "bottom_right", "bottom_left"], ) - .register_documented( - "resolve", - | - _self: Ref<::bevy_ui::prelude::BorderRadius>, - scale_factor: f32, - node_size: Val<::bevy_math::Vec2>, - viewport_size: Val<::bevy_math::Vec2>| - { - let output: Val<::bevy_ui::prelude::ResolvedBorderRadius> = { - { - let output: Val<::bevy_ui::prelude::ResolvedBorderRadius> = ::bevy_ui::prelude::BorderRadius::resolve( - &_self, - scale_factor, - node_size.into_inner(), - viewport_size.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Resolve the border radii for the corners from the given context values.\n Returns the radii of the each corner in physical pixels.", - &["_self", "scale_factor", "node_size", "viewport_size"], - ) - .register_documented( - "resolve_single_corner", - | - radius: Val<::bevy_ui::prelude::Val>, - scale_factor: f32, - min_length: f32, - viewport_size: Val<::bevy_math::Vec2>| - { - let output: f32 = { - { - let output: f32 = ::bevy_ui::prelude::BorderRadius::resolve_single_corner( - radius.into_inner(), - scale_factor, - min_length, - viewport_size.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Resolve the border radius for a single corner from the given context values.\n Returns the radius of the corner in physical pixels.", - &["radius", "scale_factor", "min_length", "viewport_size"], - ) .register_documented( "right", |radius: Val<::bevy_ui::prelude::Val>| { diff --git a/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml b/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml index 7adb245adf..a6c9fd3f62 100644 --- a/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml @@ -56,7 +56,7 @@ bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "al bevy_ui = { version = "^0.17.2", features = ["bevy_picking", "bevy_ui_picking_backend"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} bytemuck = { version = "^1.5", features = [], default-features = true} diff --git a/crates/languages/bevy_mod_scripting_lua/src/lib.rs b/crates/languages/bevy_mod_scripting_lua/src/lib.rs index 43090ee3ed..109b7c6f3c 100644 --- a/crates/languages/bevy_mod_scripting_lua/src/lib.rs +++ b/crates/languages/bevy_mod_scripting_lua/src/lib.rs @@ -397,7 +397,7 @@ impl IntoMluaError for InteropError { } #[cfg(test)] mod test { - use ::bevy_asset::{AssetId, AssetIndex, Handle}; + use ::bevy_asset::Handle; use bevy_mod_scripting_asset::LanguageExtensions; use mlua::Value; @@ -407,8 +407,8 @@ mod test { fn test_reload_doesnt_overwrite_old_context() { let lua = Lua::new(); let mut old_ctxt = LuaContext(lua.clone()); - let handle = Handle::Weak(AssetId::from(AssetIndex::from_bits(0))); - let context_key = ScriptAttachment::EntityScript(Entity::from_raw(1), handle); + let handle = Handle::default(); + let context_key = ScriptAttachment::EntityScript(Entity::from_raw_u32(1).unwrap(), handle); let world_id = WorldId::new().unwrap(); LuaScriptingPlugin::set_world_local_config( world_id, diff --git a/crates/testing_crates/script_integration_test_harness/src/lib.rs b/crates/testing_crates/script_integration_test_harness/src/lib.rs index 03367008d5..d492848c7b 100644 --- a/crates/testing_crates/script_integration_test_harness/src/lib.rs +++ b/crates/testing_crates/script_integration_test_harness/src/lib.rs @@ -9,7 +9,7 @@ use std::{ use ::{ bevy_app::{App, Plugin, PostUpdate, Startup, Update}, - bevy_asset::{AssetPath, AssetServer, Handle, LoadState}, + bevy_asset::{AssetPath, AssetServer, LoadState}, bevy_ecs::{ component::Component, resource::Resource, schedule::IntoScheduleConfigs, system::Command, world::FromWorld, @@ -204,7 +204,7 @@ pub fn run_lua_benchmark( let plugin = make_test_lua_plugin(); run_plugin_benchmark( plugin, - script_id, + script_id.to_string(), label, criterion, |ctxt, _runtime, label, criterion| { @@ -235,7 +235,7 @@ pub fn run_rhai_benchmark( let plugin = make_test_rhai_plugin(); run_plugin_benchmark( plugin, - script_id, + script_id.to_string(), label, criterion, |ctxt, runtime, label, criterion| { @@ -318,7 +318,7 @@ where .clone(); let guard = WorldGuard::new_exclusive(app.world_mut()); - let context_key = ScriptAttachment::EntityScript(entity, Handle::Weak(script_id)); + let context_key = ScriptAttachment::EntityScript(entity, script_handle.clone()); let script_contexts = script_contexts.read(); let ctxt_arc = script_contexts.get_context(&context_key).unwrap(); @@ -332,7 +332,7 @@ where ThreadWorldContainer .set_context(ThreadScriptContext { world: guard.clone(), - attachment: ScriptAttachment::StaticScript(Handle::Weak(script_id)), + attachment: ScriptAttachment::StaticScript(script_handle), }) .map_err(|e| format!("{e:#?}"))?; // Pass the locked context to the closure for benchmarking its Lua (or generic) part diff --git a/crates/testing_crates/script_integration_test_harness/src/parse.rs b/crates/testing_crates/script_integration_test_harness/src/parse.rs index 6c1c12daea..95a7bc2a6a 100644 --- a/crates/testing_crates/script_integration_test_harness/src/parse.rs +++ b/crates/testing_crates/script_integration_test_harness/src/parse.rs @@ -15,7 +15,7 @@ use bevy_mod_scripting_script::ScriptAttachment; use crate::scenario::{SCENARIO_SELF_LANGUAGE_NAME, ScenarioContext, ScenarioStep}; -#[derive(Debug, Clone, serde::Deserialize, serde::Serialize, PartialEq, Eq)] +#[derive(Debug, Clone, Hash, serde::Deserialize, serde::Serialize, PartialEq, Eq)] pub enum ScenarioSchedule { Startup, Update, @@ -214,11 +214,11 @@ impl ScenarioStepSerialized { ScenarioRecipients::AllScripts => Recipients::AllScripts, ScenarioRecipients::AllContexts => Recipients::AllContexts, ScenarioRecipients::EntityScript { entity, script } => Recipients::ScriptEntity( - context.get_script_handle(&script)?.id(), + context.get_script_handle(&script)?, context.get_entity(&entity)?, ), ScenarioRecipients::StaticScript { script } => { - Recipients::StaticScript(context.get_script_handle(&script)?.id()) + Recipients::StaticScript(context.get_script_handle(&script)?) } }) } diff --git a/crates/testing_crates/script_integration_test_harness/src/scenario.rs b/crates/testing_crates/script_integration_test_harness/src/scenario.rs index 9523806819..e78413684d 100644 --- a/crates/testing_crates/script_integration_test_harness/src/scenario.rs +++ b/crates/testing_crates/script_integration_test_harness/src/scenario.rs @@ -9,17 +9,13 @@ use ::{ bevy_app::App, bevy_asset::{AssetEvent, Handle, LoadState}, bevy_ecs::{ - entity::Entity, - event::{Event, EventCursor, Events}, - schedule::ScheduleLabel, - system::Command, - system::IntoSystem, - world::World, + entity::Entity, schedule::ScheduleLabel, system::Command, system::IntoSystem, world::World, }, }; use anyhow::{Context, Error, anyhow}; -use bevy_app::{DynEq, FixedUpdate, Last, PostUpdate, Startup, Update}; +use bevy_app::{FixedUpdate, Last, PostUpdate, Startup, Update}; use bevy_asset::{AssetServer, Assets}; +use bevy_ecs::message::{Message, MessageCursor, Messages}; use bevy_log::info; use bevy_mod_scripting_asset::{Language, LanguageExtensions, ScriptAsset}; use bevy_mod_scripting_bindings::ScriptValue; @@ -157,19 +153,19 @@ pub struct ScenarioContext { #[derive(Debug, Clone, Default)] pub struct InterestingEventWatcher { pub events: Vec<(String, usize)>, - pub asset_event_cursor: EventCursor>, - pub script_attached_events_cursor: EventCursor, - pub script_detached_events_cursor: EventCursor, - pub script_response_cursor: EventCursor, + pub asset_event_cursor: MessageCursor>, + pub script_attached_events_cursor: MessageCursor, + pub script_detached_events_cursor: MessageCursor, + pub script_response_cursor: MessageCursor, pub script_responses_queue: VecDeque, } impl InterestingEventWatcher { pub fn log_events(&mut self, step_no: usize, world: &World) { - let asset_events = world.resource::>>(); - let script_attached_events = world.resource::>(); - let script_detached_events = world.resource::>(); - let script_responses = world.resource::>(); + let asset_events = world.resource::>>(); + let script_attached_events = world.resource::>(); + let script_detached_events = world.resource::>(); + let script_responses = world.resource::>(); let mut tracked_with_id = Vec::default(); for (event, id) in self.asset_event_cursor.read_with_id(asset_events) { tracked_with_id.push((id.id, format!("AssetEvent : {event:?}"))); @@ -295,26 +291,6 @@ impl ScheduleLabel for ScenarioSchedule { ScenarioSchedule::Last => Last.dyn_clone(), } } - - fn as_dyn_eq(&self) -> &dyn DynEq { - match self { - ScenarioSchedule::Startup => Startup.as_dyn_eq(), - ScenarioSchedule::Update => Update.as_dyn_eq(), - ScenarioSchedule::FixedUpdate => FixedUpdate.as_dyn_eq(), - ScenarioSchedule::PostUpdate => PostUpdate.as_dyn_eq(), - ScenarioSchedule::Last => Last.as_dyn_eq(), - } - } - - fn dyn_hash(&self, state: &mut dyn ::core::hash::Hasher) { - match self { - ScenarioSchedule::Startup => Startup.dyn_hash(state), - ScenarioSchedule::Update => Update.dyn_hash(state), - ScenarioSchedule::FixedUpdate => FixedUpdate.dyn_hash(state), - ScenarioSchedule::PostUpdate => PostUpdate.dyn_hash(state), - ScenarioSchedule::Last => Last.dyn_hash(state), - } - } } #[derive(Debug)] @@ -432,7 +408,7 @@ impl ScenarioStep { /// Will execute the app update loop until an event of type `T` is received or we timeout. pub fn execute_until_event< - T: Event + Clone, + T: Message + Clone, E, F: Fn(&T) -> bool, G: Fn(&World) -> Option, @@ -442,11 +418,11 @@ impl ScenarioStep { filter: F, early_exit: G, ) -> Result, E>, Error> { - let mut event_cursor = EventCursor::::default(); + let mut event_cursor = MessageCursor::::default(); loop { { let world = app.world_mut(); - let events = world.resource::>(); + let events = world.resource::>(); let events = event_cursor .read(events) @@ -636,7 +612,7 @@ impl ScenarioStep { ); } ScenarioStep::EmitScriptCallbackEvent { event } => { - app.world_mut().send_event(event.clone()); + app.world_mut().write_message(event.clone()); } ScenarioStep::AssertCallbackSuccess { label, @@ -690,7 +666,7 @@ impl ScenarioStep { .iter_mut() .find_map(|(name, handle)| { if handle.id() == script.id() { - *handle = handle.clone_weak(); + *handle = handle.clone(); Some(name.clone()) } else { None diff --git a/crates/testing_crates/script_integration_test_harness/src/test_functions.rs b/crates/testing_crates/script_integration_test_harness/src/test_functions.rs index 1070b3eaba..e1c57eb552 100644 --- a/crates/testing_crates/script_integration_test_harness/src/test_functions.rs +++ b/crates/testing_crates/script_integration_test_harness/src/test_functions.rs @@ -79,7 +79,7 @@ pub fn register_test_functions(world: &mut App) { let mut allocator = allocator.write(); ReflectReference::new_allocated( - c.unwrap_or(Entity::from_raw(9999)), + c.unwrap_or(Entity::from_raw_u32(9999).unwrap()), &mut allocator, ) }) diff --git a/crates/testing_crates/test_utils/src/test_plugin.rs b/crates/testing_crates/test_utils/src/test_plugin.rs index f0c36ea096..f33a5c6274 100644 --- a/crates/testing_crates/test_utils/src/test_plugin.rs +++ b/crates/testing_crates/test_utils/src/test_plugin.rs @@ -62,8 +62,12 @@ macro_rules! make_test_plugin { #[derive(Default, std::fmt::Debug)] struct TestRuntime { - pub invocations: - parking_lot::Mutex, Option<$ident::script::ScriptId>)>>, + pub invocations: parking_lot::Mutex< + Vec<( + Option, + Option>, + )>, + >, } #[derive(Default, std::fmt::Debug, Clone)] diff --git a/examples/game_of_life.rs b/examples/game_of_life.rs index 14d82ef684..39eca62288 100644 --- a/examples/game_of_life.rs +++ b/examples/game_of_life.rs @@ -3,15 +3,13 @@ use std::time::Duration; use bevy::{ + asset::RenderAssetUsages, diagnostic::LogDiagnosticsPlugin, image::ImageSampler, log::LogPlugin, prelude::*, reflect::Reflect, - render::{ - render_asset::RenderAssetUsages, - render_resource::{Extent3d, TextureDimension, TextureFormat}, - }, + render::render_resource::{Extent3d, TextureDimension, TextureFormat}, window::{PrimaryWindow, WindowResized}, }; use bevy_console::{AddConsoleCommand, ConsoleCommand, ConsoleOpen, ConsolePlugin, make_layer}; @@ -28,6 +26,7 @@ fn console_app(app: &mut App) -> &mut App { level: bevy::log::Level::INFO, filter: "error,game_of_life=info".to_owned(), custom_layer: make_layer, + ..Default::default() }), ConsolePlugin, )) @@ -276,21 +275,21 @@ callback_labels!( ); /// Sends events allowing scripts to drive update logic -pub fn send_on_update(mut events: EventWriter) { - events.send(ScriptCallbackEvent::new_for_all_scripts(OnUpdate, vec![])); +pub fn send_on_update(mut events: MessageWriter) { + events.write(ScriptCallbackEvent::new_for_all_scripts(OnUpdate, vec![])); } pub fn send_on_click( buttons: Res>, q_windows: Query<&Window, With>, - mut events: EventWriter, + mut events: MessageWriter, ) { if buttons.just_pressed(MouseButton::Left) { let window = q_windows.single(); let pos = window.unwrap().cursor_position().unwrap_or_default(); let x = pos.x as u32; let y = pos.y as u32; - events.send(ScriptCallbackEvent::new_for_all_scripts( + events.write(ScriptCallbackEvent::new_for_all_scripts( OnClick, vec![ ScriptValue::Integer(x as i64), diff --git a/examples/run_script.rs b/examples/run_script.rs index 63098a69f6..87efad05c5 100644 --- a/examples/run_script.rs +++ b/examples/run_script.rs @@ -48,12 +48,12 @@ fn add_logging(app: &mut App) { }); } -pub fn info_on_asset_event() -> impl FnMut(EventReader>) { +pub fn info_on_asset_event() -> impl FnMut(MessageReader>) { // The events need to be consumed, so that there are no false positives on subsequent // calls of the run condition. Simply checking `is_empty` would not be enough. // PERF: note that `count` is efficient (not actually looping/iterating), // due to Bevy having a specialized implementation for events. - move |mut reader: EventReader>| { + move |mut reader: MessageReader>| { for event in reader.read() { match event { AssetEvent::Modified { .. } => (), From aaa9d9aed7acd5121bbec01ba9afeee65bec4fb8 Mon Sep 17 00:00:00 2001 From: makspll Date: Mon, 10 Nov 2025 23:51:12 +0000 Subject: [PATCH 12/22] fix some test setup, add debug to dev crate features --- Cargo.toml | 1 + crates/testing_crates/test_utils/Cargo.toml | 3 +++ .../test_utils/src/test_data.rs | 25 ++++++++++++++++--- 3 files changed, 26 insertions(+), 3 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 3b771bc3de..11436abb54 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -251,6 +251,7 @@ bevy = { workspace = true, features = [ "bevy_ui", "default_font", "custom_cursor", + "debug", ] } bevy_platform = { workspace = true } clap = { workspace = true, features = ["derive"] } diff --git a/crates/testing_crates/test_utils/Cargo.toml b/crates/testing_crates/test_utils/Cargo.toml index a474cedc0b..1ba427a83e 100644 --- a/crates/testing_crates/test_utils/Cargo.toml +++ b/crates/testing_crates/test_utils/Cargo.toml @@ -12,6 +12,9 @@ bevy_log = { workspace = true, default-features = false, features = [] } bevy_diagnostic = { workspace = true, default-features = false, features = [] } bevy_reflect = { workspace = true, default-features = false, features = [] } bevy_time = { workspace = true, default-features = false, features = [] } +bevy_utils = { workspace = true, default-features = false, features = [ + "debug", +] } [lib] diff --git a/crates/testing_crates/test_utils/src/test_data.rs b/crates/testing_crates/test_utils/src/test_data.rs index 4ea8127b5b..4f253dd44f 100644 --- a/crates/testing_crates/test_utils/src/test_data.rs +++ b/crates/testing_crates/test_utils/src/test_data.rs @@ -267,7 +267,7 @@ impl SimpleEnum { } pub(crate) const TEST_COMPONENT_ID_START: usize = 20; -pub(crate) const TEST_ENTITY_ID_START: u32 = 0; +pub(crate) const TEST_ENTITY_ID_START: u32 = 1; pub trait GetTestComponentId { fn test_component_id() -> ComponentId; @@ -306,6 +306,10 @@ macro_rules! impl_test_component_ids { pub(crate) fn init_all_components(world: &mut World, registry: &mut TypeRegistry) { $( + // world + // .components() + // .iter_registered() + // .for_each(|c| println!("--> {:?}", c)); world.register_component::<$comp_type>(); registry.register::<$comp_type>(); let registered_id = world.component_id::<$comp_type>().unwrap().index(); @@ -338,8 +342,8 @@ macro_rules! impl_test_component_ids { }; } -impl_test_component_ids!( - [ TestComponent => 0, +impl_test_component_ids!([ + TestComponent => 0, CompWithFromWorld => 1, CompWithDefault => 2, CompWithDefaultAndComponentData => 3, @@ -362,6 +366,21 @@ fn init_world(world: &mut World, init: let type_registry = world.get_resource_or_init::().clone(); let mut type_registry_guard = type_registry.0.write(); + // bevy now spawns an ineternal component `bevy_ecs::event::EventWrapperComponent` + // when an entity with a component is inserted :shrug:, make that happen early + #[derive(Component)] + pub struct Dummy; + world.register_component::(); + world.spawn((Dummy,)); + + if world.components().len() > TEST_COMPONENT_ID_START { + panic!("world has more components than the first test component ID requires") + } + + if world.entities().len() > TEST_ENTITY_ID_START { + panic!("world has more entities than the first test component ID requires") + } + while world.components().len() < TEST_COMPONENT_ID_START { unsafe { world.register_component_with_descriptor(ComponentDescriptor::new_with_layout( From 0b522d4ca3c018b70e2471d10abb414d8ebed161 Mon Sep 17 00:00:00 2001 From: makspll Date: Tue, 11 Nov 2025 21:19:50 +0000 Subject: [PATCH 13/22] fix stack overflow --- crates/bevy_mod_scripting_core/src/script_system.rs | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/crates/bevy_mod_scripting_core/src/script_system.rs b/crates/bevy_mod_scripting_core/src/script_system.rs index f34ef15185..9cc4461e35 100644 --- a/crates/bevy_mod_scripting_core/src/script_system.rs +++ b/crates/bevy_mod_scripting_core/src/script_system.rs @@ -22,7 +22,7 @@ use bevy_ecs::{ system::{RunSystemError, SystemIn, SystemStateFlags}, world::DeferredWorld, }; -use bevy_log::{debug, error, info, warn_once}; +use bevy_log::{debug, error, warn_once}; use bevy_mod_scripting_bindings::{ AppReflectAllocator, AppScheduleRegistry, AppScriptComponentRegistry, AppScriptFunctionRegistry, InteropError, IntoScript, ReflectAccessId, ReflectReference, @@ -155,11 +155,8 @@ impl ScriptSystemBuilder { { for default_set in other.default_system_sets() { if is_before { - info!("before {default_set:?}"); system_config = system_config.before(*default_set); } else { - info!("before {default_set:?}"); - info!("after {default_set:?}"); system_config = system_config.after(*default_set); } } @@ -260,7 +257,8 @@ impl System for DynamicScriptSystem

{ } fn flags(&self) -> SystemStateFlags { - if self.is_exclusive() { + println!("flags"); + if self.exclusive { SystemStateFlags::NON_SEND | SystemStateFlags::EXCLUSIVE } else { SystemStateFlags::empty() From ac99996ce3239f66f30d1f9e76c83d61145cfac4 Mon Sep 17 00:00:00 2001 From: makspll Date: Tue, 11 Nov 2025 21:44:05 +0000 Subject: [PATCH 14/22] fix rest of tests and add missing features --- Cargo.toml | 14 ++++++++------ .../add_system/added_systems_run_in_parallel.lua | 2 +- .../add_system/added_systems_run_in_parallel.rhai | 2 +- crates/bevy_mod_scripting_functions/Cargo.toml | 12 ++++++++++++ crates/bevy_mod_scripting_functions/src/core.rs | 12 ++++++++++++ 5 files changed, 34 insertions(+), 8 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 11436abb54..987d95a877 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -66,7 +66,7 @@ core_functions = ["bevy_mod_scripting_functions/core_functions"] bevy_a11y_bindings = ["bevy_mod_scripting_functions/bevy_a11y"] bevy_animation_bindings = ["bevy_mod_scripting_functions/bevy_animation"] bevy_asset_bindings = ["bevy_mod_scripting_functions/bevy_asset"] -# bevy_camera +bevy_camera_bindings = ["bevy_mod_scripting_functions/bevy_camera"] bevy_color_bindings = ["bevy_mod_scripting_functions/bevy_color"] bevy_core_pipeline_bindings = [ "bevy_mod_scripting_functions/bevy_core_pipeline", @@ -77,22 +77,24 @@ bevy_gltf_bindings = ["bevy_mod_scripting_functions/bevy_gltf"] bevy_image_bindings = ["bevy_mod_scripting_functions/bevy_image"] bevy_input_bindings = ["bevy_mod_scripting_functions/bevy_input"] bevy_input_focus_bindings = ["bevy_mod_scripting_functions/bevy_input_focus"] -# bevy_light +bevy_light_bindings = ["bevy_mod_scripting_functions/bevy_light"] bevy_math_bindings = ["bevy_mod_scripting_functions/bevy_math"] bevy_mesh_bindings = ["bevy_mod_scripting_functions/bevy_mesh"] bevy_pbr_bindings = ["bevy_mod_scripting_functions/bevy_pbr"] bevy_picking_bindings = ["bevy_mod_scripting_functions/bevy_picking"] -# bevy_post_process +bevy_post_process_bindings = ["bevy_mod_scripting_functions/bevy_post_process"] bevy_reflect_bindings = ["bevy_mod_scripting_functions/bevy_reflect"] bevy_render_bindings = ["bevy_mod_scripting_functions/bevy_render"] bevy_scene_bindings = ["bevy_mod_scripting_functions/bevy_scene"] bevy_sprite_bindings = ["bevy_mod_scripting_functions/bevy_sprite"] -# bevy_sprite_renderer +bevy_sprite_render_bindings = [ + "bevy_mod_scripting_functions/bevy_sprite_render", +] bevy_text_bindings = ["bevy_mod_scripting_functions/bevy_text"] bevy_time_bindings = ["bevy_mod_scripting_functions/bevy_time"] bevy_transform_bindings = ["bevy_mod_scripting_functions/bevy_transform"] -# bevy_ui -# bevy_ui_render +bevy_ui_bindings = ["bevy_mod_scripting_functions/bevy_ui"] +bevy_ui_render_bindings = ["bevy_mod_scripting_functions/bevy_ui_render"] # optional unsafe_lua_modules = ["bevy_mod_scripting_lua?/unsafe_lua_modules"] diff --git a/assets/tests/add_system/added_systems_run_in_parallel.lua b/assets/tests/add_system/added_systems_run_in_parallel.lua index f5c129280c..63788e88fc 100644 --- a/assets/tests/add_system/added_systems_run_in_parallel.lua +++ b/assets/tests/add_system/added_systems_run_in_parallel.lua @@ -41,7 +41,7 @@ digraph { node_16 [label="on_test_post_update"]; node_17 [label="custom_system_a"]; node_18 [label="custom_system_b"]; - node_19 [label="SystemSet AssetEvents"]; + node_19 [label="SystemSet AssetEventSystems"]; node_20 [label="SystemSet GarbageCollection"]; node_21 [label="SystemSet ListeningPhase"]; node_22 [label="SystemSet MachineStartPhase"]; diff --git a/assets/tests/add_system/added_systems_run_in_parallel.rhai b/assets/tests/add_system/added_systems_run_in_parallel.rhai index b87e5e75a9..c3d84302fe 100644 --- a/assets/tests/add_system/added_systems_run_in_parallel.rhai +++ b/assets/tests/add_system/added_systems_run_in_parallel.rhai @@ -40,7 +40,7 @@ digraph { node_16 [label="on_test_post_update"]; node_17 [label="custom_system_a"]; node_18 [label="custom_system_b"]; - node_19 [label="SystemSet AssetEvents"]; + node_19 [label="SystemSet AssetEventSystems"]; node_20 [label="SystemSet GarbageCollection"]; node_21 [label="SystemSet ListeningPhase"]; node_22 [label="SystemSet MachineStartPhase"]; diff --git a/crates/bevy_mod_scripting_functions/Cargo.toml b/crates/bevy_mod_scripting_functions/Cargo.toml index ed662f7b61..d8a90d5b37 100644 --- a/crates/bevy_mod_scripting_functions/Cargo.toml +++ b/crates/bevy_mod_scripting_functions/Cargo.toml @@ -15,6 +15,7 @@ readme.workspace = true bevy_a11y = ["bevy_a11y_bms_bindings"] bevy_animation = ["bevy_animation_bms_bindings"] bevy_asset = ["bevy_asset_bms_bindings"] +bevy_camera = ["bevy_camera_bms_bindings"] bevy_color = ["bevy_color_bms_bindings"] bevy_core_pipeline = ["bevy_core_pipeline_bms_bindings"] bevy_ecs = ["bevy_ecs_bms_bindings"] @@ -23,17 +24,22 @@ bevy_gltf = ["bevy_gltf_bms_bindings"] bevy_image = ["bevy_image_bms_bindings"] bevy_input = ["bevy_input_bms_bindings"] bevy_input_focus = ["bevy_input_focus_bms_bindings"] +bevy_light = ["bevy_light_bms_bindings"] bevy_math = ["bevy_math_bms_bindings"] bevy_mesh = ["bevy_mesh_bms_bindings"] bevy_pbr = ["bevy_pbr_bms_bindings"] bevy_picking = ["bevy_picking_bms_bindings"] +bevy_post_process = ["bevy_post_process_bms_bindings"] bevy_reflect = ["bevy_reflect_bms_bindings"] bevy_render = ["bevy_render_bms_bindings"] bevy_scene = ["bevy_scene_bms_bindings"] bevy_sprite = ["bevy_sprite_bms_bindings"] +bevy_sprite_render = ["bevy_sprite_render_bms_bindings"] bevy_text = ["bevy_text_bms_bindings"] bevy_time = ["bevy_time_bms_bindings"] bevy_transform = ["bevy_transform_bms_bindings"] +bevy_ui = ["bevy_ui_bms_bindings"] +bevy_ui_render = ["bevy_ui_render_bms_bindings"] core_functions = [] lua_bindings = ["bevy_mod_scripting_lua"] @@ -61,6 +67,7 @@ bevy_reflect = { workspace = true, features = [] } bevy_a11y_bms_bindings = { path = "../bindings/bevy_a11y_bms_bindings", version = "0.17.0", optional = true } bevy_animation_bms_bindings = { path = "../bindings/bevy_animation_bms_bindings", version = "0.17.0", optional = true } bevy_asset_bms_bindings = { path = "../bindings/bevy_asset_bms_bindings", version = "0.17.0", optional = true } +bevy_camera_bms_bindings = { path = "../bindings/bevy_camera_bms_bindings", version = "0.17.0", optional = true } bevy_color_bms_bindings = { path = "../bindings/bevy_color_bms_bindings", version = "0.17.0", optional = true } bevy_core_pipeline_bms_bindings = { path = "../bindings/bevy_core_pipeline_bms_bindings", version = "0.17.0", optional = true } bevy_ecs_bms_bindings = { path = "../bindings/bevy_ecs_bms_bindings", version = "0.17.0", optional = true } @@ -69,17 +76,22 @@ bevy_gltf_bms_bindings = { path = "../bindings/bevy_gltf_bms_bindings", version bevy_image_bms_bindings = { path = "../bindings/bevy_image_bms_bindings", version = "0.17.0", optional = true } bevy_input_bms_bindings = { path = "../bindings/bevy_input_bms_bindings", version = "0.17.0", optional = true } bevy_input_focus_bms_bindings = { path = "../bindings/bevy_input_focus_bms_bindings", version = "0.17.0", optional = true } +bevy_light_bms_bindings = { path = "../bindings/bevy_light_bms_bindings", version = "0.17.0", optional = true } bevy_math_bms_bindings = { path = "../bindings/bevy_math_bms_bindings", version = "0.17.0", optional = true } bevy_mesh_bms_bindings = { path = "../bindings/bevy_mesh_bms_bindings", version = "0.17.0", optional = true } bevy_pbr_bms_bindings = { path = "../bindings/bevy_pbr_bms_bindings", version = "0.17.0", optional = true } bevy_picking_bms_bindings = { path = "../bindings/bevy_picking_bms_bindings", version = "0.17.0", optional = true } +bevy_post_process_bms_bindings = { path = "../bindings/bevy_post_process_bms_bindings", version = "0.17.0", optional = true } bevy_reflect_bms_bindings = { path = "../bindings/bevy_reflect_bms_bindings", version = "0.17.0", optional = true } bevy_render_bms_bindings = { path = "../bindings/bevy_render_bms_bindings", version = "0.17.0", optional = true } bevy_scene_bms_bindings = { path = "../bindings/bevy_scene_bms_bindings", version = "0.17.0", optional = true } bevy_sprite_bms_bindings = { path = "../bindings/bevy_sprite_bms_bindings", version = "0.17.0", optional = true } +bevy_sprite_render_bms_bindings = { path = "../bindings/bevy_sprite_render_bms_bindings", version = "0.17.0", optional = true } bevy_text_bms_bindings = { path = "../bindings/bevy_text_bms_bindings", version = "0.17.0", optional = true } bevy_time_bms_bindings = { path = "../bindings/bevy_time_bms_bindings", version = "0.17.0", optional = true } bevy_transform_bms_bindings = { path = "../bindings/bevy_transform_bms_bindings", version = "0.17.0", optional = true } +bevy_ui_bms_bindings = { path = "../bindings/bevy_ui_bms_bindings", version = "0.17.0", optional = true } +bevy_ui_render_bms_bindings = { path = "../bindings/bevy_ui_render_bms_bindings", version = "0.17.0", optional = true } [lints] workspace = true diff --git a/crates/bevy_mod_scripting_functions/src/core.rs b/crates/bevy_mod_scripting_functions/src/core.rs index 5da871d8e0..97129069fb 100644 --- a/crates/bevy_mod_scripting_functions/src/core.rs +++ b/crates/bevy_mod_scripting_functions/src/core.rs @@ -35,6 +35,8 @@ pub fn register_bevy_bindings(app: &mut App) { app.add_plugins(bevy_animation_bms_bindings::BevyAnimationScriptingPlugin); #[cfg(feature = "bevy_asset")] app.add_plugins(bevy_asset_bms_bindings::BevyAssetScriptingPlugin); + #[cfg(feature = "bevy_camera")] + app.add_plugins(bevy_camera_bms_bindings::BevyCameraScriptingPlugin); #[cfg(feature = "bevy_color")] app.add_plugins(bevy_color_bms_bindings::BevyColorScriptingPlugin); #[cfg(feature = "bevy_core_pipeline")] @@ -51,6 +53,8 @@ pub fn register_bevy_bindings(app: &mut App) { app.add_plugins(bevy_input_bms_bindings::BevyInputScriptingPlugin); #[cfg(feature = "bevy_input_focus")] app.add_plugins(bevy_input_focus_bms_bindings::BevyInputFocusScriptingPlugin); + #[cfg(feature = "bevy_light")] + app.add_plugins(bevy_light_bms_bindings::BevyLightScriptingPlugin); #[cfg(feature = "bevy_math")] app.add_plugins(bevy_math_bms_bindings::BevyMathScriptingPlugin); #[cfg(feature = "bevy_mesh")] @@ -59,6 +63,8 @@ pub fn register_bevy_bindings(app: &mut App) { app.add_plugins(bevy_pbr_bms_bindings::BevyPbrScriptingPlugin); #[cfg(feature = "bevy_picking")] app.add_plugins(bevy_picking_bms_bindings::BevyPickingScriptingPlugin); + #[cfg(feature = "bevy_post_process")] + app.add_plugins(bevy_post_process_bms_bindings::BevyPostProcessScriptingPlugin); #[cfg(feature = "bevy_reflect")] app.add_plugins(bevy_reflect_bms_bindings::BevyReflectScriptingPlugin); #[cfg(feature = "bevy_render")] @@ -67,12 +73,18 @@ pub fn register_bevy_bindings(app: &mut App) { app.add_plugins(bevy_scene_bms_bindings::BevySceneScriptingPlugin); #[cfg(feature = "bevy_sprite")] app.add_plugins(bevy_sprite_bms_bindings::BevySpriteScriptingPlugin); + #[cfg(feature = "bevy_sprite_render")] + app.add_plugins(bevy_sprite_renderer_bms_bindings::BevySpriteRendererScriptingPlugin); #[cfg(feature = "bevy_text")] app.add_plugins(bevy_text_bms_bindings::BevyTextScriptingPlugin); #[cfg(feature = "bevy_time")] app.add_plugins(bevy_time_bms_bindings::BevyTimeScriptingPlugin); #[cfg(feature = "bevy_transform")] app.add_plugins(bevy_transform_bms_bindings::BevyTransformScriptingPlugin); + #[cfg(feature = "bevy_ui")] + app.add_plugins(bevy_ui_bms_bindings::BevyUiScriptingPlugin); + #[cfg(feature = "bevy_ui_render")] + app.add_plugins(bevy_ui_renderer_bms_bindings::BevyUiRendererScriptingPlugin); } #[script_bindings( From 0e0037c5fdf615fb7e0f9a05ec35c0c4615a87b5 Mon Sep 17 00:00:00 2001 From: makspll Date: Tue, 11 Nov 2025 22:22:35 +0000 Subject: [PATCH 15/22] add wayland to init --- xtask/src/main.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 39af27b70b..fbdf825587 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -1200,7 +1200,7 @@ impl Xtasks { let codegen_app_settings = main_workspace_app_settings .clone() .with_workspace_dir(api_gen_dir.clone()); - // .with_toolchain(codegen_toolchain.clone()); // don't think it's needed, the rust toolchain file sorts that out + // .with_toolchain(codegen_toolchain.clone()); // don't think it's needed, the rust toolchain file sorts that out let bevy_repo_app_settings = main_workspace_app_settings .clone() @@ -2014,7 +2014,7 @@ impl Xtasks { if cfg!(target_os = "linux") { let sudo = if !is_root::is_root() { "sudo" } else { "" }; let install_cmd = format!( - "{sudo} apt-get update && {sudo} apt-get install --no-install-recommends -y libasound2-dev libudev-dev" + "{sudo} apt-get update && {sudo} apt-get install --no-install-recommends -y libasound2-dev libudev-dev libwayland-dev" ); Self::run_system_command( &app_settings, From 1fb4847a03ae1ece4b1ab5a1f0e5f310e3589935 Mon Sep 17 00:00:00 2001 From: makspll Date: Wed, 12 Nov 2025 00:24:10 +0000 Subject: [PATCH 16/22] fix game of life, and some other bugs --- Cargo.toml | 1 + assets/scripts/game_of_life.lua | 13 +++++------ assets/scripts/game_of_life.rhai | 12 +++++----- .../bevy_mod_scripting_core/src/commands.rs | 23 ++++++++++++++----- .../src/pipeline/hooks.rs | 20 ++++++++++++++-- .../src/pipeline/machines.rs | 10 ++++---- .../src/pipeline/mod.rs | 9 ++++---- .../src/pipeline/start.rs | 16 +++++++++---- .../bevy_mod_scripting_lua/src/lib.rs | 1 + examples/game_of_life.rs | 14 +++-------- 10 files changed, 74 insertions(+), 45 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 987d95a877..23aa10b513 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -248,6 +248,7 @@ bevy = { workspace = true, features = [ "bevy_asset", "bevy_core_pipeline", "bevy_sprite", + "bevy_sprite_render", "bevy_state", "x11", "bevy_ui", diff --git a/assets/scripts/game_of_life.lua b/assets/scripts/game_of_life.lua index c217f6b821..49a2ce4d21 100644 --- a/assets/scripts/game_of_life.lua +++ b/assets/scripts/game_of_life.lua @@ -2,7 +2,6 @@ LifeState = world.get_type_by_name("LifeState") Settings = world.get_type_by_name("Settings") info("Lua: The game_of_life.lua script just got loaded") - math.randomseed(os.time()) function fetch_life_state() @@ -37,11 +36,11 @@ function on_click(x, y) local dimensions = settings.physical_grid_dimensions local screen = settings.display_grid_dimensions - local dimension_x = dimensions._1 - local dimension_y = dimensions._2 + local dimension_x = dimensions[1] + local dimension_y = dimensions[2] - local screen_x = screen._1 - local screen_y = screen._2 + local screen_x = screen[1] + local screen_y = screen[2] local cell_width = screen_x / dimension_x local cell_height = screen_y / dimension_y @@ -78,8 +77,8 @@ function on_update() local cells = fetch_life_state().cells local settings = world.get_resource(Settings) local dimensions = settings.physical_grid_dimensions - local dimension_x = dimensions._1 - local dimension_y = dimensions._2 + local dimension_x = dimensions[1] + local dimension_y = dimensions[2] -- primitives are passed by value to lua, keep a hold of old state but turn 255's into 1's local prev_state = {} diff --git a/assets/scripts/game_of_life.rhai b/assets/scripts/game_of_life.rhai index 0b99e385c7..557cdcf478 100644 --- a/assets/scripts/game_of_life.rhai +++ b/assets/scripts/game_of_life.rhai @@ -40,11 +40,11 @@ fn on_click(x,y) { let dimensions = settings.physical_grid_dimensions; let screen = settings.display_grid_dimensions; - let dimension_x = dimensions["_0"]; - let dimension_y = dimensions["_1"]; + let dimension_x = dimensions[0]; + let dimension_y = dimensions[1]; - let screen_x = screen["_0"]; - let screen_y = screen["_1"]; + let screen_x = screen[0]; + let screen_y = screen[1]; let cell_width = screen_x / dimension_x; let cell_height = screen_y / dimension_y; @@ -77,8 +77,8 @@ fn on_update() { // note that here we do not make use of RhaiProxyable and just go off pure reflection let settings = world.get_resource.call(Settings); let dimensions = settings.physical_grid_dimensions; - let dimension_x = dimensions["_0"]; - let dimension_y = dimensions["_1"]; + let dimension_x = dimensions[0]; + let dimension_y = dimensions[1]; // primitives are passed by value to rhai, keep a hold of old state but turn 255's into 1's let prev_state = []; diff --git a/crates/bevy_mod_scripting_core/src/commands.rs b/crates/bevy_mod_scripting_core/src/commands.rs index 3fdb3291ae..1b696ddf59 100644 --- a/crates/bevy_mod_scripting_core/src/commands.rs +++ b/crates/bevy_mod_scripting_core/src/commands.rs @@ -60,9 +60,16 @@ impl RunScriptCallback

{ self } + fn handle_error(res: &Result, guard: WorldGuard) { + if let Err(err) = res { + send_script_errors(guard, [err]); + } + } + /// Run the command on the given context. /// /// Assumes this context matches the attachment for the command. + /// Does not send the error as a message, this needs to be done explicitly by the caller. pub fn run_with_context( self, guard: WorldGuard, @@ -109,6 +116,8 @@ impl RunScriptCallback

{ } /// Equivalent to [`Self::run`], but usable in the case where you already have [`ScriptContext`] and [`ScriptCallbacks`] resources available. + /// + /// Does not send the error as a message, this needs to be done explicitly by the caller. pub fn run_with_contexts( self, guard: WorldGuard, @@ -125,7 +134,6 @@ impl RunScriptCallback

{ ) .with_script(self.attachment.script().display()) .with_language(P::LANGUAGE); - send_script_errors(guard, [&err]); return Err(err); } }; @@ -135,19 +143,22 @@ impl RunScriptCallback

{ /// Equivalent to running the command, but also returns the result of the callback. /// - /// The returned errors will NOT be sent as events or printed - pub fn run(self, world: &mut World) -> Result { + /// The returned errors will NOT be sent as events or printed unless send errors is set to true + pub fn run(self, world: &mut World, send_errors: bool) -> Result { let script_contexts = world.get_resource_or_init::>().clone(); let script_callbacks = world.get_resource_or_init::>().clone(); let guard = WorldGuard::new_exclusive(world); - self.run_with_contexts(guard, script_contexts, script_callbacks) + let res = self.run_with_contexts(guard.clone(), script_contexts, script_callbacks); + if send_errors && res.is_err() { + Self::handle_error(&res, guard); + } + res } } impl Command for RunScriptCallback

{ fn apply(self, world: &mut World) { - // Internals handle this. - let _ = self.run(world); + let _ = self.run(world, true); } } diff --git a/crates/bevy_mod_scripting_core/src/pipeline/hooks.rs b/crates/bevy_mod_scripting_core/src/pipeline/hooks.rs index 7f1d846153..e25169eb23 100644 --- a/crates/bevy_mod_scripting_core/src/pipeline/hooks.rs +++ b/crates/bevy_mod_scripting_core/src/pipeline/hooks.rs @@ -23,7 +23,10 @@ impl TransitionListener> for OnLoa let emit_responses = P::readonly_configuration(world_id).emit_responses; let callbacks = world.get_resource_or_init::>().clone(); let guard = WorldGuard::new_exclusive(world); - + bevy_log::trace!( + "Running on_script_loaded hook for script: {}", + ctxt.attachment + ); RunScriptCallback::

::new( ctxt.attachment.clone(), OnScriptLoaded::into_callback_label(), @@ -49,7 +52,10 @@ impl TransitionListener> let emit_responses = P::readonly_configuration(world_id).emit_responses; let callbacks = world.get_resource_or_init::>().clone(); let guard = WorldGuard::new_exclusive(world); - + bevy_log::trace!( + "Running on_script_unloaded hook for script: {}", + ctxt.attachment + ); let v = RunScriptCallback::

::new( ctxt.attachment.clone(), OnScriptUnloaded::into_callback_label(), @@ -77,6 +83,11 @@ impl TransitionListener> let callbacks = world.get_resource_or_init::>().clone(); let guard = WorldGuard::new_exclusive(world); + bevy_log::trace!( + "Running on_script_unloaded for reload hook for script: {}", + ctxt.attachment + ); + let v = RunScriptCallback::

::new( ctxt.attachment.clone(), OnScriptUnloaded::into_callback_label(), @@ -106,6 +117,11 @@ impl TransitionListener> for OnRel return Ok(()); } + bevy_log::trace!( + "Running on_script_reloaded hook for script: {}", + ctxt.attachment + ); + let unload_state = ctxt.get_first_typed::(UNLOADED_SCRIPT_STATE_KEY); let unload_state = unload_state.unwrap_or(ScriptValue::Unit); diff --git a/crates/bevy_mod_scripting_core/src/pipeline/machines.rs b/crates/bevy_mod_scripting_core/src/pipeline/machines.rs index 4858d2c369..2ca903e6e9 100644 --- a/crates/bevy_mod_scripting_core/src/pipeline/machines.rs +++ b/crates/bevy_mod_scripting_core/src/pipeline/machines.rs @@ -166,7 +166,8 @@ impl ActiveMachines

{ // removed } Some(Err(err)) => { - _ = world.write_message(ScriptErrorEvent::new(err)); + _ = world + .write_message(ScriptErrorEvent::new(err.with_language(P::LANGUAGE))); // removed } None => { @@ -528,9 +529,10 @@ impl MachineState

for ContextAssigned

{ Ok(_) => {} Err(_) => { drop(contexts_guard); - _ = world.write_message(ScriptErrorEvent::new(ScriptError::from( - InteropError::str("no context policy matched"), - ))) + _ = world.write_message(ScriptErrorEvent::new( + ScriptError::from(InteropError::str("no context policy matched")) + .with_language(P::LANGUAGE), + )) } } Box::new(ready(Ok( diff --git a/crates/bevy_mod_scripting_core/src/pipeline/mod.rs b/crates/bevy_mod_scripting_core/src/pipeline/mod.rs index 33ece17db8..10bbe91fd8 100644 --- a/crates/bevy_mod_scripting_core/src/pipeline/mod.rs +++ b/crates/bevy_mod_scripting_core/src/pipeline/mod.rs @@ -12,7 +12,7 @@ use bevy_ecs::{ world::World, }; use bevy_log::debug; -use bevy_mod_scripting_asset::ScriptAsset; +use bevy_mod_scripting_asset::{Language, ScriptAsset}; use bevy_mod_scripting_bindings::WorldGuard; use bevy_mod_scripting_display::DisplayProxy; use bevy_platform::collections::HashSet; @@ -160,7 +160,7 @@ pub struct LoadedWithHandles<'w, 's, T: GetScriptHandle + Message + Clone> { assets: ResMut<'w, Assets>, asset_server: Res<'w, AssetServer>, fresh_events: MessageReader<'w, 's, T>, - loaded_with_handles: Local<'s, VecDeque<(T, StrongScriptHandle)>>, + loaded_with_handles: Local<'s, VecDeque<(T, StrongScriptHandle, Language)>>, loading: Local<'s, VecDeque>, } @@ -170,7 +170,7 @@ impl LoadedWithHandles<'_, '_, T> { /// /// This uses a [`EventReader`] underneath, meaning if you don't call this method once every frame (or every other frame). /// You may miss events. - pub fn get_loaded(&mut self) -> impl Iterator { + pub fn get_loaded(&mut self) -> impl Iterator { // first get all of the fresh_events self.loading.extend(self.fresh_events.read().cloned()); // now process the loading queue @@ -180,7 +180,8 @@ impl LoadedWithHandles<'_, '_, T> { Some(LoadState::Loaded) | None => { // none in case this is added in memory and not through asset server let strong = StrongScriptHandle::from_assets(handle, &mut self.assets); if let Some(strong) = strong { - self.loaded_with_handles.push_front((e.clone(), strong)); + let lang = strong.get(&self.assets).language.clone(); + self.loaded_with_handles.push_front((e.clone(), strong, lang)); } false } diff --git a/crates/bevy_mod_scripting_core/src/pipeline/start.rs b/crates/bevy_mod_scripting_core/src/pipeline/start.rs index 78092f2f6f..6e94a85221 100644 --- a/crates/bevy_mod_scripting_core/src/pipeline/start.rs +++ b/crates/bevy_mod_scripting_core/src/pipeline/start.rs @@ -84,11 +84,17 @@ pub fn filter_script_attachments( mut events: LoadedWithHandles, mut filtered: MessageWriter>, ) { - let mut batch = events.get_loaded().map(|(mut a, b)| { - trace!("dispatching script attachment event for: {a:?}"); - *a.0.script_mut() = b.0; - ForPlugin::new(a) - }); + let mut batch = events + .get_loaded() + .filter(|(_, _, l)| *l == P::LANGUAGE) + .map(|(mut a, b, _)| { + trace!( + "dispatching script attachment event for: {a:?}, language: {}", + P::LANGUAGE + ); + *a.0.script_mut() = b.0; + ForPlugin::new(a) + }); if let Some(next) = batch.next() { filtered.write_batch(std::iter::once(next).chain(batch)); diff --git a/crates/languages/bevy_mod_scripting_lua/src/lib.rs b/crates/languages/bevy_mod_scripting_lua/src/lib.rs index 109b7c6f3c..161eeb99c4 100644 --- a/crates/languages/bevy_mod_scripting_lua/src/lib.rs +++ b/crates/languages/bevy_mod_scripting_lua/src/lib.rs @@ -355,6 +355,7 @@ pub fn lua_handler( let out = handler .call::(input) .map_err(IntoInteropError::to_bms_error)?; + Ok(out.into()) } diff --git a/examples/game_of_life.rs b/examples/game_of_life.rs index 39eca62288..d5a73f4cd3 100644 --- a/examples/game_of_life.rs +++ b/examples/game_of_life.rs @@ -18,7 +18,6 @@ use bevy_mod_scripting_bindings::AllocatorDiagnosticPlugin; use clap::Parser; // CONSOLE SETUP - fn console_app(app: &mut App) -> &mut App { // forward logs to the console app.add_plugins(( @@ -114,7 +113,6 @@ pub enum GameOfLifeCommand { // ------------- GAME OF LIFE fn game_of_life_app(app: &mut App) -> &mut App { app.insert_resource(Time::::from_seconds(UPDATE_FREQUENCY.into())) - // .add_plugins(BMSPlugin.set(LuaScriptingPlugin::default().enable_context_sharing())) .add_plugins(BMSPlugin) .register_type::() .register_type::() @@ -176,6 +174,7 @@ pub fn register_script_functions(app: &mut App) -> &mut App { app } +// drawing based on https://github.com/bevyengine/bevy/blob/main/examples/2d/cpu_draw.rs pub fn init_game_of_life_state( mut commands: Commands, mut assets: ResMut>, @@ -194,18 +193,11 @@ pub fn init_game_of_life_state( ); image.sampler = ImageSampler::nearest(); + let handle = assets.add(image); commands.spawn(Camera2d); commands - .spawn(Sprite { - image: assets.add(image), - custom_size: Some(Vec2::new( - settings.display_grid_dimensions.0 as f32, - settings.display_grid_dimensions.1 as f32, - )), - color: Color::srgb(1.0, 0.388, 0.278), // TOMATO - ..Default::default() - }) + .spawn(Sprite::from_image(handle)) .insert(LifeState { cells: vec![ 0u8; From a08db66e1d77c06797251a91a401b75feda43099 Mon Sep 17 00:00:00 2001 From: makspll Date: Wed, 12 Nov 2025 19:39:00 +0000 Subject: [PATCH 17/22] fix change detection --- .github/workflows/synchronize_bindings.yml | 2 +- .../synchronize_bindings_check_diff.yml | 40 ++++++++++++++++++- 2 files changed, 39 insertions(+), 3 deletions(-) diff --git a/.github/workflows/synchronize_bindings.yml b/.github/workflows/synchronize_bindings.yml index aaaa55ff19..4c0ba2ee6c 100644 --- a/.github/workflows/synchronize_bindings.yml +++ b/.github/workflows/synchronize_bindings.yml @@ -32,7 +32,7 @@ jobs: run: | if [[ -n $(git status --porcelain) ]]; then echo "changes=true" >> "$GITHUB_OUTPUT" - git diff > bindings.diff + git diff --text > bindings.diff echo "Diff created:" cat bindings.diff else diff --git a/.github/workflows/synchronize_bindings_check_diff.yml b/.github/workflows/synchronize_bindings_check_diff.yml index aebef0fdb2..7d2cd2f521 100644 --- a/.github/workflows/synchronize_bindings_check_diff.yml +++ b/.github/workflows/synchronize_bindings_check_diff.yml @@ -15,8 +15,9 @@ jobs: env: DIFF_ARTIFACT: bindings.diff PR_EVENT: event-bindings.json + EVENT_FILE: event.json steps: - - name: Download Benchmark Results + - name: Download Diff Results uses: dawidd6/action-download-artifact@v6 with: name: ${{ env.DIFF_ARTIFACT }} @@ -31,13 +32,48 @@ jobs: with: script: | let fs = require('fs'); - let prEvent = JSON.parse(fs.readFileSync(process.env.PR_EVENT, {encoding: 'utf8'})); + let prEvent = JSON.parse(fs.readFileSync(process.env.EVENT_FILE, {encoding: 'utf8'})); core.exportVariable("PR_HEAD", prEvent.pull_request.head.ref); core.exportVariable("PR_BASE", prEvent.pull_request.base.ref); core.exportVariable("PR_BASE_SHA", prEvent.pull_request.base.sha); core.exportVariable("PR_NUMBER", prEvent.number); core.exportVariable("HEAD_REPO", prEvent.pull_request.head.repo.full_name); core.exportVariable("HEAD_REPO_URL", prEvent.pull_request.head.repo.git_url); + + - name: Build Collapsible Diff Comment + id: build_comment + continue-on-error: true + shell: bash + run: | + echo '### 🔍 Binding Differences Detected' > comment.md + echo '' >> comment.md + echo '> The following changes were detected in generated bindings:' >> comment.md + echo '' >> comment.md + + # Build collapsible sections per file + awk ' + /^diff --git/ { + if (file != "") print "" >> "comment.md" + file=$4 + gsub(/^a\//, "", file) + print "

" file "
" >> "comment.md"
+            next
+          }
+          { print $0 >> "comment.md" }
+          END { if (file != "") print "
" >> "comment.md" } + ' "${{ env.DIFF_ARTIFACT }}" + + - name: Add or Update PR Comment with Diff + id: pr_comment + continue-on-error: true + uses: peter-evans/create-or-update-comment@v4 + with: + issue-number: ${{ env.PR_NUMBER }} + body-path: comment.md + edit-mode: replace + token: ${{ secrets.GITHUB_TOKEN }} + comment-identifier: bindings-diff + - name: Fail PR With URL uses: actions/github-script@v6 with: From 22cda7399371f4d00f9da3cfb1ea1fb12327ac5a Mon Sep 17 00:00:00 2001 From: makspll Date: Wed, 12 Nov 2025 22:44:09 +0000 Subject: [PATCH 18/22] some improvements --- Cargo.toml | 1 + .../crates/crate_feature_graph/src/feature.rs | 40 ++++++++++++++- .../crates/crate_feature_graph/src/graph.rs | 49 ++++++++++--------- codegen/src/passes/write_meta.rs | 5 +- crates/bevy_mod_scripting_bindings/Cargo.toml | 1 + .../src/function/from.rs | 23 +++++++++ .../bevy_a11y_bms_bindings/Cargo.toml | 6 +-- .../bevy_animation_bms_bindings/Cargo.toml | 16 +++--- .../bevy_camera_bms_bindings/Cargo.toml | 18 +++---- .../bevy_color_bms_bindings/Cargo.toml | 4 +- .../Cargo.toml | 22 ++++----- .../bindings/bevy_ecs_bms_bindings/Cargo.toml | 8 +-- .../bevy_gizmos_bms_bindings/Cargo.toml | 18 +++---- .../bevy_gltf_bms_bindings/Cargo.toml | 18 +++---- .../bevy_image_bms_bindings/Cargo.toml | 12 ++--- .../bevy_input_bms_bindings/Cargo.toml | 10 ++-- .../bevy_input_focus_bms_bindings/Cargo.toml | 10 ++-- .../bevy_light_bms_bindings/Cargo.toml | 18 +++---- .../bevy_math_bms_bindings/Cargo.toml | 6 +-- .../bevy_mesh_bms_bindings/Cargo.toml | 14 +++--- .../bindings/bevy_pbr_bms_bindings/Cargo.toml | 18 +++---- .../bevy_picking_bms_bindings/Cargo.toml | 14 +++--- .../bevy_post_process_bms_bindings/Cargo.toml | 18 +++---- .../bevy_render_bms_bindings/Cargo.toml | 22 ++++----- .../bevy_scene_bms_bindings/Cargo.toml | 14 +++--- .../bevy_sprite_bms_bindings/Cargo.toml | 16 +++--- .../Cargo.toml | 24 ++++----- .../bevy_text_bms_bindings/Cargo.toml | 16 +++--- .../bevy_time_bms_bindings/Cargo.toml | 8 +-- .../bevy_transform_bms_bindings/Cargo.toml | 10 ++-- .../bindings/bevy_ui_bms_bindings/Cargo.toml | 22 ++++----- .../bevy_ui_render_bms_bindings/Cargo.toml | 22 ++++----- 32 files changed, 283 insertions(+), 220 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 23aa10b513..1aec774a18 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -198,6 +198,7 @@ bevy_utils = { version = "0.17", default-features = false, features = ["std"] } glam = { version = "0.30.7", default-features = false } uuid = { version = "1.13", default-features = false } smol_str = { version = "0.2.0", default-features = false } +nonmax = { version = "0.5.5", default-features = false, features = ["std"] } # other serde_json = { version = "1.0", default-features = false } diff --git a/codegen/crates/crate_feature_graph/src/feature.rs b/codegen/crates/crate_feature_graph/src/feature.rs index 96fa7752ac..d3471b42e3 100644 --- a/codegen/crates/crate_feature_graph/src/feature.rs +++ b/codegen/crates/crate_feature_graph/src/feature.rs @@ -2,6 +2,7 @@ use std::{ borrow::{Borrow, Cow}, collections::VecDeque, fmt::Display, + hash::Hash, }; use cargo_metadata::{ @@ -222,6 +223,43 @@ impl Ord for CrateDependency { } } +/// A feature activation descriptor within a crate +#[derive(Debug, Clone, Eq)] +#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] +pub struct LocalActivatedFeature { + pub feature: FeatureName, + pub activated_via_other_crate: bool, +} + +impl PartialEq for LocalActivatedFeature { + fn eq(&self, other: &Self) -> bool { + self.feature == other.feature + } +} + +impl Ord for LocalActivatedFeature { + fn cmp(&self, other: &Self) -> std::cmp::Ordering { + match self.feature.cmp(&other.feature) { + core::cmp::Ordering::Equal => {} + ord => return ord, + } + self.activated_via_other_crate + .cmp(&other.activated_via_other_crate) + } +} + +impl PartialOrd for LocalActivatedFeature { + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.cmp(other)) + } +} + +impl Hash for LocalActivatedFeature { + fn hash(&self, state: &mut H) { + self.feature.hash(state); + } +} + #[derive(Clone, Debug, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct Crate { @@ -232,7 +270,7 @@ pub struct Crate { pub version: Version, pub in_workspace: Option, pub active_features: Option>, - pub active_dependency_features: Option>>, + pub active_dependency_features: Option>>, pub is_enabled: Option, } diff --git a/codegen/crates/crate_feature_graph/src/graph.rs b/codegen/crates/crate_feature_graph/src/graph.rs index 9ce700e175..e04418189d 100644 --- a/codegen/crates/crate_feature_graph/src/graph.rs +++ b/codegen/crates/crate_feature_graph/src/graph.rs @@ -4,7 +4,7 @@ use indexmap::{IndexMap, IndexSet}; use log::error; use petgraph::Directed; -use crate::{CrateName, DependencyKind, Feature, FeatureName, Workspace}; +use crate::{CrateName, DependencyKind, Feature, FeatureName, LocalActivatedFeature, Workspace}; #[derive(Clone, Debug, PartialEq, Eq)] pub enum DependsOn { @@ -328,16 +328,7 @@ impl WorkspaceGraph { .as_ref() .map(|m| { m.iter() - .map(|(k, v)| { - ( - k.to_string(), - v.iter() - .map(|(f, enabled_by_shared)| { - (f.to_string(), enabled_by_shared) - }) - .collect::>(), - ) - }) + .map(|(k, v)| (k.to_string(), v.iter().collect::>())) .collect() }) .unwrap_or_default(), @@ -353,12 +344,10 @@ impl WorkspaceGraph { "{}: [{}]", k, v.iter() - .map(|(f, enabled_by_shared)| format!( + .map(|f| format!( "{}{}", - f, - enabled_by_shared - .then_some(String::from(" (*shared)")) - .unwrap_or_default() + f.feature, + if f.activated_via_other_crate { String::from(" (*shared)") } else { Default::default() } )) .collect::>() .join(", ") @@ -437,6 +426,7 @@ impl WorkspaceGraph { f.sort() } if let Some(m) = krate.active_dependency_features.as_mut() { + m.sort_keys(); for v in m.values_mut() { v.sort(); } @@ -572,7 +562,7 @@ impl WorkspaceGraph { } // then compute the active dependency features for each crate - let mut active_dependency_features = HashMap::<_, Vec<(_, _)>>::new(); + let mut active_dependency_features = HashMap::<_, Vec<_>>::new(); for krate in self .workspace .all_crates() @@ -602,7 +592,10 @@ impl WorkspaceGraph { active_dependency_features .entry((krate.name.clone(), dependency.name.clone())) .or_default() - .push((feature.clone(), false)); + .push(LocalActivatedFeature { + feature: feature.clone(), + activated_via_other_crate: false, + }); } } } @@ -620,11 +613,11 @@ impl WorkspaceGraph { .filter(|f| !f.is_special_default_enabling_feature()) { // meh - let val = (feat.clone(), true); - let false_val = (feat.clone(), false); - if !entry.contains(&val) && !entry.contains(&false_val) { - entry.push(val); - } + let val = LocalActivatedFeature { + feature: feat.clone(), + activated_via_other_crate: true, + }; + entry.push(val); } } } @@ -642,6 +635,16 @@ impl WorkspaceGraph { if let Some(krate) = self.workspace.find_crate_mut(&in_crate, || format!( "package from workspace manifest: `{in_crate}` was not found in the parsed workspace list. While setting active dependency features." )) { + // remove duplicates, but keep the "lowest" activation level to show + let mut feature_set = HashSet::::with_capacity(features.len()); + for mut feat in features.into_iter() { + if let Some(existing) = feature_set.get(&feat) { + feat.activated_via_other_crate = existing.activated_via_other_crate && feat.activated_via_other_crate; + } + feature_set.insert(feat); + } + let features = feature_set.into_iter().collect(); + match krate.active_dependency_features.as_mut() { Some(map) => { map.insert(dependency, features); diff --git a/codegen/src/passes/write_meta.rs b/codegen/src/passes/write_meta.rs index 9f027b507c..ae00ed6a92 100644 --- a/codegen/src/passes/write_meta.rs +++ b/codegen/src/passes/write_meta.rs @@ -51,10 +51,7 @@ pub(crate) fn write_meta(ctxt: &mut BevyCtxt<'_>, _args: &Args) -> bool { k.to_string(), Dependency { version: d.version.to_string(), - features: features - .iter() - .map(|(feat_name, _)| feat_name.to_string()) - .collect(), + features: features.iter().map(|f| f.feature.to_string()).collect(), }, ), None => todo!(), diff --git a/crates/bevy_mod_scripting_bindings/Cargo.toml b/crates/bevy_mod_scripting_bindings/Cargo.toml index 59d7901bf9..7bdfb0eb6b 100644 --- a/crates/bevy_mod_scripting_bindings/Cargo.toml +++ b/crates/bevy_mod_scripting_bindings/Cargo.toml @@ -32,6 +32,7 @@ profiling = { workspace = true } bevy_asset = { workspace = true } variadics_please = { workspace = true } serde = { workspace = true } +nonmax = { workspace = true } [dev-dependencies] pretty_assertions = { workspace = true } diff --git a/crates/bevy_mod_scripting_bindings/src/function/from.rs b/crates/bevy_mod_scripting_bindings/src/function/from.rs index b03b493c4d..33fa2d8006 100644 --- a/crates/bevy_mod_scripting_bindings/src/function/from.rs +++ b/crates/bevy_mod_scripting_bindings/src/function/from.rs @@ -5,6 +5,7 @@ use crate::{ }; use bevy_platform::collections::{HashMap, HashSet}; use bevy_reflect::{FromReflect, Reflect}; +use nonmax::NonMaxU32; use std::{ any::TypeId, ffi::OsString, @@ -115,6 +116,28 @@ macro_rules! impl_from_stringlike { impl_from_stringlike!(String, PathBuf, OsString); +impl FromScript for NonMaxU32 { + type This<'w> = Self; + + fn from_script( + value: ScriptValue, + _world: WorldGuard<'_>, + ) -> Result, InteropError> + where + Self: Sized, + { + match value { + ScriptValue::Integer(i) if i != 0 => Ok(unsafe { NonMaxU32::new_unchecked(i as u32) }), + ScriptValue::Float(f) if f != 0.0 => Ok(unsafe { NonMaxU32::new_unchecked(f as u32) }), + // ScriptValue::Reference(r) => r.downcast::(world), + _ => Err(InteropError::value_mismatch( + std::any::TypeId::of::(), + value, + )), + } + } +} + #[profiling::all_functions] impl FromScript for char { type This<'w> = Self; diff --git a/crates/bindings/bevy_a11y_bms_bindings/Cargo.toml b/crates/bindings/bevy_a11y_bms_bindings/Cargo.toml index 3fbc89a7cf..6e40f18cb8 100644 --- a/crates/bindings/bevy_a11y_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_a11y_bms_bindings/Cargo.toml @@ -20,12 +20,12 @@ bevy_mod_scripting_derive = { workspace = true } bevy_a11y = { version = "0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "reflect_auto_register", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["error_panic_hook", "std", "bevy_reflect", "reflect_auto_register"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "multi_threaded", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["reflect_auto_register", "bevy_reflect", "serialize", "std", "backtrace", "async_executor", "multi_threaded"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["std", "uuid", "smallvec", "debug_stack", "auto_register", "smol_str", "glam", "debug", "auto_register_inventory"], default-features = true} diff --git a/crates/bindings/bevy_animation_bms_bindings/Cargo.toml b/crates/bindings/bevy_animation_bms_bindings/Cargo.toml index 0ed8acccf8..f8ef6715ca 100644 --- a/crates/bindings/bevy_animation_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_animation_bms_bindings/Cargo.toml @@ -22,25 +22,25 @@ bevy_animation = { version = "0.17.2", features = [], default-features = true} bevy_animation_macros = { version = "^0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["reflect_auto_register", "std", "bevy_reflect", "error_panic_hook"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "multi_threaded", "watch", "file_watcher"], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["encase", "std", "wgpu-types", "bevy_reflect", "alloc"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "backtrace", "serialize", "bevy_reflect", "multi_threaded", "reflect_auto_register"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "curve", "bevy_reflect", "rand", "alloc"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["debug_stack", "debug", "smol_str", "auto_register", "std", "uuid", "glam", "auto_register_inventory", "smallvec"], default-features = true} -bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} +bevy_time = { version = "^0.17.2", features = ["bevy_reflect", "std"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["bevy-support", "bevy_log", "bevy_reflect", "std", "async_executor", "alloc"], default-features = true} bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} diff --git a/crates/bindings/bevy_camera_bms_bindings/Cargo.toml b/crates/bindings/bevy_camera_bms_bindings/Cargo.toml index 02a6a2dbe6..da9898d566 100644 --- a/crates/bindings/bevy_camera_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_camera_bms_bindings/Cargo.toml @@ -20,28 +20,28 @@ bevy_mod_scripting_derive = { workspace = true } bevy_camera = { version = "0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["reflect_auto_register", "bevy_reflect", "std", "error_panic_hook"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "multi_threaded", "file_watcher", "watch"], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["std", "alloc", "bevy_reflect", "wgpu-types", "encase"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "reflect_auto_register", "backtrace", "serialize", "bevy_reflect"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["ktx2", "zstd", "bevy_reflect", "hdr", "png", "zstd_rust"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "bevy_reflect", "curve"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["debug", "smallvec", "auto_register", "std", "debug_stack", "glam", "uuid", "smol_str", "auto_register_inventory"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["bevy-support", "std", "async_executor", "bevy_log", "bevy_reflect", "alloc"], default-features = true} bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["bevy_reflect", "bevy_asset", "bevy_image", "custom_cursor", "std"], default-features = true} diff --git a/crates/bindings/bevy_color_bms_bindings/Cargo.toml b/crates/bindings/bevy_color_bms_bindings/Cargo.toml index 27c1e36e3b..881ca5c4e7 100644 --- a/crates/bindings/bevy_color_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_color_bms_bindings/Cargo.toml @@ -20,9 +20,9 @@ bevy_mod_scripting_derive = { workspace = true } bevy_color = { version = "0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["curve", "std", "bevy_reflect", "rand", "alloc"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["std", "uuid", "smol_str", "debug_stack", "smallvec", "glam", "auto_register", "auto_register_inventory", "debug"], default-features = true} bytemuck = { version = "^1", features = [], default-features = true} diff --git a/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml b/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml index eaded9f4c7..8027229187 100644 --- a/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml @@ -20,33 +20,33 @@ bevy_mod_scripting_derive = { workspace = true } bevy_core_pipeline = { version = "0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "reflect_auto_register", "std"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["file_watcher", "multi_threaded", "notify-debouncer-full", "watch"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["encase", "wgpu-types", "alloc", "std", "bevy_reflect"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["bevy_reflect", "std", "reflect_auto_register", "serialize", "async_executor", "backtrace", "multi_threaded"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["ktx2", "zstd", "hdr", "png", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["zstd", "hdr", "bevy_reflect", "zstd_rust", "ktx2", "png"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "curve", "std", "rand", "bevy_reflect"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register_inventory", "auto_register", "std", "debug_stack", "smol_str", "debug", "smallvec", "glam", "uuid"], default-features = true} -bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} +bevy_render = { version = "^0.17.2", features = ["webgl", "multi_threaded"], default-features = true} bevy_shader = { version = "^0.17.2", features = [], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "alloc", "async_executor", "bevy_reflect", "bevy_log"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["bevy_image", "std", "bevy_reflect", "bevy_asset", "custom_cursor"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_ecs_bms_bindings/Cargo.toml b/crates/bindings/bevy_ecs_bms_bindings/Cargo.toml index caaf910f49..6ea3d53f57 100644 --- a/crates/bindings/bevy_ecs_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_ecs_bms_bindings/Cargo.toml @@ -24,13 +24,13 @@ arrayvec = { version = "^0.7.4", features = ["std"], default-features = false} bevy_ecs_macros = { version = "^0.17.2", features = [], default-features = true} -bevy_platform = { version = "^0.17.2", features = ["std", "serialize", "alloc"], default-features = true} +bevy_platform = { version = "^0.17.2", features = ["alloc", "std", "serialize"], default-features = true} bevy_ptr = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "auto_register", "glam", "uuid", "smol_str", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "std", "auto_register", "debug_stack", "uuid", "smallvec", "smol_str", "debug", "auto_register_inventory"], default-features = true} -bevy_tasks = { version = "^0.17.2", features = ["async_executor", "multi_threaded", "futures-lite"], default-features = true} +bevy_tasks = { version = "^0.17.2", features = ["multi_threaded", "futures-lite", "async_executor"], default-features = true} bevy_utils = { version = "^0.17.2", features = ["parallel", "std", "debug"], default-features = true} @@ -38,7 +38,7 @@ bitflags = { version = "^2.3", features = ["std"], default-features = false} bumpalo = { version = "^3", features = [], default-features = true} -concurrent-queue = { version = "^2.5.0", features = ["std", "std"], default-features = false} +concurrent-queue = { version = "^2.5.0", features = ["std"], default-features = false} fixedbitset = { version = "^0.5", features = ["std"], default-features = false} diff --git a/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml b/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml index f357a033e7..a130977b1c 100644 --- a/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml @@ -20,31 +20,31 @@ bevy_mod_scripting_derive = { workspace = true } bevy_gizmos = { version = "0.17.2", features = ["bevy_pbr", "bevy_core_pipeline", "bevy_render", "bevy_sprite_render", "webgl"], default-features = false} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "error_panic_hook", "reflect_auto_register", "bevy_reflect"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["multi_threaded", "file_watcher", "notify-debouncer-full", "watch"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["alloc", "std", "bevy_reflect", "wgpu-types", "encase"], default-features = true} -bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} +bevy_core_pipeline = { version = "^0.17.2", features = ["webgl", "tonemapping_luts"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["backtrace", "std", "bevy_reflect", "reflect_auto_register", "serialize", "multi_threaded", "async_executor"], default-features = true} bevy_gizmos_macros = { version = "^0.17.2", features = [], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["png", "zstd", "hdr", "ktx2", "bevy_reflect", "zstd_rust"], default-features = true} bevy_light = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "rand", "bevy_reflect", "alloc", "curve"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} bevy_pbr = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["smol_str", "auto_register", "auto_register_inventory", "smallvec", "glam", "debug", "debug_stack", "std", "uuid"], default-features = true} bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} @@ -54,7 +54,7 @@ bevy_sprite_render = { version = "^0.17.2", features = ["bevy_text", "webgl"], d bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["async_executor", "std", "alloc", "bevy-support", "bevy_reflect", "bevy_log"], default-features = true} bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} diff --git a/crates/bindings/bevy_gltf_bms_bindings/Cargo.toml b/crates/bindings/bevy_gltf_bms_bindings/Cargo.toml index 465a5e174d..9d701b1f0e 100644 --- a/crates/bindings/bevy_gltf_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_gltf_bms_bindings/Cargo.toml @@ -24,35 +24,35 @@ base64 = { version = "^0.22.0", features = [], default-features = true} bevy_animation = { version = "^0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "std", "error_panic_hook", "reflect_auto_register"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "multi_threaded", "file_watcher", "watch"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["bevy_reflect", "wgpu-types", "std", "alloc", "encase"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["reflect_auto_register", "async_executor", "serialize", "backtrace", "std", "multi_threaded", "bevy_reflect"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["ktx2", "hdr", "zstd", "zstd_rust", "png", "bevy_reflect"], default-features = true} bevy_light = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "bevy_reflect", "alloc"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} bevy_pbr = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["uuid", "auto_register_inventory", "smol_str", "smallvec", "debug_stack", "glam", "auto_register", "std", "debug"], default-features = true} bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} bevy_scene = { version = "^0.17.2", features = ["serialize"], default-features = true} -bevy_tasks = { version = "^0.17.2", features = ["async_executor", "futures-lite", "multi_threaded"], default-features = true} +bevy_tasks = { version = "^0.17.2", features = ["futures-lite", "multi_threaded", "async_executor"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["bevy_reflect", "alloc", "std", "bevy-support", "async_executor", "bevy_log"], default-features = true} fixedbitset = { version = "^0.5", features = [], default-features = true} diff --git a/crates/bindings/bevy_image_bms_bindings/Cargo.toml b/crates/bindings/bevy_image_bms_bindings/Cargo.toml index 5dfdefa293..752b94fa5e 100644 --- a/crates/bindings/bevy_image_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_image_bms_bindings/Cargo.toml @@ -22,15 +22,15 @@ bevy_image = { version = "0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zs bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "multi_threaded", "file_watcher", "watch"], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["bevy_reflect", "wgpu-types", "alloc", "encase", "std"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["bevy_reflect", "alloc", "std", "rand", "curve"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "curve", "std", "rand", "bevy_reflect"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["uuid", "smallvec", "debug", "auto_register_inventory", "smol_str", "std", "debug_stack", "glam", "auto_register"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} @@ -42,7 +42,7 @@ guillotiere = { version = "^0.6.0", features = [], default-features = true} half = { version = "^2.4.1", features = [], default-features = true} -image = { version = "^0.25.2", features = ["hdr", "png"], default-features = false} +image = { version = "^0.25.2", features = ["png", "hdr"], default-features = false} ktx2 = { version = "^0.4.0", features = [], default-features = true} diff --git a/crates/bindings/bevy_input_bms_bindings/Cargo.toml b/crates/bindings/bevy_input_bms_bindings/Cargo.toml index 35c5329b27..7cb42a77ee 100644 --- a/crates/bindings/bevy_input_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_input_bms_bindings/Cargo.toml @@ -20,14 +20,14 @@ bevy_mod_scripting_derive = { workspace = true } bevy_input = { version = "0.17.2", features = ["std", "bevy_reflect", "smol_str"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "reflect_auto_register", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "multi_threaded", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "multi_threaded", "async_executor", "backtrace", "bevy_reflect", "serialize", "reflect_auto_register"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "alloc", "rand", "curve"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "curve", "alloc", "rand"], default-features = true} -bevy_platform = { version = "^0.17.2", features = ["std", "alloc", "serialize"], default-features = true} +bevy_platform = { version = "^0.17.2", features = ["serialize", "std", "alloc"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "smol_str", "glam", "uuid", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["uuid", "debug_stack", "smol_str", "glam", "std", "auto_register_inventory", "debug", "auto_register", "smallvec"], default-features = true} diff --git a/crates/bindings/bevy_input_focus_bms_bindings/Cargo.toml b/crates/bindings/bevy_input_focus_bms_bindings/Cargo.toml index f5fe7df372..9d8e28ba17 100644 --- a/crates/bindings/bevy_input_focus_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_input_focus_bms_bindings/Cargo.toml @@ -20,16 +20,16 @@ bevy_mod_scripting_derive = { workspace = true } bevy_input_focus = { version = "0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "reflect_auto_register", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "multi_threaded", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["multi_threaded", "async_executor", "reflect_auto_register", "bevy_reflect", "backtrace", "serialize", "std"], default-features = true} bevy_input = { version = "^0.17.2", features = ["std", "bevy_reflect", "smol_str"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "alloc", "rand", "curve"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["rand", "std", "bevy_reflect", "alloc", "curve"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["smallvec", "auto_register", "auto_register_inventory", "glam", "smol_str", "debug", "debug_stack", "std", "uuid"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["std", "bevy_reflect", "bevy_image", "bevy_asset", "custom_cursor"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["bevy_reflect", "bevy_asset", "custom_cursor", "std", "bevy_image"], default-features = true} diff --git a/crates/bindings/bevy_light_bms_bindings/Cargo.toml b/crates/bindings/bevy_light_bms_bindings/Cargo.toml index bdcddafacb..17fd165628 100644 --- a/crates/bindings/bevy_light_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_light_bms_bindings/Cargo.toml @@ -20,27 +20,27 @@ bevy_mod_scripting_derive = { workspace = true } bevy_light = { version = "0.17.2", features = ["webgl"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "std", "reflect_auto_register"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["multi_threaded", "notify-debouncer-full", "watch", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "encase", "bevy_reflect"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["serialize", "std", "async_executor", "bevy_reflect", "reflect_auto_register", "multi_threaded", "backtrace"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "zstd_rust", "ktx2", "hdr", "zstd", "png"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["curve", "alloc", "rand", "std", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_platform = { version = "^0.17.2", features = ["alloc", "std", "serialize"], default-features = true} +bevy_platform = { version = "^0.17.2", features = ["serialize", "alloc", "std"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["smallvec", "auto_register", "std", "uuid", "debug", "glam", "auto_register_inventory", "debug_stack", "smol_str"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["bevy_reflect", "alloc", "bevy_log", "std", "async_executor", "bevy-support"], default-features = true} bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} diff --git a/crates/bindings/bevy_math_bms_bindings/Cargo.toml b/crates/bindings/bevy_math_bms_bindings/Cargo.toml index dc18f5c448..1a93ce312c 100644 --- a/crates/bindings/bevy_math_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_math_bms_bindings/Cargo.toml @@ -20,17 +20,17 @@ bevy_mod_scripting_derive = { workspace = true } bevy_math = { version = "0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "debug", "uuid", "std", "glam", "auto_register_inventory", "smallvec", "debug_stack", "smol_str"], default-features = true} derive_more = { version = "^2", features = ["std"], default-features = false} glam = { version = "^0.30.1", features = ["std", "rand"], default-features = false} -itertools = { version = "^0.14.0", features = ["use_alloc", "use_std"], default-features = false} +itertools = { version = "^0.14.0", features = ["use_std", "use_alloc"], default-features = false} rand = { version = "^0.9", features = ["alloc", "std"], default-features = false} -rand_distr = { version = "^0.5", features = ["alloc", "std"], default-features = false} +rand_distr = { version = "^0.5", features = ["std", "alloc"], default-features = false} variadics_please = { version = "^1.1", features = [], default-features = true} diff --git a/crates/bindings/bevy_mesh_bms_bindings/Cargo.toml b/crates/bindings/bevy_mesh_bms_bindings/Cargo.toml index 12a4cbd5da..537a68ee14 100644 --- a/crates/bindings/bevy_mesh_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_mesh_bms_bindings/Cargo.toml @@ -20,23 +20,23 @@ bevy_mod_scripting_derive = { workspace = true } bevy_mesh = { version = "0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "reflect_auto_register", "error_panic_hook", "bevy_reflect"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["multi_threaded", "notify-debouncer-full", "file_watcher", "watch"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["serialize", "bevy_reflect", "std", "async_executor", "multi_threaded", "backtrace", "reflect_auto_register"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["zstd_rust", "zstd", "ktx2", "hdr", "bevy_reflect", "png"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "bevy_reflect", "curve"], default-features = true} bevy_mikktspace = { version = "^0.17.0-dev", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "smol_str", "uuid", "debug_stack", "auto_register_inventory", "std", "smallvec", "debug", "glam"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "alloc", "bevy_reflect", "bevy_log", "async_executor", "bevy-support"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml b/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml index 0fe487789d..5dd2969f0f 100644 --- a/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml @@ -20,13 +20,13 @@ bevy_mod_scripting_derive = { workspace = true } bevy_pbr = { version = "0.17.2", features = ["webgl"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "error_panic_hook", "reflect_auto_register", "bevy_reflect"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["watch", "notify-debouncer-full", "multi_threaded", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["encase", "wgpu-types", "alloc", "std", "bevy_reflect"], default-features = true} bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} @@ -34,25 +34,25 @@ bevy_derive = { version = "^0.17.2", features = [], default-features = true} bevy_diagnostic = { version = "^0.17.2", features = ["std", "sysinfo", "sysinfo_plugin"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "reflect_auto_register", "multi_threaded", "bevy_reflect", "async_executor", "backtrace", "serialize"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["png", "bevy_reflect", "ktx2", "zstd_rust", "zstd", "hdr"], default-features = true} bevy_light = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "curve", "rand", "alloc", "bevy_reflect"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["smol_str", "debug_stack", "std", "uuid", "auto_register", "debug", "smallvec", "auto_register_inventory", "glam"], default-features = true} bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} bevy_shader = { version = "^0.17.2", features = [], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["bevy-support", "bevy_log", "std", "bevy_reflect", "async_executor", "alloc"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_picking_bms_bindings/Cargo.toml b/crates/bindings/bevy_picking_bms_bindings/Cargo.toml index 77612c0975..cc4566f5cc 100644 --- a/crates/bindings/bevy_picking_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_picking_bms_bindings/Cargo.toml @@ -20,27 +20,27 @@ bevy_mod_scripting_derive = { workspace = true } bevy_picking = { version = "0.17.2", features = ["bevy_mesh_picking_backend"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["error_panic_hook", "reflect_auto_register", "std", "bevy_reflect"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["file_watcher", "notify-debouncer-full", "multi_threaded", "watch"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["serialize", "backtrace", "reflect_auto_register", "std", "async_executor", "multi_threaded", "bevy_reflect"], default-features = true} -bevy_input = { version = "^0.17.2", features = ["std", "bevy_reflect", "smol_str"], default-features = true} +bevy_input = { version = "^0.17.2", features = ["smol_str", "std", "bevy_reflect"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "rand", "curve", "alloc"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["smallvec", "glam", "smol_str", "auto_register_inventory", "debug_stack", "auto_register", "std", "uuid", "debug"], default-features = true} bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["bevy-support", "std", "alloc", "bevy_log", "bevy_reflect", "async_executor"], default-features = true} bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} diff --git a/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml b/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml index a694159e18..4c530e7cb4 100644 --- a/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml @@ -22,33 +22,33 @@ bevy_post_process = { version = "0.17.2", features = [], default-features = true bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["watch", "file_watcher", "multi_threaded", "notify-debouncer-full"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "bevy_reflect", "std", "encase"], default-features = true} bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "serialize", "reflect_auto_register", "multi_threaded", "bevy_reflect", "async_executor", "backtrace"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "ktx2", "hdr", "png", "zstd_rust", "zstd"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["rand", "bevy_reflect", "alloc", "std", "curve"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["debug_stack", "auto_register", "smallvec", "glam", "uuid", "auto_register_inventory", "std", "debug", "smol_str"], default-features = true} -bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} +bevy_render = { version = "^0.17.2", features = ["webgl", "multi_threaded"], default-features = true} bevy_shader = { version = "^0.17.2", features = [], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["async_executor", "alloc", "std", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["bevy_asset", "bevy_reflect", "std", "custom_cursor", "bevy_image"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_render_bms_bindings/Cargo.toml b/crates/bindings/bevy_render_bms_bindings/Cargo.toml index 00a707b93a..9edc79854a 100644 --- a/crates/bindings/bevy_render_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_render_bms_bindings/Cargo.toml @@ -22,43 +22,43 @@ bevy_render = { version = "0.17.2", features = ["multi_threaded", "webgl"], defa async-channel = { version = "^2.3.0", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["error_panic_hook", "reflect_auto_register", "bevy_reflect", "std"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["multi_threaded", "notify-debouncer-full", "watch", "file_watcher"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["encase", "alloc", "wgpu-types", "std", "bevy_reflect"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_diagnostic = { version = "^0.17.2", features = ["std", "sysinfo", "sysinfo_plugin"], default-features = true} +bevy_diagnostic = { version = "^0.17.2", features = ["std", "sysinfo_plugin", "sysinfo"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["bevy_reflect", "multi_threaded", "serialize", "reflect_auto_register", "backtrace", "std", "async_executor"], default-features = true} bevy_encase_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["hdr", "bevy_reflect", "png", "ktx2", "zstd", "zstd_rust"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "curve", "alloc", "bevy_reflect", "rand"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["std", "debug_stack", "debug", "glam", "smol_str", "auto_register_inventory", "smallvec", "auto_register", "uuid"], default-features = true} bevy_render_macros = { version = "^0.17.2", features = [], default-features = true} bevy_shader = { version = "^0.17.2", features = [], default-features = true} -bevy_tasks = { version = "^0.17.2", features = ["multi_threaded", "async_executor", "futures-lite"], default-features = true} +bevy_tasks = { version = "^0.17.2", features = ["multi_threaded", "futures-lite", "async_executor"], default-features = true} bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["async_executor", "bevy_reflect", "bevy-support", "alloc", "std", "bevy_log"], default-features = true} bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["bevy_image", "std", "bevy_reflect", "bevy_asset", "custom_cursor"], default-features = true} bitflags = { version = "^2", features = [], default-features = true} diff --git a/crates/bindings/bevy_scene_bms_bindings/Cargo.toml b/crates/bindings/bevy_scene_bms_bindings/Cargo.toml index 334a1766ff..b29cc1923c 100644 --- a/crates/bindings/bevy_scene_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_scene_bms_bindings/Cargo.toml @@ -20,26 +20,26 @@ bevy_mod_scripting_derive = { workspace = true } bevy_scene = { version = "0.17.2", features = ["serialize"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["error_panic_hook", "bevy_reflect", "reflect_auto_register", "std"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["watch", "file_watcher", "multi_threaded", "notify-debouncer-full"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["serialize", "std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["serialize", "reflect_auto_register", "backtrace", "bevy_reflect", "std", "async_executor", "multi_threaded"], default-features = true} -bevy_platform = { version = "^0.17.2", features = ["serialize", "alloc", "std"], default-features = true} +bevy_platform = { version = "^0.17.2", features = ["alloc", "serialize", "std"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["smol_str", "auto_register_inventory", "uuid", "auto_register", "debug_stack", "glam", "std", "smallvec", "debug"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "alloc", "bevy_log", "bevy_reflect", "async_executor"], default-features = true} bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} serde = { version = "^1.0", features = [], default-features = true} -uuid = { version = "^1.13.1", features = ["serde", "serde"], default-features = false} +uuid = { version = "^1.13.1", features = ["serde"], default-features = false} diff --git a/crates/bindings/bevy_sprite_bms_bindings/Cargo.toml b/crates/bindings/bevy_sprite_bms_bindings/Cargo.toml index 6603309374..9fbf74350d 100644 --- a/crates/bindings/bevy_sprite_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_sprite_bms_bindings/Cargo.toml @@ -22,31 +22,31 @@ bevy_sprite = { version = "0.17.2", features = ["bevy_picking", "bevy_window", " bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["watch", "file_watcher", "multi_threaded", "notify-debouncer-full"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["wgpu-types", "bevy_reflect", "encase", "std", "alloc"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "serialize", "async_executor", "bevy_reflect", "reflect_auto_register", "multi_threaded", "backtrace"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["zstd", "hdr", "png", "bevy_reflect", "zstd_rust", "ktx2"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "bevy_reflect", "alloc"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} bevy_picking = { version = "^0.17.2", features = ["bevy_mesh_picking_backend"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "auto_register", "debug_stack", "std", "uuid", "smol_str", "smallvec", "auto_register_inventory", "debug"], default-features = true} bevy_text = { version = "^0.17.2", features = ["default_font"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["bevy_log", "bevy_reflect", "std", "alloc", "bevy-support", "async_executor"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["std", "custom_cursor", "bevy_asset", "bevy_image", "bevy_reflect"], default-features = true} radsort = { version = "^0.1", features = [], default-features = true} diff --git a/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml b/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml index c037728a5f..c681cca629 100644 --- a/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml @@ -20,39 +20,39 @@ bevy_mod_scripting_derive = { workspace = true } bevy_sprite_render = { version = "0.17.2", features = ["bevy_text", "webgl"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "std", "reflect_auto_register", "error_panic_hook"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "file_watcher", "watch", "multi_threaded"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["bevy_reflect", "std", "wgpu-types", "alloc", "encase"], default-features = true} -bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} +bevy_core_pipeline = { version = "^0.17.2", features = ["webgl", "tonemapping_luts"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["async_executor", "std", "multi_threaded", "backtrace", "bevy_reflect", "serialize", "reflect_auto_register"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["zstd", "zstd_rust", "ktx2", "bevy_reflect", "hdr", "png"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "alloc", "rand", "curve"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register_inventory", "debug_stack", "glam", "smol_str", "std", "smallvec", "uuid", "debug", "auto_register"], default-features = true} -bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} +bevy_render = { version = "^0.17.2", features = ["webgl", "multi_threaded"], default-features = true} bevy_shader = { version = "^0.17.2", features = [], default-features = true} -bevy_sprite = { version = "^0.17.2", features = ["bevy_text", "bevy_picking", "bevy_window", "bevy_sprite_picking_backend"], default-features = true} +bevy_sprite = { version = "^0.17.2", features = ["bevy_text", "bevy_picking", "bevy_sprite_picking_backend", "bevy_window"], default-features = true} bevy_text = { version = "^0.17.2", features = ["default_font"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["bevy-support", "alloc", "bevy_log", "async_executor", "std", "bevy_reflect"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_text_bms_bindings/Cargo.toml b/crates/bindings/bevy_text_bms_bindings/Cargo.toml index 1fab9a0ad3..c1b235328f 100644 --- a/crates/bindings/bevy_text_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_text_bms_bindings/Cargo.toml @@ -20,25 +20,25 @@ bevy_mod_scripting_derive = { workspace = true } bevy_text = { version = "0.17.2", features = ["default_font"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "error_panic_hook", "bevy_reflect", "reflect_auto_register"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "file_watcher", "multi_threaded"], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "wgpu-types", "encase", "alloc"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "reflect_auto_register", "serialize", "multi_threaded", "bevy_reflect", "backtrace"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["png", "zstd_rust", "ktx2", "zstd", "hdr", "bevy_reflect"], default-features = true} bevy_log = { version = "^0.17.2", features = [], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["rand", "bevy_reflect", "curve", "alloc", "std"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["std", "smallvec", "smol_str", "uuid", "auto_register", "debug_stack", "auto_register_inventory", "glam", "debug"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} cosmic-text = { version = "^0.14", features = [], default-features = true} diff --git a/crates/bindings/bevy_time_bms_bindings/Cargo.toml b/crates/bindings/bevy_time_bms_bindings/Cargo.toml index c5c2c83399..ee667997be 100644 --- a/crates/bindings/bevy_time_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_time_bms_bindings/Cargo.toml @@ -20,12 +20,12 @@ bevy_mod_scripting_derive = { workspace = true } bevy_time = { version = "0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "reflect_auto_register", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["error_panic_hook", "std", "reflect_auto_register", "bevy_reflect"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "multi_threaded", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["reflect_auto_register", "async_executor", "serialize", "std", "backtrace", "bevy_reflect", "multi_threaded"], default-features = true} -bevy_platform = { version = "^0.17.2", features = ["std", "alloc", "serialize"], default-features = true} +bevy_platform = { version = "^0.17.2", features = ["std", "serialize", "alloc"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["glam", "auto_register", "uuid", "debug_stack", "debug", "std", "smallvec", "smol_str", "auto_register_inventory"], default-features = true} diff --git a/crates/bindings/bevy_transform_bms_bindings/Cargo.toml b/crates/bindings/bevy_transform_bms_bindings/Cargo.toml index 1dea392fa8..c4fc8b352a 100644 --- a/crates/bindings/bevy_transform_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_transform_bms_bindings/Cargo.toml @@ -20,15 +20,15 @@ bevy_mod_scripting_derive = { workspace = true } bevy_transform = { version = "0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "reflect_auto_register", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["reflect_auto_register", "bevy_reflect", "error_panic_hook", "std"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "async_executor", "multi_threaded", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["backtrace", "reflect_auto_register", "async_executor", "serialize", "std", "bevy_reflect", "multi_threaded"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "alloc", "rand", "curve"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "alloc", "bevy_reflect", "curve", "rand"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "uuid", "std", "glam", "auto_register_inventory", "smallvec", "smol_str", "debug", "debug_stack"], default-features = true} -bevy_tasks = { version = "^0.17.2", features = ["async_executor", "futures-lite", "multi_threaded"], default-features = true} +bevy_tasks = { version = "^0.17.2", features = ["futures-lite", "multi_threaded", "async_executor"], default-features = true} bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} diff --git a/crates/bindings/bevy_ui_bms_bindings/Cargo.toml b/crates/bindings/bevy_ui_bms_bindings/Cargo.toml index 80a8023ab6..f7dc2c2c7e 100644 --- a/crates/bindings/bevy_ui_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_ui_bms_bindings/Cargo.toml @@ -24,37 +24,37 @@ accesskit = { version = "^0.21", features = [], default-features = true} bevy_a11y = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["std", "error_panic_hook", "reflect_auto_register", "bevy_reflect"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "multi_threaded", "file_watcher", "watch"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["std", "encase", "bevy_reflect", "wgpu-types", "alloc"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "async_executor", "multi_threaded", "serialize", "backtrace"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["zstd_rust", "zstd", "bevy_reflect", "ktx2", "hdr", "png"], default-features = true} bevy_input = { version = "^0.17.2", features = ["std", "bevy_reflect", "smol_str"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["curve", "bevy_reflect", "rand", "alloc", "std"], default-features = true} bevy_picking = { version = "^0.17.2", features = ["bevy_mesh_picking_backend"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["std", "uuid", "auto_register", "smallvec", "glam", "smol_str", "debug", "debug_stack", "auto_register_inventory"], default-features = true} -bevy_sprite = { version = "^0.17.2", features = ["bevy_picking", "bevy_window", "bevy_sprite_picking_backend", "bevy_text"], default-features = true} +bevy_sprite = { version = "^0.17.2", features = ["bevy_window", "bevy_sprite_picking_backend", "bevy_text", "bevy_picking"], default-features = true} bevy_text = { version = "^0.17.2", features = ["default_font"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["alloc", "bevy-support", "bevy_reflect", "async_executor", "bevy_log", "std"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["bevy_reflect", "std", "bevy_asset", "custom_cursor", "bevy_image"], default-features = true} taffy = { version = "^0.7", features = [], default-features = true} diff --git a/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml b/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml index a6c9fd3f62..b2b377c1f4 100644 --- a/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml @@ -20,41 +20,41 @@ bevy_mod_scripting_derive = { workspace = true } bevy_ui_render = { version = "0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["reflect_auto_register", "bevy_reflect", "std", "error_panic_hook"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "multi_threaded", "file_watcher", "watch"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "wgpu-types", "alloc"], default-features = true} -bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} +bevy_core_pipeline = { version = "^0.17.2", features = ["webgl", "tonemapping_luts"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "backtrace", "async_executor", "reflect_auto_register", "serialize", "multi_threaded"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "bevy_reflect", "png", "zstd", "zstd_rust"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "rand", "alloc", "curve"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "uuid", "smol_str", "auto_register", "auto_register_inventory", "std", "smallvec", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register_inventory", "std", "auto_register", "uuid", "debug", "smallvec", "glam", "smol_str", "debug_stack"], default-features = true} bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} bevy_shader = { version = "^0.17.2", features = [], default-features = true} -bevy_sprite = { version = "^0.17.2", features = ["bevy_picking", "bevy_window", "bevy_sprite_picking_backend", "bevy_text"], default-features = true} +bevy_sprite = { version = "^0.17.2", features = ["bevy_sprite_picking_backend", "bevy_text", "bevy_picking", "bevy_window"], default-features = true} bevy_sprite_render = { version = "^0.17.2", features = ["bevy_text", "webgl"], default-features = true} bevy_text = { version = "^0.17.2", features = ["default_font"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["bevy_log", "bevy-support", "alloc", "async_executor", "std", "bevy_reflect"], default-features = true} -bevy_ui = { version = "^0.17.2", features = ["bevy_picking", "bevy_ui_picking_backend"], default-features = true} +bevy_ui = { version = "^0.17.2", features = ["bevy_ui_picking_backend", "bevy_picking"], default-features = true} bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} From 1410f8152dc57474ca151b342c7f91e044f26254 Mon Sep 17 00:00:00 2001 From: makspll Date: Thu, 13 Nov 2025 09:01:42 +0000 Subject: [PATCH 19/22] make sure deps in meta are sorted --- Cargo.toml | 2 +- codegen/src/meta.rs | 3 ++- codegen/src/passes/find_methods_and_fields.rs | 4 ---- 3 files changed, 3 insertions(+), 6 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 1aec774a18..a67b23aeb3 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -198,7 +198,7 @@ bevy_utils = { version = "0.17", default-features = false, features = ["std"] } glam = { version = "0.30.7", default-features = false } uuid = { version = "1.13", default-features = false } smol_str = { version = "0.2.0", default-features = false } -nonmax = { version = "0.5.5", default-features = false, features = ["std"] } +nonmax = { version = "0.5", default-features = false, features = ["std"] } # other serde_json = { version = "1.0", default-features = false } diff --git a/codegen/src/meta.rs b/codegen/src/meta.rs index fa4afdc930..35590fcb3e 100644 --- a/codegen/src/meta.rs +++ b/codegen/src/meta.rs @@ -7,6 +7,7 @@ use std::{ use cargo_metadata::camino::Utf8PathBuf; use chrono::NaiveDateTime; +use indexmap::IndexMap; use log::trace; use rustc_hir::def_id::DefPathHash; use serde::{Deserialize, Serialize, Serializer}; @@ -38,7 +39,7 @@ pub struct Meta { pub(crate) version: String, /// a map of crate names to the features that crate was compiled with - pub(crate) dependencies: HashMap, + pub(crate) dependencies: IndexMap, } #[derive(Serialize, Deserialize, Clone, Debug)] diff --git a/codegen/src/passes/find_methods_and_fields.rs b/codegen/src/passes/find_methods_and_fields.rs index 39cc1c5bb1..6e92f62a87 100644 --- a/codegen/src/passes/find_methods_and_fields.rs +++ b/codegen/src/passes/find_methods_and_fields.rs @@ -202,10 +202,6 @@ pub(crate) fn find_methods_and_fields(ctxt: &mut BevyCtxt<'_>, args: &Args) -> b }) .unwrap_or(true); - log::info!("function: {}, is_stable_for_target: {is_stable_for_target}, stability: {:?}", ctxt.tcx.item_name(def_id), ctxt - .tcx - .lookup_stability(fn_did)); - if !is_stable_for_target { log::debug!( "Skipping unstable function: `{}` on type: `{}`, msrv target: {:?}", From d9501a0f7c4f3df8e1c2ff6eb1c367bddfe61930 Mon Sep 17 00:00:00 2001 From: makspll Date: Thu, 13 Nov 2025 09:13:21 +0000 Subject: [PATCH 20/22] finally make Cargo.toml generation stable --- codegen/src/callback.rs | 12 ++++++--- .../bevy_a11y_bms_bindings/Cargo.toml | 8 +++--- .../bevy_animation_bms_bindings/Cargo.toml | 16 ++++++------ .../bevy_asset_bms_bindings/Cargo.toml | 4 +-- .../bevy_camera_bms_bindings/Cargo.toml | 20 +++++++------- .../bevy_color_bms_bindings/Cargo.toml | 6 ++--- .../Cargo.toml | 16 ++++++------ .../bindings/bevy_ecs_bms_bindings/Cargo.toml | 12 ++++----- .../bevy_gizmos_bms_bindings/Cargo.toml | 24 ++++++++--------- .../bevy_gltf_bms_bindings/Cargo.toml | 18 ++++++------- .../bevy_image_bms_bindings/Cargo.toml | 14 +++++----- .../bevy_input_bms_bindings/Cargo.toml | 12 ++++----- .../bevy_input_focus_bms_bindings/Cargo.toml | 14 +++++----- .../bevy_light_bms_bindings/Cargo.toml | 20 +++++++------- .../bevy_math_bms_bindings/Cargo.toml | 10 +++---- .../bevy_mesh_bms_bindings/Cargo.toml | 14 +++++----- .../bindings/bevy_pbr_bms_bindings/Cargo.toml | 16 ++++++------ .../bevy_picking_bms_bindings/Cargo.toml | 18 ++++++------- .../bevy_post_process_bms_bindings/Cargo.toml | 22 ++++++++-------- .../bevy_render_bms_bindings/Cargo.toml | 26 +++++++++---------- .../bevy_scene_bms_bindings/Cargo.toml | 12 ++++----- .../bevy_sprite_bms_bindings/Cargo.toml | 20 +++++++------- .../Cargo.toml | 22 ++++++++-------- .../bevy_text_bms_bindings/Cargo.toml | 14 +++++----- .../bevy_time_bms_bindings/Cargo.toml | 10 +++---- .../bevy_transform_bms_bindings/Cargo.toml | 14 +++++----- .../bindings/bevy_ui_bms_bindings/Cargo.toml | 24 ++++++++--------- .../bevy_ui_render_bms_bindings/Cargo.toml | 24 ++++++++--------- 28 files changed, 223 insertions(+), 219 deletions(-) diff --git a/codegen/src/callback.rs b/codegen/src/callback.rs index 22d01bd2eb..c98b01d36e 100644 --- a/codegen/src/callback.rs +++ b/codegen/src/callback.rs @@ -66,6 +66,13 @@ impl rustc_driver::Callbacks for BevyAnalyzerCallbacks { let tera = crate::configure_tera(tcx.crate_name(LOCAL_CRATE).as_str(), &templates_dir); info!("Using meta directories: {meta_dirs:?}"); + + let mut graph = WorkspaceGraph::deserialize(&PathBuf::from( + std::env::var(WORKSPACE_GRAPH_FILE_ENV).unwrap(), + )) + .unwrap(); + graph.stable_sort(); + let mut ctxt = crate::BevyCtxt::new( tcx, &meta_dirs, @@ -77,10 +84,7 @@ impl rustc_driver::Callbacks for BevyAnalyzerCallbacks { tera.render(&TemplateKind::ImportProcessor.to_string(), &ctxt) .unwrap() })), - WorkspaceGraph::deserialize(&PathBuf::from( - std::env::var(WORKSPACE_GRAPH_FILE_ENV).unwrap(), - )) - .unwrap(), + graph, ); trace!("Running all passes"); diff --git a/crates/bindings/bevy_a11y_bms_bindings/Cargo.toml b/crates/bindings/bevy_a11y_bms_bindings/Cargo.toml index 6e40f18cb8..64efd0dd52 100644 --- a/crates/bindings/bevy_a11y_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_a11y_bms_bindings/Cargo.toml @@ -17,15 +17,15 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_a11y = { version = "0.17.2", features = ["std", "bevy_reflect"], default-features = true} +bevy_a11y = { version = "0.17.2", features = ["bevy_reflect", "std"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["error_panic_hook", "std", "bevy_reflect", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "reflect_auto_register", "std"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["reflect_auto_register", "bevy_reflect", "serialize", "std", "backtrace", "async_executor", "multi_threaded"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["async_executor", "backtrace", "bevy_reflect", "multi_threaded", "reflect_auto_register", "serialize", "std"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "uuid", "smallvec", "debug_stack", "auto_register", "smol_str", "glam", "debug", "auto_register_inventory"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} diff --git a/crates/bindings/bevy_animation_bms_bindings/Cargo.toml b/crates/bindings/bevy_animation_bms_bindings/Cargo.toml index f8ef6715ca..2e32dc2378 100644 --- a/crates/bindings/bevy_animation_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_animation_bms_bindings/Cargo.toml @@ -22,27 +22,27 @@ bevy_animation = { version = "0.17.2", features = [], default-features = true} bevy_animation_macros = { version = "^0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["reflect_auto_register", "std", "bevy_reflect", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "reflect_auto_register", "std"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "multi_threaded", "watch", "file_watcher"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["file_watcher", "multi_threaded", "notify-debouncer-full", "watch"], default-features = true} -bevy_color = { version = "^0.17.2", features = ["encase", "std", "wgpu-types", "bevy_reflect", "alloc"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "encase", "std", "wgpu-types"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "backtrace", "serialize", "bevy_reflect", "multi_threaded", "reflect_auto_register"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["async_executor", "backtrace", "bevy_reflect", "multi_threaded", "reflect_auto_register", "serialize", "std"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "curve", "bevy_reflect", "rand", "alloc"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "curve", "rand", "std"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["debug_stack", "debug", "smol_str", "auto_register", "std", "uuid", "glam", "auto_register_inventory", "smallvec"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} bevy_time = { version = "^0.17.2", features = ["bevy_reflect", "std"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["bevy-support", "bevy_log", "bevy_reflect", "std", "async_executor", "alloc"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["alloc", "async_executor", "bevy-support", "bevy_log", "bevy_reflect", "std"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} blake3 = { version = "^1.0", features = [], default-features = true} diff --git a/crates/bindings/bevy_asset_bms_bindings/Cargo.toml b/crates/bindings/bevy_asset_bms_bindings/Cargo.toml index bfd7abf50d..3e89b5c7b7 100644 --- a/crates/bindings/bevy_asset_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_asset_bms_bindings/Cargo.toml @@ -17,12 +17,12 @@ bevy_app = { workspace = true, features = ["std"] } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_asset = { version = "0.17.2", features = ["notify-debouncer-full", "watch", "multi_threaded", "file_watcher"], default-features = true} +bevy_asset = { version = "0.17.2", features = ["file_watcher", "multi_threaded", "notify-debouncer-full", "watch"], default-features = true} bevy_asset_macros = { version = "^0.17.2", features = [], default-features = true} -bevy_tasks = { version = "^0.17.2", features = ["multi_threaded", "async_executor", "futures-lite"], default-features = true} +bevy_tasks = { version = "^0.17.2", features = ["async_executor", "futures-lite", "multi_threaded"], default-features = true} js-sys = { version = "^0.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_camera_bms_bindings/Cargo.toml b/crates/bindings/bevy_camera_bms_bindings/Cargo.toml index da9898d566..b737c093b3 100644 --- a/crates/bindings/bevy_camera_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_camera_bms_bindings/Cargo.toml @@ -20,28 +20,28 @@ bevy_mod_scripting_derive = { workspace = true } bevy_camera = { version = "0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["reflect_auto_register", "bevy_reflect", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "reflect_auto_register", "std"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "multi_threaded", "file_watcher", "watch"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["file_watcher", "multi_threaded", "notify-debouncer-full", "watch"], default-features = true} -bevy_color = { version = "^0.17.2", features = ["std", "alloc", "bevy_reflect", "wgpu-types", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "encase", "std", "wgpu-types"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "multi_threaded", "reflect_auto_register", "backtrace", "serialize", "bevy_reflect"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["async_executor", "backtrace", "bevy_reflect", "multi_threaded", "reflect_auto_register", "serialize", "std"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["ktx2", "zstd", "bevy_reflect", "hdr", "png", "zstd_rust"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "bevy_reflect", "curve"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "curve", "rand", "std"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["debug", "smallvec", "auto_register", "std", "debug_stack", "glam", "uuid", "smol_str", "auto_register_inventory"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["bevy-support", "std", "async_executor", "bevy_log", "bevy_reflect", "alloc"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["alloc", "async_executor", "bevy-support", "bevy_log", "bevy_reflect", "std"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["bevy_reflect", "bevy_asset", "bevy_image", "custom_cursor", "std"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["bevy_asset", "bevy_image", "bevy_reflect", "custom_cursor", "std"], default-features = true} diff --git a/crates/bindings/bevy_color_bms_bindings/Cargo.toml b/crates/bindings/bevy_color_bms_bindings/Cargo.toml index 881ca5c4e7..addb65c95f 100644 --- a/crates/bindings/bevy_color_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_color_bms_bindings/Cargo.toml @@ -17,12 +17,12 @@ bevy_app = { workspace = true, features = ["std"] } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_color = { version = "0.17.2", features = ["wgpu-types", "alloc", "std", "bevy_reflect", "encase"], default-features = true} +bevy_color = { version = "0.17.2", features = ["alloc", "bevy_reflect", "encase", "std", "wgpu-types"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["curve", "std", "bevy_reflect", "rand", "alloc"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "curve", "rand", "std"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "uuid", "smol_str", "debug_stack", "smallvec", "glam", "auto_register", "auto_register_inventory", "debug"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} bytemuck = { version = "^1", features = [], default-features = true} diff --git a/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml b/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml index 8027229187..b28e6d2d60 100644 --- a/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml @@ -26,27 +26,27 @@ bevy_asset = { version = "^0.17.2", features = ["file_watcher", "multi_threaded" bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["encase", "wgpu-types", "alloc", "std", "bevy_reflect"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "encase", "std", "wgpu-types"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["bevy_reflect", "std", "reflect_auto_register", "serialize", "async_executor", "backtrace", "multi_threaded"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["async_executor", "backtrace", "bevy_reflect", "multi_threaded", "reflect_auto_register", "serialize", "std"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["zstd", "hdr", "bevy_reflect", "zstd_rust", "ktx2", "png"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "curve", "std", "rand", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "curve", "rand", "std"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["auto_register_inventory", "auto_register", "std", "debug_stack", "smol_str", "debug", "smallvec", "glam", "uuid"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} -bevy_render = { version = "^0.17.2", features = ["webgl", "multi_threaded"], default-features = true} +bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} bevy_shader = { version = "^0.17.2", features = [], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "alloc", "async_executor", "bevy_reflect", "bevy_log"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["alloc", "async_executor", "bevy-support", "bevy_log", "bevy_reflect", "std"], default-features = true} bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["bevy_image", "std", "bevy_reflect", "bevy_asset", "custom_cursor"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["bevy_asset", "bevy_image", "bevy_reflect", "custom_cursor", "std"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_ecs_bms_bindings/Cargo.toml b/crates/bindings/bevy_ecs_bms_bindings/Cargo.toml index 6ea3d53f57..d7a016a361 100644 --- a/crates/bindings/bevy_ecs_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_ecs_bms_bindings/Cargo.toml @@ -17,22 +17,22 @@ bevy_app = { workspace = true, features = ["std"] } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_ecs = { version = "0.17.2", features = ["std", "async_executor", "multi_threaded", "bevy_reflect", "reflect_auto_register", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "0.17.2", features = ["async_executor", "backtrace", "bevy_reflect", "multi_threaded", "reflect_auto_register", "serialize", "std"], default-features = true} arrayvec = { version = "^0.7.4", features = ["std"], default-features = false} bevy_ecs_macros = { version = "^0.17.2", features = [], default-features = true} -bevy_platform = { version = "^0.17.2", features = ["alloc", "std", "serialize"], default-features = true} +bevy_platform = { version = "^0.17.2", features = ["alloc", "serialize", "std"], default-features = true} bevy_ptr = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "std", "auto_register", "debug_stack", "uuid", "smallvec", "smol_str", "debug", "auto_register_inventory"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} -bevy_tasks = { version = "^0.17.2", features = ["multi_threaded", "futures-lite", "async_executor"], default-features = true} +bevy_tasks = { version = "^0.17.2", features = ["async_executor", "futures-lite", "multi_threaded"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "std", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel", "std"], default-features = true} bitflags = { version = "^2.3", features = ["std"], default-features = false} @@ -42,7 +42,7 @@ concurrent-queue = { version = "^2.5.0", features = ["std"], default-features = fixedbitset = { version = "^0.5", features = ["std"], default-features = false} -indexmap = { version = "^2.5.0", features = ["std", "serde"], default-features = false} +indexmap = { version = "^2.5.0", features = ["serde", "std"], default-features = false} log = { version = "^0.4", features = ["std"], default-features = false} diff --git a/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml b/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml index a130977b1c..33004e7c24 100644 --- a/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml @@ -17,34 +17,34 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_gizmos = { version = "0.17.2", features = ["bevy_pbr", "bevy_core_pipeline", "bevy_render", "bevy_sprite_render", "webgl"], default-features = false} +bevy_gizmos = { version = "0.17.2", features = ["bevy_core_pipeline", "bevy_pbr", "bevy_render", "bevy_sprite_render", "webgl"], default-features = false} -bevy_app = { version = "^0.17.2", features = ["std", "error_panic_hook", "reflect_auto_register", "bevy_reflect"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "reflect_auto_register", "std"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["multi_threaded", "file_watcher", "notify-debouncer-full", "watch"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["file_watcher", "multi_threaded", "notify-debouncer-full", "watch"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["alloc", "std", "bevy_reflect", "wgpu-types", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "encase", "std", "wgpu-types"], default-features = true} -bevy_core_pipeline = { version = "^0.17.2", features = ["webgl", "tonemapping_luts"], default-features = true} +bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["backtrace", "std", "bevy_reflect", "reflect_auto_register", "serialize", "multi_threaded", "async_executor"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["async_executor", "backtrace", "bevy_reflect", "multi_threaded", "reflect_auto_register", "serialize", "std"], default-features = true} bevy_gizmos_macros = { version = "^0.17.2", features = [], default-features = true} -bevy_image = { version = "^0.17.2", features = ["png", "zstd", "hdr", "ktx2", "bevy_reflect", "zstd_rust"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} bevy_light = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "rand", "bevy_reflect", "alloc", "curve"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "curve", "rand", "std"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} bevy_pbr = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["smol_str", "auto_register", "auto_register_inventory", "smallvec", "glam", "debug", "debug_stack", "std", "uuid"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} @@ -52,11 +52,11 @@ bevy_shader = { version = "^0.17.2", features = [], default-features = true} bevy_sprite_render = { version = "^0.17.2", features = ["bevy_text", "webgl"], default-features = true} -bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} +bevy_time = { version = "^0.17.2", features = ["bevy_reflect", "std"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["async_executor", "std", "alloc", "bevy-support", "bevy_reflect", "bevy_log"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["alloc", "async_executor", "bevy-support", "bevy_log", "bevy_reflect", "std"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} bytemuck = { version = "^1.0", features = [], default-features = true} diff --git a/crates/bindings/bevy_gltf_bms_bindings/Cargo.toml b/crates/bindings/bevy_gltf_bms_bindings/Cargo.toml index 9d701b1f0e..f4f05b363d 100644 --- a/crates/bindings/bevy_gltf_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_gltf_bms_bindings/Cargo.toml @@ -24,35 +24,35 @@ base64 = { version = "^0.22.0", features = [], default-features = true} bevy_animation = { version = "^0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "std", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "reflect_auto_register", "std"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "multi_threaded", "file_watcher", "watch"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["file_watcher", "multi_threaded", "notify-debouncer-full", "watch"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["bevy_reflect", "wgpu-types", "std", "alloc", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "encase", "std", "wgpu-types"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["reflect_auto_register", "async_executor", "serialize", "backtrace", "std", "multi_threaded", "bevy_reflect"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["async_executor", "backtrace", "bevy_reflect", "multi_threaded", "reflect_auto_register", "serialize", "std"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["ktx2", "hdr", "zstd", "zstd_rust", "png", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} bevy_light = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "bevy_reflect", "alloc"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "curve", "rand", "std"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} bevy_pbr = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["uuid", "auto_register_inventory", "smol_str", "smallvec", "debug_stack", "glam", "auto_register", "std", "debug"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} bevy_scene = { version = "^0.17.2", features = ["serialize"], default-features = true} -bevy_tasks = { version = "^0.17.2", features = ["futures-lite", "multi_threaded", "async_executor"], default-features = true} +bevy_tasks = { version = "^0.17.2", features = ["async_executor", "futures-lite", "multi_threaded"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["bevy_reflect", "alloc", "std", "bevy-support", "async_executor", "bevy_log"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["alloc", "async_executor", "bevy-support", "bevy_log", "bevy_reflect", "std"], default-features = true} fixedbitset = { version = "^0.5", features = [], default-features = true} diff --git a/crates/bindings/bevy_image_bms_bindings/Cargo.toml b/crates/bindings/bevy_image_bms_bindings/Cargo.toml index 752b94fa5e..95aac2a446 100644 --- a/crates/bindings/bevy_image_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_image_bms_bindings/Cargo.toml @@ -17,18 +17,18 @@ bevy_ecs = { workspace = true, features = ["std", "bevy_reflect"] } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_image = { version = "0.17.2", features = ["hdr", "ktx2", "png", "zstd", "zstd_rust", "bevy_reflect"], default-features = true} +bevy_image = { version = "0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "reflect_auto_register", "std"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "multi_threaded", "file_watcher", "watch"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["file_watcher", "multi_threaded", "notify-debouncer-full", "watch"], default-features = true} -bevy_color = { version = "^0.17.2", features = ["bevy_reflect", "wgpu-types", "alloc", "encase", "std"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "encase", "std", "wgpu-types"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "curve", "std", "rand", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "curve", "rand", "std"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["uuid", "smallvec", "debug", "auto_register_inventory", "smol_str", "std", "debug_stack", "glam", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} @@ -42,7 +42,7 @@ guillotiere = { version = "^0.6.0", features = [], default-features = true} half = { version = "^2.4.1", features = [], default-features = true} -image = { version = "^0.25.2", features = ["png", "hdr"], default-features = false} +image = { version = "^0.25.2", features = ["hdr", "png"], default-features = false} ktx2 = { version = "^0.4.0", features = [], default-features = true} diff --git a/crates/bindings/bevy_input_bms_bindings/Cargo.toml b/crates/bindings/bevy_input_bms_bindings/Cargo.toml index 7cb42a77ee..e4ab536a48 100644 --- a/crates/bindings/bevy_input_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_input_bms_bindings/Cargo.toml @@ -17,17 +17,17 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_input = { version = "0.17.2", features = ["std", "bevy_reflect", "smol_str"], default-features = true} +bevy_input = { version = "0.17.2", features = ["bevy_reflect", "smol_str", "std"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "reflect_auto_register", "std"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "multi_threaded", "async_executor", "backtrace", "bevy_reflect", "serialize", "reflect_auto_register"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["async_executor", "backtrace", "bevy_reflect", "multi_threaded", "reflect_auto_register", "serialize", "std"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "curve", "alloc", "rand"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "curve", "rand", "std"], default-features = true} -bevy_platform = { version = "^0.17.2", features = ["serialize", "std", "alloc"], default-features = true} +bevy_platform = { version = "^0.17.2", features = ["alloc", "serialize", "std"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["uuid", "debug_stack", "smol_str", "glam", "std", "auto_register_inventory", "debug", "auto_register", "smallvec"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} diff --git a/crates/bindings/bevy_input_focus_bms_bindings/Cargo.toml b/crates/bindings/bevy_input_focus_bms_bindings/Cargo.toml index 9d8e28ba17..2de73b8ef6 100644 --- a/crates/bindings/bevy_input_focus_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_input_focus_bms_bindings/Cargo.toml @@ -17,19 +17,19 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_input_focus = { version = "0.17.2", features = ["std", "bevy_reflect"], default-features = true} +bevy_input_focus = { version = "0.17.2", features = ["bevy_reflect", "std"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "bevy_reflect", "error_panic_hook", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "reflect_auto_register", "std"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["multi_threaded", "async_executor", "reflect_auto_register", "bevy_reflect", "backtrace", "serialize", "std"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["async_executor", "backtrace", "bevy_reflect", "multi_threaded", "reflect_auto_register", "serialize", "std"], default-features = true} -bevy_input = { version = "^0.17.2", features = ["std", "bevy_reflect", "smol_str"], default-features = true} +bevy_input = { version = "^0.17.2", features = ["bevy_reflect", "smol_str", "std"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["rand", "std", "bevy_reflect", "alloc", "curve"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "curve", "rand", "std"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["smallvec", "auto_register", "auto_register_inventory", "glam", "smol_str", "debug", "debug_stack", "std", "uuid"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["bevy_reflect", "bevy_asset", "custom_cursor", "std", "bevy_image"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["bevy_asset", "bevy_image", "bevy_reflect", "custom_cursor", "std"], default-features = true} diff --git a/crates/bindings/bevy_light_bms_bindings/Cargo.toml b/crates/bindings/bevy_light_bms_bindings/Cargo.toml index 17fd165628..e2b6193b93 100644 --- a/crates/bindings/bevy_light_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_light_bms_bindings/Cargo.toml @@ -20,28 +20,28 @@ bevy_mod_scripting_derive = { workspace = true } bevy_light = { version = "0.17.2", features = ["webgl"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "std", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "reflect_auto_register", "std"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["multi_threaded", "notify-debouncer-full", "watch", "file_watcher"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["file_watcher", "multi_threaded", "notify-debouncer-full", "watch"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "std", "encase", "bevy_reflect"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "encase", "std", "wgpu-types"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["serialize", "std", "async_executor", "bevy_reflect", "reflect_auto_register", "multi_threaded", "backtrace"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["async_executor", "backtrace", "bevy_reflect", "multi_threaded", "reflect_auto_register", "serialize", "std"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "zstd_rust", "ktx2", "hdr", "zstd", "png"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["curve", "alloc", "rand", "std", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "curve", "rand", "std"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_platform = { version = "^0.17.2", features = ["serialize", "alloc", "std"], default-features = true} +bevy_platform = { version = "^0.17.2", features = ["alloc", "serialize", "std"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["smallvec", "auto_register", "std", "uuid", "debug", "glam", "auto_register_inventory", "debug_stack", "smol_str"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["bevy_reflect", "alloc", "bevy_log", "std", "async_executor", "bevy-support"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["alloc", "async_executor", "bevy-support", "bevy_log", "bevy_reflect", "std"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} diff --git a/crates/bindings/bevy_math_bms_bindings/Cargo.toml b/crates/bindings/bevy_math_bms_bindings/Cargo.toml index 1a93ce312c..5c53ead352 100644 --- a/crates/bindings/bevy_math_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_math_bms_bindings/Cargo.toml @@ -17,20 +17,20 @@ bevy_app = { workspace = true, features = ["std"] } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_math = { version = "0.17.2", features = ["alloc", "std", "rand", "curve", "bevy_reflect"], default-features = true} +bevy_math = { version = "0.17.2", features = ["alloc", "bevy_reflect", "curve", "rand", "std"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["auto_register", "debug", "uuid", "std", "glam", "auto_register_inventory", "smallvec", "debug_stack", "smol_str"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} derive_more = { version = "^2", features = ["std"], default-features = false} -glam = { version = "^0.30.1", features = ["std", "rand"], default-features = false} +glam = { version = "^0.30.1", features = ["rand", "std"], default-features = false} -itertools = { version = "^0.14.0", features = ["use_std", "use_alloc"], default-features = false} +itertools = { version = "^0.14.0", features = ["use_alloc", "use_std"], default-features = false} rand = { version = "^0.9", features = ["alloc", "std"], default-features = false} -rand_distr = { version = "^0.5", features = ["std", "alloc"], default-features = false} +rand_distr = { version = "^0.5", features = ["alloc", "std"], default-features = false} variadics_please = { version = "^1.1", features = [], default-features = true} diff --git a/crates/bindings/bevy_mesh_bms_bindings/Cargo.toml b/crates/bindings/bevy_mesh_bms_bindings/Cargo.toml index 537a68ee14..e5d2415af9 100644 --- a/crates/bindings/bevy_mesh_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_mesh_bms_bindings/Cargo.toml @@ -20,23 +20,23 @@ bevy_mod_scripting_derive = { workspace = true } bevy_mesh = { version = "0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "reflect_auto_register", "error_panic_hook", "bevy_reflect"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "reflect_auto_register", "std"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["multi_threaded", "notify-debouncer-full", "file_watcher", "watch"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["file_watcher", "multi_threaded", "notify-debouncer-full", "watch"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["serialize", "bevy_reflect", "std", "async_executor", "multi_threaded", "backtrace", "reflect_auto_register"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["async_executor", "backtrace", "bevy_reflect", "multi_threaded", "reflect_auto_register", "serialize", "std"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["zstd_rust", "zstd", "ktx2", "hdr", "bevy_reflect", "png"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["alloc", "std", "rand", "bevy_reflect", "curve"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "curve", "rand", "std"], default-features = true} bevy_mikktspace = { version = "^0.17.0-dev", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["auto_register", "smol_str", "uuid", "debug_stack", "auto_register_inventory", "std", "smallvec", "debug", "glam"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "alloc", "bevy_reflect", "bevy_log", "async_executor", "bevy-support"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["alloc", "async_executor", "bevy-support", "bevy_log", "bevy_reflect", "std"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml b/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml index 5dd2969f0f..1e9450c057 100644 --- a/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_pbr_bms_bindings/Cargo.toml @@ -20,13 +20,13 @@ bevy_mod_scripting_derive = { workspace = true } bevy_pbr = { version = "0.17.2", features = ["webgl"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "error_panic_hook", "reflect_auto_register", "bevy_reflect"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "reflect_auto_register", "std"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["watch", "notify-debouncer-full", "multi_threaded", "file_watcher"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["file_watcher", "multi_threaded", "notify-debouncer-full", "watch"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["encase", "wgpu-types", "alloc", "std", "bevy_reflect"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "encase", "std", "wgpu-types"], default-features = true} bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} @@ -34,23 +34,23 @@ bevy_derive = { version = "^0.17.2", features = [], default-features = true} bevy_diagnostic = { version = "^0.17.2", features = ["std", "sysinfo", "sysinfo_plugin"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "reflect_auto_register", "multi_threaded", "bevy_reflect", "async_executor", "backtrace", "serialize"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["async_executor", "backtrace", "bevy_reflect", "multi_threaded", "reflect_auto_register", "serialize", "std"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["png", "bevy_reflect", "ktx2", "zstd_rust", "zstd", "hdr"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} bevy_light = { version = "^0.17.2", features = ["webgl"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "curve", "rand", "alloc", "bevy_reflect"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "curve", "rand", "std"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["smol_str", "debug_stack", "std", "uuid", "auto_register", "debug", "smallvec", "auto_register_inventory", "glam"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} bevy_shader = { version = "^0.17.2", features = [], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["bevy-support", "bevy_log", "std", "bevy_reflect", "async_executor", "alloc"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["alloc", "async_executor", "bevy-support", "bevy_log", "bevy_reflect", "std"], default-features = true} bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} diff --git a/crates/bindings/bevy_picking_bms_bindings/Cargo.toml b/crates/bindings/bevy_picking_bms_bindings/Cargo.toml index cc4566f5cc..697f762d14 100644 --- a/crates/bindings/bevy_picking_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_picking_bms_bindings/Cargo.toml @@ -20,29 +20,29 @@ bevy_mod_scripting_derive = { workspace = true } bevy_picking = { version = "0.17.2", features = ["bevy_mesh_picking_backend"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["error_panic_hook", "reflect_auto_register", "std", "bevy_reflect"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "reflect_auto_register", "std"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["file_watcher", "notify-debouncer-full", "multi_threaded", "watch"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["file_watcher", "multi_threaded", "notify-debouncer-full", "watch"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["serialize", "backtrace", "reflect_auto_register", "std", "async_executor", "multi_threaded", "bevy_reflect"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["async_executor", "backtrace", "bevy_reflect", "multi_threaded", "reflect_auto_register", "serialize", "std"], default-features = true} -bevy_input = { version = "^0.17.2", features = ["smol_str", "std", "bevy_reflect"], default-features = true} +bevy_input = { version = "^0.17.2", features = ["bevy_reflect", "smol_str", "std"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "rand", "curve", "alloc"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "curve", "rand", "std"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["smallvec", "glam", "smol_str", "auto_register_inventory", "debug_stack", "auto_register", "std", "uuid", "debug"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} -bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} +bevy_time = { version = "^0.17.2", features = ["bevy_reflect", "std"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["bevy-support", "std", "alloc", "bevy_log", "bevy_reflect", "async_executor"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["alloc", "async_executor", "bevy-support", "bevy_log", "bevy_reflect", "std"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["bevy_image", "bevy_asset", "custom_cursor", "std", "bevy_reflect"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["bevy_asset", "bevy_image", "bevy_reflect", "custom_cursor", "std"], default-features = true} crossbeam-channel = { version = "^0.5", features = [], default-features = true} diff --git a/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml b/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml index 4c530e7cb4..9b6096c2d2 100644 --- a/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_post_process_bms_bindings/Cargo.toml @@ -20,35 +20,35 @@ bevy_mod_scripting_derive = { workspace = true } bevy_post_process = { version = "0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "reflect_auto_register", "std"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["watch", "file_watcher", "multi_threaded", "notify-debouncer-full"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["file_watcher", "multi_threaded", "notify-debouncer-full", "watch"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "alloc", "bevy_reflect", "std", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "encase", "std", "wgpu-types"], default-features = true} bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "serialize", "reflect_auto_register", "multi_threaded", "bevy_reflect", "async_executor", "backtrace"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["async_executor", "backtrace", "bevy_reflect", "multi_threaded", "reflect_auto_register", "serialize", "std"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "ktx2", "hdr", "png", "zstd_rust", "zstd"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["rand", "bevy_reflect", "alloc", "std", "curve"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "curve", "rand", "std"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["debug_stack", "auto_register", "smallvec", "glam", "uuid", "auto_register_inventory", "std", "debug", "smol_str"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} -bevy_render = { version = "^0.17.2", features = ["webgl", "multi_threaded"], default-features = true} +bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} bevy_shader = { version = "^0.17.2", features = [], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["async_executor", "alloc", "std", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["alloc", "async_executor", "bevy-support", "bevy_log", "bevy_reflect", "std"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["bevy_asset", "bevy_reflect", "std", "custom_cursor", "bevy_image"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["bevy_asset", "bevy_image", "bevy_reflect", "custom_cursor", "std"], default-features = true} bitflags = { version = "^2.3", features = [], default-features = true} diff --git a/crates/bindings/bevy_render_bms_bindings/Cargo.toml b/crates/bindings/bevy_render_bms_bindings/Cargo.toml index 9edc79854a..798290eb69 100644 --- a/crates/bindings/bevy_render_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_render_bms_bindings/Cargo.toml @@ -22,43 +22,43 @@ bevy_render = { version = "0.17.2", features = ["multi_threaded", "webgl"], defa async-channel = { version = "^2.3.0", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["error_panic_hook", "reflect_auto_register", "bevy_reflect", "std"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "reflect_auto_register", "std"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["multi_threaded", "notify-debouncer-full", "watch", "file_watcher"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["file_watcher", "multi_threaded", "notify-debouncer-full", "watch"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["encase", "alloc", "wgpu-types", "std", "bevy_reflect"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "encase", "std", "wgpu-types"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_diagnostic = { version = "^0.17.2", features = ["std", "sysinfo_plugin", "sysinfo"], default-features = true} +bevy_diagnostic = { version = "^0.17.2", features = ["std", "sysinfo", "sysinfo_plugin"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["bevy_reflect", "multi_threaded", "serialize", "reflect_auto_register", "backtrace", "std", "async_executor"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["async_executor", "backtrace", "bevy_reflect", "multi_threaded", "reflect_auto_register", "serialize", "std"], default-features = true} bevy_encase_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "bevy_reflect", "png", "ktx2", "zstd", "zstd_rust"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "curve", "alloc", "bevy_reflect", "rand"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "curve", "rand", "std"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "debug_stack", "debug", "glam", "smol_str", "auto_register_inventory", "smallvec", "auto_register", "uuid"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} bevy_render_macros = { version = "^0.17.2", features = [], default-features = true} bevy_shader = { version = "^0.17.2", features = [], default-features = true} -bevy_tasks = { version = "^0.17.2", features = ["multi_threaded", "futures-lite", "async_executor"], default-features = true} +bevy_tasks = { version = "^0.17.2", features = ["async_executor", "futures-lite", "multi_threaded"], default-features = true} -bevy_time = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} +bevy_time = { version = "^0.17.2", features = ["bevy_reflect", "std"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["async_executor", "bevy_reflect", "bevy-support", "alloc", "std", "bevy_log"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["alloc", "async_executor", "bevy-support", "bevy_log", "bevy_reflect", "std"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["bevy_image", "std", "bevy_reflect", "bevy_asset", "custom_cursor"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["bevy_asset", "bevy_image", "bevy_reflect", "custom_cursor", "std"], default-features = true} bitflags = { version = "^2", features = [], default-features = true} diff --git a/crates/bindings/bevy_scene_bms_bindings/Cargo.toml b/crates/bindings/bevy_scene_bms_bindings/Cargo.toml index b29cc1923c..0967671b81 100644 --- a/crates/bindings/bevy_scene_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_scene_bms_bindings/Cargo.toml @@ -20,23 +20,23 @@ bevy_mod_scripting_derive = { workspace = true } bevy_scene = { version = "0.17.2", features = ["serialize"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["error_panic_hook", "bevy_reflect", "reflect_auto_register", "std"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "reflect_auto_register", "std"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["watch", "file_watcher", "multi_threaded", "notify-debouncer-full"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["file_watcher", "multi_threaded", "notify-debouncer-full", "watch"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["serialize", "reflect_auto_register", "backtrace", "bevy_reflect", "std", "async_executor", "multi_threaded"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["async_executor", "backtrace", "bevy_reflect", "multi_threaded", "reflect_auto_register", "serialize", "std"], default-features = true} bevy_platform = { version = "^0.17.2", features = ["alloc", "serialize", "std"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["smol_str", "auto_register_inventory", "uuid", "auto_register", "debug_stack", "glam", "std", "smallvec", "debug"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["std", "bevy-support", "alloc", "bevy_log", "bevy_reflect", "async_executor"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["alloc", "async_executor", "bevy-support", "bevy_log", "bevy_reflect", "std"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} serde = { version = "^1.0", features = [], default-features = true} diff --git a/crates/bindings/bevy_sprite_bms_bindings/Cargo.toml b/crates/bindings/bevy_sprite_bms_bindings/Cargo.toml index 9fbf74350d..86a4241cb6 100644 --- a/crates/bindings/bevy_sprite_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_sprite_bms_bindings/Cargo.toml @@ -17,36 +17,36 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_sprite = { version = "0.17.2", features = ["bevy_picking", "bevy_window", "bevy_sprite_picking_backend", "bevy_text"], default-features = true} +bevy_sprite = { version = "0.17.2", features = ["bevy_picking", "bevy_sprite_picking_backend", "bevy_text", "bevy_window"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "reflect_auto_register", "std"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["watch", "file_watcher", "multi_threaded", "notify-debouncer-full"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["file_watcher", "multi_threaded", "notify-debouncer-full", "watch"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["wgpu-types", "bevy_reflect", "encase", "std", "alloc"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "encase", "std", "wgpu-types"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "serialize", "async_executor", "bevy_reflect", "reflect_auto_register", "multi_threaded", "backtrace"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["async_executor", "backtrace", "bevy_reflect", "multi_threaded", "reflect_auto_register", "serialize", "std"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["zstd", "hdr", "png", "bevy_reflect", "zstd_rust", "ktx2"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "rand", "curve", "bevy_reflect", "alloc"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "curve", "rand", "std"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} bevy_picking = { version = "^0.17.2", features = ["bevy_mesh_picking_backend"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "auto_register", "debug_stack", "std", "uuid", "smol_str", "smallvec", "auto_register_inventory", "debug"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} bevy_text = { version = "^0.17.2", features = ["default_font"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["bevy_log", "bevy_reflect", "std", "alloc", "bevy-support", "async_executor"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["alloc", "async_executor", "bevy-support", "bevy_log", "bevy_reflect", "std"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["std", "custom_cursor", "bevy_asset", "bevy_image", "bevy_reflect"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["bevy_asset", "bevy_image", "bevy_reflect", "custom_cursor", "std"], default-features = true} radsort = { version = "^0.1", features = [], default-features = true} diff --git a/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml b/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml index c681cca629..26b137bab4 100644 --- a/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml @@ -20,37 +20,37 @@ bevy_mod_scripting_derive = { workspace = true } bevy_sprite_render = { version = "0.17.2", features = ["bevy_text", "webgl"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "std", "reflect_auto_register", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "reflect_auto_register", "std"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "file_watcher", "watch", "multi_threaded"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["file_watcher", "multi_threaded", "notify-debouncer-full", "watch"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["bevy_reflect", "std", "wgpu-types", "alloc", "encase"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "encase", "std", "wgpu-types"], default-features = true} -bevy_core_pipeline = { version = "^0.17.2", features = ["webgl", "tonemapping_luts"], default-features = true} +bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["async_executor", "std", "multi_threaded", "backtrace", "bevy_reflect", "serialize", "reflect_auto_register"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["async_executor", "backtrace", "bevy_reflect", "multi_threaded", "reflect_auto_register", "serialize", "std"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["zstd", "zstd_rust", "ktx2", "bevy_reflect", "hdr", "png"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "alloc", "rand", "curve"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "curve", "rand", "std"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["auto_register_inventory", "debug_stack", "glam", "smol_str", "std", "smallvec", "uuid", "debug", "auto_register"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} -bevy_render = { version = "^0.17.2", features = ["webgl", "multi_threaded"], default-features = true} +bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} bevy_shader = { version = "^0.17.2", features = [], default-features = true} -bevy_sprite = { version = "^0.17.2", features = ["bevy_text", "bevy_picking", "bevy_sprite_picking_backend", "bevy_window"], default-features = true} +bevy_sprite = { version = "^0.17.2", features = ["bevy_picking", "bevy_sprite_picking_backend", "bevy_text", "bevy_window"], default-features = true} bevy_text = { version = "^0.17.2", features = ["default_font"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["bevy-support", "alloc", "bevy_log", "async_executor", "std", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["alloc", "async_executor", "bevy-support", "bevy_log", "bevy_reflect", "std"], default-features = true} bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} diff --git a/crates/bindings/bevy_text_bms_bindings/Cargo.toml b/crates/bindings/bevy_text_bms_bindings/Cargo.toml index c1b235328f..17799c5f8c 100644 --- a/crates/bindings/bevy_text_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_text_bms_bindings/Cargo.toml @@ -20,23 +20,23 @@ bevy_mod_scripting_derive = { workspace = true } bevy_text = { version = "0.17.2", features = ["default_font"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "error_panic_hook", "bevy_reflect", "reflect_auto_register"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "reflect_auto_register", "std"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "watch", "file_watcher", "multi_threaded"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["file_watcher", "multi_threaded", "notify-debouncer-full", "watch"], default-features = true} -bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "wgpu-types", "encase", "alloc"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "encase", "std", "wgpu-types"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "async_executor", "reflect_auto_register", "serialize", "multi_threaded", "bevy_reflect", "backtrace"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["async_executor", "backtrace", "bevy_reflect", "multi_threaded", "reflect_auto_register", "serialize", "std"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["png", "zstd_rust", "ktx2", "zstd", "hdr", "bevy_reflect"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} bevy_log = { version = "^0.17.2", features = [], default-features = true} -bevy_math = { version = "^0.17.2", features = ["rand", "bevy_reflect", "curve", "alloc", "std"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "curve", "rand", "std"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "smallvec", "smol_str", "uuid", "auto_register", "debug_stack", "auto_register_inventory", "glam", "debug"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} diff --git a/crates/bindings/bevy_time_bms_bindings/Cargo.toml b/crates/bindings/bevy_time_bms_bindings/Cargo.toml index ee667997be..3021e4479a 100644 --- a/crates/bindings/bevy_time_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_time_bms_bindings/Cargo.toml @@ -17,15 +17,15 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_time = { version = "0.17.2", features = ["std", "bevy_reflect"], default-features = true} +bevy_time = { version = "0.17.2", features = ["bevy_reflect", "std"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["error_panic_hook", "std", "reflect_auto_register", "bevy_reflect"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "reflect_auto_register", "std"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["reflect_auto_register", "async_executor", "serialize", "std", "backtrace", "bevy_reflect", "multi_threaded"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["async_executor", "backtrace", "bevy_reflect", "multi_threaded", "reflect_auto_register", "serialize", "std"], default-features = true} -bevy_platform = { version = "^0.17.2", features = ["std", "serialize", "alloc"], default-features = true} +bevy_platform = { version = "^0.17.2", features = ["alloc", "serialize", "std"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["glam", "auto_register", "uuid", "debug_stack", "debug", "std", "smallvec", "smol_str", "auto_register_inventory"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} diff --git a/crates/bindings/bevy_transform_bms_bindings/Cargo.toml b/crates/bindings/bevy_transform_bms_bindings/Cargo.toml index c4fc8b352a..0f934d12bb 100644 --- a/crates/bindings/bevy_transform_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_transform_bms_bindings/Cargo.toml @@ -17,19 +17,19 @@ categories.workspace = true bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_transform = { version = "0.17.2", features = ["std", "async_executor", "alloc", "bevy_log", "bevy-support", "bevy_reflect"], default-features = true} +bevy_transform = { version = "0.17.2", features = ["alloc", "async_executor", "bevy-support", "bevy_log", "bevy_reflect", "std"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["reflect_auto_register", "bevy_reflect", "error_panic_hook", "std"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "reflect_auto_register", "std"], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["backtrace", "reflect_auto_register", "async_executor", "serialize", "std", "bevy_reflect", "multi_threaded"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["async_executor", "backtrace", "bevy_reflect", "multi_threaded", "reflect_auto_register", "serialize", "std"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "alloc", "bevy_reflect", "curve", "rand"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "curve", "rand", "std"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["auto_register", "uuid", "std", "glam", "auto_register_inventory", "smallvec", "smol_str", "debug", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} -bevy_tasks = { version = "^0.17.2", features = ["futures-lite", "multi_threaded", "async_executor"], default-features = true} +bevy_tasks = { version = "^0.17.2", features = ["async_executor", "futures-lite", "multi_threaded"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} diff --git a/crates/bindings/bevy_ui_bms_bindings/Cargo.toml b/crates/bindings/bevy_ui_bms_bindings/Cargo.toml index f7dc2c2c7e..01ff25454e 100644 --- a/crates/bindings/bevy_ui_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_ui_bms_bindings/Cargo.toml @@ -22,39 +22,39 @@ bevy_ui = { version = "0.17.2", features = ["bevy_picking", "bevy_ui_picking_bac accesskit = { version = "^0.21", features = [], default-features = true} -bevy_a11y = { version = "^0.17.2", features = ["std", "bevy_reflect"], default-features = true} +bevy_a11y = { version = "^0.17.2", features = ["bevy_reflect", "std"], default-features = true} -bevy_app = { version = "^0.17.2", features = ["std", "error_panic_hook", "reflect_auto_register", "bevy_reflect"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "reflect_auto_register", "std"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "multi_threaded", "file_watcher", "watch"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["file_watcher", "multi_threaded", "notify-debouncer-full", "watch"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["std", "encase", "bevy_reflect", "wgpu-types", "alloc"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "encase", "std", "wgpu-types"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["bevy_reflect", "reflect_auto_register", "std", "async_executor", "multi_threaded", "serialize", "backtrace"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["async_executor", "backtrace", "bevy_reflect", "multi_threaded", "reflect_auto_register", "serialize", "std"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["zstd_rust", "zstd", "bevy_reflect", "ktx2", "hdr", "png"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} -bevy_input = { version = "^0.17.2", features = ["std", "bevy_reflect", "smol_str"], default-features = true} +bevy_input = { version = "^0.17.2", features = ["bevy_reflect", "smol_str", "std"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["curve", "bevy_reflect", "rand", "alloc", "std"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "curve", "rand", "std"], default-features = true} bevy_picking = { version = "^0.17.2", features = ["bevy_mesh_picking_backend"], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["std", "uuid", "auto_register", "smallvec", "glam", "smol_str", "debug", "debug_stack", "auto_register_inventory"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} -bevy_sprite = { version = "^0.17.2", features = ["bevy_window", "bevy_sprite_picking_backend", "bevy_text", "bevy_picking"], default-features = true} +bevy_sprite = { version = "^0.17.2", features = ["bevy_picking", "bevy_sprite_picking_backend", "bevy_text", "bevy_window"], default-features = true} bevy_text = { version = "^0.17.2", features = ["default_font"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["alloc", "bevy-support", "bevy_reflect", "async_executor", "bevy_log", "std"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["alloc", "async_executor", "bevy-support", "bevy_log", "bevy_reflect", "std"], default-features = true} bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} -bevy_window = { version = "^0.17.2", features = ["bevy_reflect", "std", "bevy_asset", "custom_cursor", "bevy_image"], default-features = true} +bevy_window = { version = "^0.17.2", features = ["bevy_asset", "bevy_image", "bevy_reflect", "custom_cursor", "std"], default-features = true} taffy = { version = "^0.7", features = [], default-features = true} diff --git a/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml b/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml index b2b377c1f4..6aabdf0336 100644 --- a/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml @@ -20,43 +20,43 @@ bevy_mod_scripting_derive = { workspace = true } bevy_ui_render = { version = "0.17.2", features = [], default-features = true} -bevy_app = { version = "^0.17.2", features = ["reflect_auto_register", "bevy_reflect", "std", "error_panic_hook"], default-features = true} +bevy_app = { version = "^0.17.2", features = ["bevy_reflect", "error_panic_hook", "reflect_auto_register", "std"], default-features = true} -bevy_asset = { version = "^0.17.2", features = ["notify-debouncer-full", "multi_threaded", "file_watcher", "watch"], default-features = true} +bevy_asset = { version = "^0.17.2", features = ["file_watcher", "multi_threaded", "notify-debouncer-full", "watch"], default-features = true} bevy_camera = { version = "^0.17.2", features = [], default-features = true} -bevy_color = { version = "^0.17.2", features = ["std", "bevy_reflect", "encase", "wgpu-types", "alloc"], default-features = true} +bevy_color = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "encase", "std", "wgpu-types"], default-features = true} -bevy_core_pipeline = { version = "^0.17.2", features = ["webgl", "tonemapping_luts"], default-features = true} +bevy_core_pipeline = { version = "^0.17.2", features = ["tonemapping_luts", "webgl"], default-features = true} bevy_derive = { version = "^0.17.2", features = [], default-features = true} -bevy_ecs = { version = "^0.17.2", features = ["std", "bevy_reflect", "backtrace", "async_executor", "reflect_auto_register", "serialize", "multi_threaded"], default-features = true} +bevy_ecs = { version = "^0.17.2", features = ["async_executor", "backtrace", "bevy_reflect", "multi_threaded", "reflect_auto_register", "serialize", "std"], default-features = true} -bevy_image = { version = "^0.17.2", features = ["hdr", "ktx2", "bevy_reflect", "png", "zstd", "zstd_rust"], default-features = true} +bevy_image = { version = "^0.17.2", features = ["bevy_reflect", "hdr", "ktx2", "png", "zstd", "zstd_rust"], default-features = true} -bevy_math = { version = "^0.17.2", features = ["std", "bevy_reflect", "rand", "alloc", "curve"], default-features = true} +bevy_math = { version = "^0.17.2", features = ["alloc", "bevy_reflect", "curve", "rand", "std"], default-features = true} bevy_mesh = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect = { version = "^0.17.2", features = ["auto_register_inventory", "std", "auto_register", "uuid", "debug", "smallvec", "glam", "smol_str", "debug_stack"], default-features = true} +bevy_reflect = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} bevy_render = { version = "^0.17.2", features = ["multi_threaded", "webgl"], default-features = true} bevy_shader = { version = "^0.17.2", features = [], default-features = true} -bevy_sprite = { version = "^0.17.2", features = ["bevy_sprite_picking_backend", "bevy_text", "bevy_picking", "bevy_window"], default-features = true} +bevy_sprite = { version = "^0.17.2", features = ["bevy_picking", "bevy_sprite_picking_backend", "bevy_text", "bevy_window"], default-features = true} bevy_sprite_render = { version = "^0.17.2", features = ["bevy_text", "webgl"], default-features = true} bevy_text = { version = "^0.17.2", features = ["default_font"], default-features = true} -bevy_transform = { version = "^0.17.2", features = ["bevy_log", "bevy-support", "alloc", "async_executor", "std", "bevy_reflect"], default-features = true} +bevy_transform = { version = "^0.17.2", features = ["alloc", "async_executor", "bevy-support", "bevy_log", "bevy_reflect", "std"], default-features = true} -bevy_ui = { version = "^0.17.2", features = ["bevy_ui_picking_backend", "bevy_picking"], default-features = true} +bevy_ui = { version = "^0.17.2", features = ["bevy_picking", "bevy_ui_picking_backend"], default-features = true} -bevy_utils = { version = "^0.17.2", features = ["parallel", "debug"], default-features = true} +bevy_utils = { version = "^0.17.2", features = ["debug", "parallel"], default-features = true} bytemuck = { version = "^1.5", features = [], default-features = true} From 42d87a0d9a41e8d2cf09e7873d183e60addeb51c Mon Sep 17 00:00:00 2001 From: makspll Date: Wed, 19 Nov 2025 21:43:38 +0000 Subject: [PATCH 21/22] improvements to codegen + xtask --- codegen/src/args.rs | 8 +- codegen/src/bin/main.rs | 2 +- codegen/src/callback.rs | 3 +- codegen/src/candidate.rs | 383 + codegen/src/context.rs | 47 +- codegen/src/import_path.rs | 17 +- codegen/src/lib.rs | 1 + codegen/src/passes/codegen.rs | 13 +- codegen/src/passes/crawl_paths.rs | 6 +- codegen/src/passes/find_methods_and_fields.rs | 625 +- codegen/src/passes/find_reflect_types.rs | 120 +- codegen/src/passes/find_trait_impls.rs | 5 +- codegen/src/passes/populate_template_data.rs | 74 +- codegen/templates/footer.tera | 7 - .../bevy_a11y_bms_bindings/src/lib.rs | 108 +- .../bevy_animation_bms_bindings/src/lib.rs | 208 +- .../bevy_asset_bms_bindings/src/lib.rs | 221 +- .../bevy_camera_bms_bindings/src/lib.rs | 1033 ++- .../bevy_color_bms_bindings/src/lib.rs | 796 +- .../src/lib.rs | 45 +- .../bindings/bevy_ecs_bms_bindings/src/lib.rs | 278 +- .../bevy_gizmos_bms_bindings/src/lib.rs | 246 +- .../bevy_gltf_bms_bindings/src/lib.rs | 138 +- .../bevy_image_bms_bindings/src/lib.rs | 193 +- .../bevy_input_bms_bindings/src/lib.rs | 890 +- .../bevy_input_focus_bms_bindings/src/lib.rs | 75 +- .../bevy_light_bms_bindings/src/lib.rs | 648 +- .../bevy_math_bms_bindings/src/lib.rs | 8105 +++++++++++------ .../bevy_mesh_bms_bindings/src/lib.rs | 1309 +-- .../bindings/bevy_pbr_bms_bindings/src/lib.rs | 949 +- .../bevy_picking_bms_bindings/src/lib.rs | 1425 +-- .../bevy_post_process_bms_bindings/src/lib.rs | 180 +- .../bevy_reflect_bms_bindings/Cargo.toml | 6 +- .../bevy_render_bms_bindings/src/lib.rs | 469 +- .../bevy_scene_bms_bindings/src/lib.rs | 54 +- .../bevy_sprite_bms_bindings/src/lib.rs | 478 +- .../src/lib.rs | 340 +- .../bevy_text_bms_bindings/src/lib.rs | 576 +- .../bevy_time_bms_bindings/src/lib.rs | 357 +- .../bevy_transform_bms_bindings/src/lib.rs | 518 +- .../bindings/bevy_ui_bms_bindings/src/lib.rs | 5014 +++++----- .../bevy_ui_render_bms_bindings/src/lib.rs | 53 +- makefile | 4 +- xtask/src/args.rs | 86 + xtask/src/codegen.rs | 147 + xtask/src/command.rs | 198 + xtask/src/features.rs | 293 + xtask/src/lib.rs | 12 +- xtask/src/main.rs | 826 +- 49 files changed, 15932 insertions(+), 11657 deletions(-) create mode 100644 codegen/src/candidate.rs create mode 100644 xtask/src/args.rs create mode 100644 xtask/src/codegen.rs create mode 100644 xtask/src/command.rs create mode 100644 xtask/src/features.rs diff --git a/codegen/src/args.rs b/codegen/src/args.rs index 361fed8eb4..815bcbf50f 100644 --- a/codegen/src/args.rs +++ b/codegen/src/args.rs @@ -27,6 +27,10 @@ use serde::{Deserialize, Serialize}; /// /// 5.Generates code using Tera templates given the data gathered from the analysis pub struct Args { + /// the output and artifact directory + #[arg(global = true, short, long, default_value = compute_default_dir(), value_name = "DIR")] + pub output: Utf8PathBuf, + #[command(subcommand)] pub cmd: Command, @@ -198,10 +202,6 @@ pub enum Command { ListTemplates, /// Crawls current workspace/crate and generates wrappers for Reflect types using templates Generate { - /// the output and artifact directory - #[arg(short, long, default_value = compute_default_dir(), value_name = "DIR")] - output: Utf8PathBuf, - /// The directory in which to look for templates, if unspecified will use built-in templates #[arg(short, long, value_name = "DIR")] templates: Option, diff --git a/codegen/src/bin/main.rs b/codegen/src/bin/main.rs index b952a6a276..2910caf82a 100644 --- a/codegen/src/bin/main.rs +++ b/codegen/src/bin/main.rs @@ -50,7 +50,7 @@ fn main() { .collect::>(); info!("Computing active features"); - let include_crates = if args.cmd.is_generate() { + let include_crates = if !args.cmd.is_collect() { let workspace = Workspace::from(&metadata); let mut graph = WorkspaceGraph::from(workspace); info!("Using workspace graph: \n{}", graph.to_dot()); diff --git a/codegen/src/callback.rs b/codegen/src/callback.rs index c98b01d36e..8bb951ce61 100644 --- a/codegen/src/callback.rs +++ b/codegen/src/callback.rs @@ -37,8 +37,8 @@ impl rustc_driver::Callbacks for BevyAnalyzerCallbacks { let mut meta_dirs = Vec::default(); let mut templates_dir = None; // add all relevant meta dirs to the context + meta_dirs.push(self.args.output.to_owned()); if let crate::Command::Generate { - output, meta, meta_output, templates, @@ -49,7 +49,6 @@ impl rustc_driver::Callbacks for BevyAnalyzerCallbacks { if let Some(meta_output) = meta_output { meta_dirs.push(meta_output.to_owned()) }; - meta_dirs.push(output.to_owned()); meta.iter() .flatten() .for_each(|m| meta_dirs.push(m.to_owned())); diff --git a/codegen/src/candidate.rs b/codegen/src/candidate.rs new file mode 100644 index 0000000000..68c2ca5d75 --- /dev/null +++ b/codegen/src/candidate.rs @@ -0,0 +1,383 @@ +use std::borrow::Cow; + +use indexmap::IndexMap; +use rustc_hir::def_id::DefId; +use rustc_middle::ty::{AdtDef, FieldDef, FnSig, TyCtxt, VariantDef, Visibility}; +use rustc_span::Symbol; + +use crate::ReflectionStrategy; + +#[derive(Debug)] +pub struct GenerationCandidate<'tcx, D> { + pub did: Option, + pub friendly_name: Option, + pub def: D, + pub variants: Vec>, + pub excluded_variants: Vec>, + pub trait_impls: IndexMap>, + pub notes: Vec, + pub functions: Vec>, + pub excluded_functions: Vec>, +} + +impl<'tcx, D> GenerationCandidate<'tcx, D> { + pub fn promote(self, def: AdtDef<'tcx>) -> GenerationCandidate<'tcx, AdtDef<'tcx>> { + GenerationCandidate { + def, + friendly_name: self.friendly_name, + did: Some(def.did()), + variants: self.variants, + notes: self.notes, + excluded_variants: self.excluded_variants, + trait_impls: self.trait_impls, + functions: self.functions, + excluded_functions: self.excluded_functions, + } + } +} + +impl Default for GenerationCandidate<'_, D> +where + D: Default, +{ + fn default() -> Self { + Self { + friendly_name: Default::default(), + def: Default::default(), + variants: Default::default(), + notes: Default::default(), + did: Default::default(), + excluded_variants: Default::default(), + trait_impls: Default::default(), + functions: Default::default(), + excluded_functions: Default::default(), + } + } +} + +#[derive(Debug)] +pub struct FunctionCandidate<'tcx> { + pub(crate) fn_name: Symbol, + pub(crate) sig: FnSig<'tcx>, + pub(crate) did: DefId, + pub(crate) visibility: Visibility, + pub(crate) has_self: bool, + pub(crate) is_unsafe: bool, + pub(crate) kind: FunctionCandidateKind, + pub(crate) notes: Vec, + pub(crate) arguments: Vec, + pub(crate) ret: FunctionArgCandidate, +} + +#[derive(Debug)] +pub enum FunctionCandidateKind { + TraitImplMethod { trait_did: DefId, impl_did: DefId }, + Method { impl_did: DefId }, +} + +impl FunctionCandidateKind { + pub fn impl_did(&self) -> DefId { + match self { + FunctionCandidateKind::TraitImplMethod { impl_did, .. } + | FunctionCandidateKind::Method { impl_did } => *impl_did, + } + } + + pub fn as_trait_fn(&self) -> Option<(DefId, DefId)> { + if let FunctionCandidateKind::TraitImplMethod { + trait_did, + impl_did, + } = self + { + Some((*trait_did, *impl_did)) + } else { + None + } + } +} + +#[derive(Debug)] +pub struct FunctionArgCandidate { + pub friendly_name: String, + pub reflection_strategy: ReflectionStrategy, + pub notes: Vec, +} + +impl FunctionArgCandidate { + pub fn new(friendly_name: String) -> Self { + Self { + friendly_name, + reflection_strategy: Default::default(), + notes: Default::default(), + } + } +} + +impl FunctionArgCandidate { + pub fn with_reflection_strategy(mut self, strategy: ReflectionStrategy) -> Self { + self.reflection_strategy = strategy; + self + } +} + +#[derive(Debug)] +pub struct VariantCandidate<'tcx> { + pub def: &'tcx VariantDef, + pub fields: Vec, + pub excluded_fields: Vec, + pub notes: Vec, +} + +impl<'tcx> VariantCandidate<'tcx> { + pub fn new(def: &'tcx VariantDef) -> Self { + Self { + def, + fields: Default::default(), + excluded_fields: Default::default(), + notes: Default::default(), + } + } +} +#[derive(Debug)] +pub struct FieldCandidate { + pub did: DefId, + pub name: Symbol, + // pub vis: Visibility, + // pub safety: Safety, + pub notes: Vec, + pub reflection_strategy: ReflectionStrategy, +} + +impl FieldCandidate { + pub fn new(def: &FieldDef) -> Self { + Self { + did: def.did, + name: def.name, + // vis: def.vis, + // safety: def.safety, + notes: Default::default(), + reflection_strategy: ReflectionStrategy::Filtered, + } + } + + pub fn with_reflection_strategy(mut self, strategy: ReflectionStrategy) -> Self { + self.reflection_strategy = strategy; + self + } +} + +#[derive(Debug, Clone)] +pub enum GenerationExclusionNote { + Reason(String), +} + +impl std::fmt::Display for GenerationExclusionNote { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("Excluded: ")?; + match self { + GenerationExclusionNote::Reason(reason) => f.write_str(reason.as_str())?, + } + Ok(()) + } +} + +pub trait Annotated { + fn with_note(self, note: GenerationExclusionNote) -> Self; + fn applying_notes(&self) -> impl Iterator; + fn friendly_name<'a, 'tcx>(&'a self, tcx: TyCtxt<'tcx>) -> Cow<'a, str> + where + 'tcx: 'a; +} + +impl Annotated for GenerationCandidate<'_, D> { + fn with_note(mut self, note: GenerationExclusionNote) -> Self { + self.notes.push(note); + self + } + + fn applying_notes(&self) -> impl Iterator { + self.notes + .iter() + .chain(self.variants.iter().flat_map(|v| v.applying_notes())) + .chain( + self.excluded_variants + .iter() + .flat_map(|v| v.applying_notes()), + ) + .chain(self.functions.iter().flat_map(|f| f.applying_notes())) + .chain( + self.excluded_functions + .iter() + .flat_map(|f| f.applying_notes()), + ) + } + fn friendly_name<'a, 'tcx>(&'a self, tcx: TyCtxt<'tcx>) -> Cow<'a, str> + where + 'tcx: 'a, + { + self.did + .map(|did| format!("{}::{}", tcx.crate_name(did.krate), tcx.item_name(did)).into()) + .unwrap_or(Cow::Borrowed("unknown")) + } +} + +impl Annotated for VariantCandidate<'_> { + fn with_note(mut self, note: GenerationExclusionNote) -> Self { + self.notes.push(note); + self + } + + fn applying_notes(&self) -> impl Iterator { + self.notes + .iter() + .chain(self.fields.iter().flat_map(|f| f.applying_notes())) + .chain(self.excluded_fields.iter().flat_map(|f| f.applying_notes())) + } + + fn friendly_name<'a, 'tcx>(&'a self, _tcx: TyCtxt<'tcx>) -> Cow<'a, str> + where + 'tcx: 'a, + { + self.def.name.as_str().into() + } +} + +impl Annotated for FieldCandidate { + fn with_note(mut self, note: GenerationExclusionNote) -> Self { + self.notes.push(note); + self + } + + fn applying_notes(&self) -> impl Iterator { + self.notes.iter() + } + + fn friendly_name<'a, 'tcx>(&'a self, _tcx: TyCtxt<'tcx>) -> Cow<'a, str> + where + 'tcx: 'a, + { + self.name.as_str().into() + } +} + +impl<'tcx> Annotated for FunctionCandidate<'tcx> { + fn with_note(mut self, note: GenerationExclusionNote) -> Self { + self.notes.push(note); + self + } + + fn applying_notes(&self) -> impl Iterator { + self.notes + .iter() + .chain(self.arguments.iter().flat_map(|a| a.applying_notes())) + .chain(self.ret.applying_notes()) + } + + fn friendly_name<'a, 'b>(&'a self, _tcx: TyCtxt<'b>) -> Cow<'a, str> + where + 'b: 'a, + { + self.fn_name.as_str().into() + } +} + +impl Annotated for FunctionArgCandidate { + fn with_note(mut self, note: GenerationExclusionNote) -> Self { + self.notes.push(note); + self + } + + fn applying_notes(&self) -> impl Iterator { + self.notes.iter() + } + + fn friendly_name<'a, 'tcx>(&'a self, _tcx: TyCtxt<'tcx>) -> Cow<'a, str> + where + 'tcx: 'a, + { + (&self.friendly_name).into() + } +} + +pub struct AnnotationContextCollector<'n, 'tcx> { + notes_with_context: Vec<(String, &'n GenerationExclusionNote)>, + ctxt: TyCtxt<'tcx>, +} + +impl<'n, 'tcx> AnnotationContextCollector<'n, 'tcx> { + pub fn new(ctxt: TyCtxt<'tcx>) -> Self { + Self { + notes_with_context: Default::default(), + ctxt, + } + } + + pub fn build(self) -> Vec<(String, &'n GenerationExclusionNote)> { + self.notes_with_context + } + + pub fn annotate(&mut self, candidate: &'n GenerationCandidate<'tcx, D>) { + let ctxt = candidate.friendly_name(self.ctxt); + + for note in &candidate.notes { + self.notes_with_context.push((ctxt.to_string(), note)) + } + + for variant in &candidate.excluded_variants { + self.annotate_variant(&ctxt, variant); + } + + for variant in &candidate.variants { + self.annotate_variant(&ctxt, variant); + } + + for function in &candidate.excluded_functions { + self.annotate_function(&ctxt, function); + } + } + + pub fn annotate_variant(&mut self, ctxt: &str, variant: &'n VariantCandidate<'tcx>) { + let ctxt = format!("{ctxt}::{}", variant.friendly_name(self.ctxt)); + + for note in &variant.notes { + self.notes_with_context.push((ctxt.to_string(), note)) + } + + for field in &variant.fields { + self.annotate_field(&ctxt, field) + } + + for field in &variant.excluded_fields { + self.annotate_field(&ctxt, field) + } + } + + pub fn annotate_field(&mut self, ctxt: &str, field: &'n FieldCandidate) { + let ctxt = format!("{ctxt}::{}", field.friendly_name(self.ctxt)); + for note in &field.notes { + self.notes_with_context.push((ctxt.to_string(), note)) + } + } + + fn annotate_function(&mut self, ctxt: &str, function: &'n FunctionCandidate<'tcx>) { + let ctxt = format!("{ctxt}::{}", function.friendly_name(self.ctxt)); + + for note in &function.notes { + self.notes_with_context.push((ctxt.to_string(), note)) + } + + for arg in &function.arguments { + self.annotate_arg(&ctxt, arg); + } + + self.annotate_arg(&ctxt, &function.ret) + } + + fn annotate_arg(&mut self, ctxt: &str, arg: &'n FunctionArgCandidate) { + let ctxt = format!("{ctxt}::{}", arg.friendly_name(self.ctxt)); + + for note in &arg.notes { + self.notes_with_context.push((ctxt.to_string(), note)) + } + } +} diff --git a/codegen/src/context.rs b/codegen/src/context.rs index 6120402b31..f8ef2b692e 100644 --- a/codegen/src/context.rs +++ b/codegen/src/context.rs @@ -8,12 +8,13 @@ use rustc_hir::def_id::DefId; use rustc_middle::ty::{AdtDef, TyCtxt}; use serde::Serialize; -use crate::{ImportPathFinder, MetaLoader, TemplateContext}; +use crate::{ImportPathFinder, MetaLoader, TemplateContext, candidate::GenerationCandidate}; pub(crate) struct BevyCtxt<'tcx> { pub(crate) tcx: TyCtxt<'tcx>, pub(crate) meta_loader: MetaLoader, - pub(crate) reflect_types: IndexMap>, + pub(crate) reflect_types: IndexMap>>, + pub(crate) excluded_reflect_types: Vec>>>, pub(crate) cached_traits: CachedTraits, pub(crate) path_finder: ImportPathFinder<'tcx>, pub(crate) workspace: WorkspaceGraph, @@ -35,6 +36,7 @@ impl<'tcx> BevyCtxt<'tcx> { Self { tcx, reflect_types: Default::default(), + excluded_reflect_types: Default::default(), cached_traits: Default::default(), meta_loader: MetaLoader::new(meta_dirs.to_vec(), workspace_meta), template_context: Default::default(), @@ -58,34 +60,6 @@ impl<'tcx> BevyCtxt<'tcx> { } } -#[derive(Clone, Default, Debug)] -pub(crate) struct ReflectType<'tcx> { - /// Map from traits to their implementations for the reflect type (from a selection) - pub(crate) trait_impls: Option>>, - /// Information about the ADT structure, fields, and variants - pub(crate) variant_data: Option>, - /// Functions passing criteria to be proxied - pub(crate) valid_functions: Option>, - - /// Mapping from fields to the reflection strategy - field_reflection_types: IndexMap, -} - -impl ReflectType<'_> { - pub(crate) fn set_field_reflection_strategies< - I: Iterator, - >( - &mut self, - field_strats: I, - ) { - self.field_reflection_types = field_strats.collect(); - } - - pub(crate) fn get_field_reflection_strat(&self, field: DefId) -> Option<&ReflectionStrategy> { - self.field_reflection_types.get(&field) - } -} - pub(crate) const DEF_PATHS_BMS_FROM_SCRIPT: [&str; 2] = ["bevy_mod_scripting_bindings::FromScript", "FromScript"]; pub(crate) const DEF_PATHS_BMS_INTO_SCRIPT: [&str; 2] = @@ -190,17 +164,7 @@ impl CachedTraits { // } } -#[derive(Clone, Debug)] -pub(crate) struct FunctionContext { - pub(crate) def_id: DefId, - pub(crate) has_self: bool, - pub(crate) is_unsafe: bool, - pub(crate) trait_and_impl_did: Option<(DefId, DefId)>, - /// strategies for input and output (last element is the output) - pub(crate) reflection_strategies: Vec, -} - -#[derive(PartialEq, Eq, Clone, Copy, Serialize, Debug)] +#[derive(PartialEq, Eq, Clone, Copy, Serialize, Debug, Default)] pub(crate) enum ReflectionStrategy { /// The will have a known wrapper we can use Proxy, @@ -209,5 +173,6 @@ pub(crate) enum ReflectionStrategy { /// Use a reflection primitive i.e. 'ReflectedValue', dynamic runtime reflection Reflection, /// Either ignored via 'reflect(ignore)' or not visible + #[default] Filtered, } diff --git a/codegen/src/import_path.rs b/codegen/src/import_path.rs index a4e05b23c5..b981d0e636 100644 --- a/codegen/src/import_path.rs +++ b/codegen/src/import_path.rs @@ -65,7 +65,11 @@ impl<'tcx> ImportPathFinder<'tcx> { self.crawl_module( crate_num.as_def_id(), &[ImportPathElement::Crate(crate_num)], - ) + ); + // sort by length of path, shortest wins + self.cache.iter_mut().for_each(|(_, paths)| { + paths.sort_by_key(|a| a.len()); + }); } fn crawl_module(&mut self, did: DefId, frontier: &[ImportPathElement]) { @@ -97,10 +101,11 @@ impl<'tcx> ImportPathFinder<'tcx> { // skip non local items, i.e. don't go crawling serde if !did.is_local() { trace!("Skipping non-local child {:?}", child.ident); - continue; + // continue; } - let rename = (child.ident != self.tcx.item_ident(did)).then_some(child.ident.as_str()); + let rename = (Some(child.ident.name) != self.tcx.opt_item_name(did)) + .then_some(child.ident.as_str()); self.crawl_item(did, frontier, rename); } @@ -175,7 +180,11 @@ impl<'tcx> ImportPathFinder<'tcx> { .iter() .map(|elem| match elem { ImportPathElement::Rename(_, name) => name.to_owned(), - ImportPathElement::Item(did) => self.tcx.item_name(*did).to_ident_string(), + ImportPathElement::Item(did) => self + .tcx + .opt_item_name(*did) + .expect("missing item name") + .to_ident_string(), ImportPathElement::Crate(crate_num) => { self.tcx.crate_name(*crate_num).to_ident_string() } diff --git a/codegen/src/lib.rs b/codegen/src/lib.rs index 0409702e73..de0271bbe6 100644 --- a/codegen/src/lib.rs +++ b/codegen/src/lib.rs @@ -17,6 +17,7 @@ extern crate rustc_trait_selection; mod args; mod callback; +mod candidate; mod context; mod import_path; mod meta; diff --git a/codegen/src/passes/codegen.rs b/codegen/src/passes/codegen.rs index 7584b2256a..4f3d2af650 100644 --- a/codegen/src/passes/codegen.rs +++ b/codegen/src/passes/codegen.rs @@ -11,24 +11,23 @@ use crate::{Args, BevyCtxt, TemplateKind, configure_tera}; /// generates a module with the appropriate wrappers for all the found reflection ADT's in the crate pub(crate) fn codegen(ctxt: &mut BevyCtxt<'_>, args: &Args) -> bool { - let (output, templates) = match &args.cmd { - crate::Command::Generate { - output, templates, .. - } => (output, templates), + let templates = match &args.cmd { + crate::Command::Generate { templates, .. } => templates, _ => return true, }; let tera = configure_tera(ctxt.tcx.crate_name(LOCAL_CRATE).as_str(), templates); // perform code gen using templates - fs::create_dir_all(output).unwrap(); - info!("Writing code files to : {output}"); + fs::create_dir_all(&args.output).unwrap(); + info!("Writing code files to : {}", args.output); let template_data = ctxt.template_context.as_ref().unwrap(); let mut context = Context::from_serialize(template_data).unwrap(); crate::extend_context_with_args(args.template_args.as_deref(), &mut context); // generate crate artifact - let mut file = File::create(output.join(format!("{}.rs", template_data.crate_name))).unwrap(); + let mut file = + File::create(args.output.join(format!("{}.rs", template_data.crate_name))).unwrap(); match tera.render_to( &TemplateKind::CrateArtifact.to_string(), diff --git a/codegen/src/passes/crawl_paths.rs b/codegen/src/passes/crawl_paths.rs index 64f44893e1..fd2a4cf8af 100644 --- a/codegen/src/passes/crawl_paths.rs +++ b/codegen/src/passes/crawl_paths.rs @@ -6,8 +6,8 @@ use crate::{Args, BevyCtxt}; pub(crate) fn crawl_paths(ctxt: &mut BevyCtxt<'_>, _args: &Args) -> bool { ctxt.path_finder.crawl_crate(LOCAL_CRATE); - // for c in ctxt.tcx.crates(()) { - // ctxt.path_finder.crawl_crate(*c); - // } + for c in ctxt.tcx.crates(()) { + ctxt.path_finder.crawl_crate(*c); + } true } diff --git a/codegen/src/passes/find_methods_and_fields.rs b/codegen/src/passes/find_methods_and_fields.rs index 6e92f62a87..a054ebb145 100644 --- a/codegen/src/passes/find_methods_and_fields.rs +++ b/codegen/src/passes/find_methods_and_fields.rs @@ -1,18 +1,24 @@ +use std::io::Write; + use indexmap::IndexMap; -use log::{info, trace}; +use itertools::Itertools; +use log::trace; use rustc_hir::{ - Safety, StableSince, + StableSince, def_id::{DefId, LOCAL_CRATE}, }; use rustc_infer::infer::TyCtxtInferExt; -use rustc_middle::ty::{ - AdtKind, AssocKind, FieldDef, FnSig, GenericArgs, Ty, TyCtxt, TyKind, TypingEnv, -}; +use rustc_middle::ty::{AdtDef, AssocKind, FnSig, GenericArgs, Ty, TyCtxt, TyKind, TypingEnv}; use rustc_span::Symbol; use rustc_trait_selection::infer::InferCtxtExt; use crate::{ - Args, BevyCtxt, CachedTraits, FunctionContext, MetaLoader, ReflectType, ReflectionStrategy, + Args, BevyCtxt, CachedTraits, MetaLoader, ReflectionStrategy, + candidate::{ + Annotated, AnnotationContextCollector, FieldCandidate, FunctionArgCandidate, + FunctionCandidate, FunctionCandidateKind, GenerationCandidate, GenerationExclusionNote, + VariantCandidate, + }, }; /// Finds all methods and fields which can be wrapped on a proxy, stores them in sorted order. @@ -22,291 +28,305 @@ pub(crate) fn find_methods_and_fields(ctxt: &mut BevyCtxt<'_>, args: &Args) -> b // go through all impls on the types (traits and non-traits) and pick signatures we're happy with // borrow checker fucky wucky - let reflect_types = ctxt.reflect_types.keys().cloned().collect::>(); - for def_id in reflect_types { - let adt_def = ctxt.tcx.adt_def(def_id); - - match adt_def.adt_kind() { - AdtKind::Enum => { - let strats = adt_def - .variants() - .iter() - .flat_map(|variant| { - if has_reflect_ignore_attr(ctxt.tcx.get_all_attrs(variant.def_id)) { - // TODO: is this the right approach? do we need to still include those variants? or do we just provide dummies - // or can we just skip those ? - info!( - "ignoring enum variant: {}::{} due to 'reflect(ignore)' attribute", - ctxt.tcx.item_name(def_id), - variant.name - ); - todo!(); - } - let param_env = TypingEnv::non_body_analysis(ctxt.tcx, variant.def_id); - process_fields( - ctxt.tcx, - &ctxt.meta_loader, - &ctxt.reflect_types, - &ctxt.cached_traits, - variant.fields.iter(), - param_env, - ) - }) - .collect::>(); - - strats.iter().for_each(|(f_did, strat)| match strat { - ReflectionStrategy::Reflection => report_field_not_supported( - ctxt.tcx, - *f_did, - def_id, - None, - "type is neither a proxy nor a type expressible as lua primitive", - ), - ReflectionStrategy::Filtered => report_field_not_supported( - ctxt.tcx, - *f_did, - def_id, - None, - "field has a 'reflect(ignore)' attribute", - ), - _ => {} - }); - - let ty_ctxt = ctxt.reflect_types.get_mut(&def_id).unwrap(); - ty_ctxt.variant_data = Some(adt_def); - ty_ctxt.set_field_reflection_strategies(strats.into_iter()); - } - AdtKind::Struct => { - let param_env = TypingEnv::non_body_analysis(ctxt.tcx, def_id); - let fields = process_fields( - ctxt.tcx, - &ctxt.meta_loader, - &ctxt.reflect_types, - &ctxt.cached_traits, - adt_def.all_fields(), - param_env, - ); - fields.iter().for_each(|(f_did, strat)| match strat { - ReflectionStrategy::Reflection => report_field_not_supported( - ctxt.tcx, - *f_did, - def_id, - None, - "type is neither a proxy nor a type expressible as lua primitive", - ), - ReflectionStrategy::Filtered => report_field_not_supported( - ctxt.tcx, - *f_did, - def_id, - None, - "field has a 'reflect(ignore)' attribute", - ), - _ => {} - }); - let ty_ctxt = ctxt.reflect_types.get_mut(&def_id).unwrap(); - assert!(ty_ctxt.variant_data.is_none(), "variant data already set!"); - ty_ctxt.variant_data = Some(adt_def); - ty_ctxt.set_field_reflection_strategies(fields.into_iter()); - } - t => panic!( - "Unexpected item type, all `Reflect` implementing items should be enums or structs. : {t:?}" - ), - }; + // let mut reflect_types = std::mem::take(&mut ctxt.reflect_types); + let all_def_ids = ctxt.reflect_types.keys().cloned().collect::>(); + for def_id in all_def_ids { + let (variants, excluded_variants) = generate_variants(ctxt, def_id); + + // filter the list of all methods and select candidates applicable to proxy generation + let mut all_impls = { + let trait_impls = &ctxt.reflect_types[&def_id].trait_impls; - // borrow checker fucky wucky pt2 - let trait_impls_for_ty = { - let ty_ctxt = ctxt.reflect_types.get(&def_id).unwrap(); - ty_ctxt.trait_impls.as_ref() - .expect("A type was not processed correctly in a previous pass, missing trait impl info") - .values() + ctxt.tcx + .inherent_impls(def_id) + .iter() + .chain(trait_impls.iter().flat_map(|(_, impl_did)| impl_did)) .cloned() .collect::>() }; - // should we not find functions set default value for future passes - let ty_ctxt = ctxt.reflect_types.get_mut(&def_id).unwrap(); - assert!( - ty_ctxt.valid_functions.is_none(), - "valid functions already set!" - ); - ty_ctxt.valid_functions = Some(Vec::default()); - - // filter the list of all methods and select candidates applicable to proxy generation - let mut all_impls = ctxt - .tcx - .inherent_impls(def_id) - .iter() - .chain(trait_impls_for_ty.iter().flatten()) - .collect::>(); - // sort them to avoid unnecessary diffs, we can use hashes here as they are forever stable (touch wood) - all_impls.sort_by_cached_key(|a| ctxt.tcx.def_path_hash(**a)); + all_impls.sort_by_cached_key(|a| ctxt.tcx.def_path_hash(*a)); for impl_did in all_impls { - let functions = ctxt + let (functions, excluded_functions) = generate_functions(ctxt, args, def_id, impl_did); + + let candidate = &mut ctxt.reflect_types[&def_id]; + candidate.functions.extend(functions); + candidate.excluded_functions.extend(excluded_functions); + } + let candidate = &mut ctxt.reflect_types[&def_id]; + candidate.variants.extend(variants); + candidate.excluded_variants.extend(excluded_variants); + } + + if args.cmd.is_list_types() { + let stdout = std::io::stdout(); + let mut handle = stdout.lock(); + + writeln!( + handle, + "included generation candidates in crate: {}", + ctxt.tcx.crate_name(LOCAL_CRATE) + ) + .unwrap(); + for (did, candidate) in ctxt.reflect_types.iter() { + writeln!(handle, "{:?}", ctxt.tcx.def_path_str(did)).unwrap(); + writeln!(handle, "Exclusions: ").unwrap(); + let mut annotator = AnnotationContextCollector::new(ctxt.tcx); + annotator.annotate(candidate); + let built = annotator.build(); + for (ctxt, annotation) in built { + writeln!(handle, "{ctxt} : {annotation}").unwrap(); + } + } + writeln!( + handle, + "excluded generation candidates in crate: {}", + ctxt.tcx.crate_name(LOCAL_CRATE) + ) + .unwrap(); + for candidate in ctxt.excluded_reflect_types.iter() { + if let Some(did) = candidate.did { + writeln!(handle, "{:?}", ctxt.tcx.def_path_str(did)).unwrap(); + } + writeln!(handle, "Exclusions: ").unwrap(); + let mut annotator = AnnotationContextCollector::new(ctxt.tcx); + annotator.annotate(candidate); + let built = annotator.build(); + for (ctxt, annotation) in built { + writeln!(handle, "{ctxt} : {annotation}").unwrap(); + } + } + return false; + } + + true +} + +fn generate_functions<'tcx>( + ctxt: &mut BevyCtxt<'tcx>, + args: &Args, + def_id: DefId, + impl_did: DefId, +) -> (Vec>, Vec>) { + let (functions, excluded_functions): (Vec<_>, Vec<_>) = ctxt + .tcx + .associated_items(impl_did) + .in_definition_order() + .filter_map(|assoc_item| { + if !matches!(assoc_item.kind, AssocKind::Fn { .. }) { + return None; + } + + let (fn_name, has_self) = match assoc_item.kind { + AssocKind::Fn { has_self, name } => (name, has_self), + _ => return None, + }; + + let trait_did = ctxt .tcx - .associated_items(impl_did) - .in_definition_order() - .filter_map(|assoc_item| { - if !matches!(assoc_item.kind, AssocKind::Fn { .. }) { - return None; - } + .impl_opt_trait_ref(impl_did) + .map(|tr| tr.skip_binder().def_id); + let param_env = TypingEnv::non_body_analysis(ctxt.tcx, def_id); + let fn_did = assoc_item.def_id; + let fn_sig = ctxt.tcx.fn_sig(fn_did).instantiate_identity(); + let sig: FnSig = ctxt + .tcx + .normalize_erasing_late_bound_regions(param_env, fn_sig); + Some(FunctionCandidate { + fn_name, + did: fn_did, + visibility: assoc_item.visibility(ctxt.tcx), + sig, + has_self, + is_unsafe: sig.safety.is_unsafe(), + kind: trait_did + .map(|trait_did| FunctionCandidateKind::TraitImplMethod {trait_did,impl_did}) + .unwrap_or(FunctionCandidateKind::Method { impl_did }), + notes: vec![], + arguments: vec![], + ret: FunctionArgCandidate::new(String::from("Return value")), + }) + }) + .map(|mut fn_candidate| { - let (fn_name, has_self) = match assoc_item.kind { - AssocKind::Fn { has_self, name } => (name, has_self), - _ => return None, - }; - - let trait_did = ctxt - .tcx - .impl_opt_trait_ref(*impl_did) - .map(|tr| tr.skip_binder().def_id); - let trait_name = trait_did - .map(|td| ctxt.tcx.item_name(td).to_ident_string()) - .unwrap_or_else(|| "None".to_string()); - - let fn_name = fn_name.to_ident_string(); - let fn_did = assoc_item.def_id; - - trace!( - "Processing function: '{fn_name}' on type: `{}` on trait: `{trait_name}`", - ctxt.tcx.item_name(def_id) - ); - - let param_env = TypingEnv::non_body_analysis(ctxt.tcx, def_id); - let fn_sig = ctxt.tcx.fn_sig(fn_did).instantiate_identity(); - let sig: FnSig = ctxt - .tcx - .normalize_erasing_late_bound_regions(param_env, fn_sig); - - let function_generics = get_function_generics(ctxt.tcx, fn_did, *impl_did); - - if !function_generics.is_empty() { - log::debug!( - "Skipping function: `{}` on type: `{}` as it has generics: {:?}", - fn_name, - ctxt.tcx.item_name(def_id), - function_generics - ); - return None; - } + if !fn_candidate.visibility.is_public() { + return Err(fn_candidate.with_note(GenerationExclusionNote::Reason(String::from("function is not public")))) + } - let is_stable_for_target = ctxt - .tcx - .lookup_stability(fn_did) - .map(|stability| match stability.stable_since() { - Some(StableSince::Version(rustc_version)) => { - !args.rustc_version_is_greater_than_mrsv_target(rustc_version) - } - _ => false, - }) - .unwrap_or(true); - - if !is_stable_for_target { - log::debug!( - "Skipping unstable function: `{}` on type: `{}`, msrv target: {:?}", - ctxt.tcx.item_name(fn_did), - ctxt.tcx.item_name(def_id), - args.mrsv_target() - ); - return None; - }; - - let is_unsafe = sig.safety == Safety::Unsafe; - - if is_unsafe { - log::debug!( - "Skipping unsafe function: `{}` on type: `{}`", - ctxt.tcx.item_name(fn_did), - ctxt.tcx.item_name(def_id), - ); - return None; - } + let function_generics = + get_function_generics(ctxt.tcx, fn_candidate.did, fn_candidate.kind.impl_did()); - if trait_did.is_none() && !ctxt.tcx.visibility(fn_did).is_public() { - log::info!( - "Skipping non-public function: `{}` on type: `{}`", - fn_name, - ctxt.tcx.item_name(def_id) - ); - return None; - } + if !function_generics.is_empty() { + return Err(fn_candidate.with_note(GenerationExclusionNote::Reason(format!( + "function has generics: {function_generics:?}" + )))); + } - let arg_names = ctxt.tcx.fn_arg_idents(fn_did); - - let mut reflection_strategies = Vec::with_capacity(sig.inputs().len()); - for (idx, arg_ty) in sig.inputs().iter().enumerate() { - if type_is_supported_as_non_proxy_arg( - ctxt.tcx, - param_env, - &ctxt.cached_traits, - *arg_ty, - ) { - reflection_strategies.push(ReflectionStrategy::Primitive); - } else if type_is_supported_as_proxy_arg( - ctxt.tcx, - &ctxt.reflect_types, - &ctxt.meta_loader, - *arg_ty, - ) { - reflection_strategies.push(ReflectionStrategy::Proxy); - } else { - report_fn_arg_not_supported( - ctxt.tcx, - fn_did, - def_id, - *arg_ty, - &format!( - "argument \"{:?}\" at idx {idx} not supported", - arg_names[idx] - ), - ); - return None; - } + let stability = ctxt.tcx.lookup_stability(fn_candidate.did); + let is_stable_for_target = stability + .map(|stability| match stability.stable_since() { + Some(StableSince::Version(rustc_version)) => { + !args.rustc_version_is_greater_than_mrsv_target(rustc_version) } + _ => false, + }) + .unwrap_or(true); + + if !is_stable_for_target { + return Err(fn_candidate.with_note(GenerationExclusionNote::Reason(format!( + "function is not stable for the target: {:?} or unstable. Item stability: {stability:?}", + args.mrsv_target() + )))); + } + + if fn_candidate.is_unsafe { + + return Err(fn_candidate.with_note(GenerationExclusionNote::Reason("Function is unsafe".to_string()))) + } + + if matches!(fn_candidate.kind, FunctionCandidateKind::TraitImplMethod { .. }) && !ctxt.tcx.visibility(fn_candidate.did).is_public() { + return Err(fn_candidate.with_note(GenerationExclusionNote::Reason("Function is not public and does not come from a trait impl".to_string()))); + } - if type_is_supported_as_non_proxy_return_val( + let param_env = TypingEnv::non_body_analysis(ctxt.tcx, def_id); + + let arg_names = ctxt.tcx.fn_arg_idents(fn_candidate.did); + fn_candidate.arguments = fn_candidate.sig.inputs().iter().zip(arg_names).enumerate().map(|(index, (arg_ty, ident))| { + let candidate_input = FunctionArgCandidate::new(ident.map(|id| id.to_string()).unwrap_or(index.to_string())); + if type_is_supported_as_non_proxy_arg( + ctxt.tcx, + param_env, + &ctxt.cached_traits, + *arg_ty, + ) { + candidate_input.with_reflection_strategy(ReflectionStrategy::Primitive) + } else if type_is_supported_as_proxy_arg( + ctxt.tcx, + &ctxt.reflect_types, + &ctxt.meta_loader, + *arg_ty, + ) { + candidate_input.with_reflection_strategy(ReflectionStrategy::Proxy) + } else { + candidate_input.with_note(GenerationExclusionNote::Reason("argument is neither a primitive type implementing FromScript or a reflectable type".to_string())) + } + }).collect::>(); + + if type_is_supported_as_non_proxy_return_val( + ctxt.tcx, + param_env, + &ctxt.cached_traits, + fn_candidate.sig.output(), + ) { + fn_candidate.ret = fn_candidate.ret.with_reflection_strategy(ReflectionStrategy::Primitive); + } else if type_is_supported_as_proxy_return_val( + ctxt.tcx, + &ctxt.reflect_types, + &ctxt.meta_loader, + fn_candidate.sig.output(), + ) { + fn_candidate.ret = fn_candidate.ret.with_reflection_strategy(ReflectionStrategy::Proxy); + } else { + fn_candidate.ret = fn_candidate.ret.with_note(GenerationExclusionNote::Reason("return type is neither a primitive type implementing IntoScript, or a reflectable type, or is a reference".to_string())) + } + + if fn_candidate.applying_notes().next().is_some() { + // notes inside will suffice here + return Err(fn_candidate); + } + + Ok(fn_candidate) + }) + .partition_result(); + (functions, excluded_functions) +} + +fn generate_variants<'tcx>( + ctxt: &mut BevyCtxt<'tcx>, + did: DefId, +) -> (Vec>, Vec>) { + let candidate = &ctxt.reflect_types[&did]; + let (mut variants, excluded_variants): (Vec<_>, Vec<_>) = candidate + .def + .variants() + .iter() + .map(|variant| { + let variant_candidate = VariantCandidate::new(variant); + if has_reflect_ignore_attr(ctxt.tcx.get_all_attrs(variant.def_id)) { + return Err(variant_candidate.with_note(GenerationExclusionNote::Reason( + "variant has 'reflect(ignore)' attribute".to_string(), + ))); + } + + Ok(variant_candidate) + }) + .partition_result(); + + for variant in &mut variants { + let param_env = TypingEnv::non_body_analysis(ctxt.tcx, variant.def.def_id); + + let (fields, excluded_fields): (Vec<_>, Vec<_>) = variant + .def + .fields + .iter() + .map(|field| { + let candidate = FieldCandidate::new(field); + let visibility = field.vis; + if !visibility.is_public() { + return Err(candidate.with_note(GenerationExclusionNote::Reason(format!( + "field is not public {:?}", + field.did + )))); + } + + if has_reflect_ignore_attr(ctxt.tcx.get_all_attrs(field.did)) { + return Err(candidate.with_note(GenerationExclusionNote::Reason( + "field has 'reflect(ignore)' attribute".to_string(), + ))); + } + + let field_ty = ctxt.tcx.erase_and_anonymize_regions( + ctxt.tcx.type_of(field.did).instantiate_identity(), + ); + + Ok( + if type_is_supported_as_non_proxy_arg( ctxt.tcx, param_env, &ctxt.cached_traits, - sig.output(), + field_ty, + ) && type_is_supported_as_non_proxy_return_val( + ctxt.tcx, + param_env, + &ctxt.cached_traits, + field_ty, ) { - reflection_strategies.push(ReflectionStrategy::Primitive); - } else if type_is_supported_as_proxy_return_val( + candidate.with_reflection_strategy(ReflectionStrategy::Primitive) + } else if type_is_supported_as_proxy_arg( + ctxt.tcx, + &ctxt.reflect_types, + &ctxt.meta_loader, + field_ty, + ) && type_is_supported_as_proxy_return_val( ctxt.tcx, &ctxt.reflect_types, &ctxt.meta_loader, - sig.output(), + field_ty, ) { - reflection_strategies.push(ReflectionStrategy::Proxy); + candidate.with_reflection_strategy(ReflectionStrategy::Proxy) } else { - report_fn_arg_not_supported( - ctxt.tcx, - fn_did, - def_id, - sig.output(), - "return value not supported", - ); - return None; - } - - Some(FunctionContext { - is_unsafe, - def_id: fn_did, - has_self, - trait_and_impl_did: trait_did.map(|td| (td, *impl_did)), - reflection_strategies, - }) - }) - .collect::>(); + candidate.with_reflection_strategy(ReflectionStrategy::Reflection) + }, + ) + }) + .partition_result(); - let ty_ctxt = ctxt.reflect_types.get_mut(&def_id).unwrap(); - // must exist since we set default above - ty_ctxt.valid_functions.as_mut().unwrap().extend(functions); - } + variant.fields.extend(fields); + variant.excluded_fields.extend(excluded_fields); } - - true + (variants, excluded_variants) } fn get_function_generics(tcx: TyCtxt, fn_did: DefId, impl_did: DefId) -> Vec { @@ -326,75 +346,6 @@ fn get_function_generics(tcx: TyCtxt, fn_did: DefId, impl_did: DefId) -> Vec .collect::>() } -fn report_fn_arg_not_supported(tcx: TyCtxt, f_did: DefId, type_did: DefId, ty: Ty, reason: &str) { - info!( - "Ignoring function: `{}` on type: `{}` reason: `{}`, relevant type: `{}`", - tcx.item_name(f_did), - tcx.item_name(type_did), - reason, - ty - ); -} - -fn report_field_not_supported( - tcx: TyCtxt, - f_did: DefId, - type_did: DefId, - variant_did: Option, - reason: &'static str, -) { - let param_env = TypingEnv::non_body_analysis(tcx, type_did); - let normalised_ty = - tcx.normalize_erasing_regions(param_env, tcx.type_of(f_did).instantiate_identity()); - info!( - "Ignoring field: `{}:{}` on type: `{}` in variant: `{}` as it is not supported: `{}`", - tcx.item_name(f_did), - normalised_ty, - tcx.item_name(type_did), - tcx.item_name(variant_did.unwrap_or(type_did)), - reason - ); -} - -/// Checks each field individually and returns reflection strategies -fn process_fields<'tcx, 'f, I: Iterator>( - tcx: TyCtxt<'tcx>, - meta_loader: &MetaLoader, - reflect_types: &IndexMap>, - cached_traits: &CachedTraits, - fields: I, - param_env: TypingEnv<'tcx>, -) -> Vec<(DefId, ReflectionStrategy)> { - fields - .map(move |f| { - if !f.vis.is_public() { - return (f.did, crate::ReflectionStrategy::Filtered); - } - - let field_ty = - tcx.erase_and_anonymize_regions(tcx.type_of(f.did).instantiate_identity()); - if type_is_supported_as_non_proxy_arg(tcx, param_env, cached_traits, field_ty) - && type_is_supported_as_non_proxy_return_val( - tcx, - param_env, - cached_traits, - field_ty, - ) - { - (f.did, crate::ReflectionStrategy::Primitive) - } else if type_is_supported_as_proxy_arg(tcx, reflect_types, meta_loader, field_ty) - && type_is_supported_as_proxy_return_val(tcx, reflect_types, meta_loader, field_ty) - { - (f.did, crate::ReflectionStrategy::Proxy) - } else if !has_reflect_ignore_attr(tcx.get_all_attrs(f.did)) { - (f.did, crate::ReflectionStrategy::Reflection) - } else { - (f.did, crate::ReflectionStrategy::Filtered) - } - }) - .collect::>() -} - /// Checks if the given attributes contain among them a reflect ignore attribute fn has_reflect_ignore_attr(attrs: &[rustc_hir::Attribute]) -> bool { attrs.iter().any(|a| { @@ -408,7 +359,7 @@ fn has_reflect_ignore_attr(attrs: &[rustc_hir::Attribute]) -> bool { /// Returns true if this type can be used in argument position by checking if it's a top level proxy arg fn type_is_supported_as_proxy_arg<'tcx>( tcx: TyCtxt<'tcx>, - reflect_types: &IndexMap>, + reflect_types: &IndexMap>>, meta_loader: &MetaLoader, ty: Ty, ) -> bool { @@ -428,7 +379,7 @@ fn peel_refs_up_to_once(ty: Ty) -> Ty { /// Returns true if this type can be used in return position by checking if it's a top level proxy arg without references fn type_is_supported_as_proxy_return_val<'tcx>( tcx: TyCtxt<'tcx>, - reflect_types: &IndexMap>, + reflect_types: &IndexMap>>, meta_loader: &MetaLoader, ty: Ty, ) -> bool { @@ -439,7 +390,7 @@ fn type_is_supported_as_proxy_return_val<'tcx>( /// Check if the type is an ADT and is reflectable (i.e. a proxy is being generated for it in SOME crate that we know about from the meta files) fn type_is_adt_and_reflectable<'tcx>( tcx: TyCtxt<'tcx>, - reflect_types: &IndexMap>, + reflect_types: &IndexMap>>, meta_loader: &MetaLoader, ty: Ty, ) -> bool { diff --git a/codegen/src/passes/find_reflect_types.rs b/codegen/src/passes/find_reflect_types.rs index 8355dea34b..157c43a3ab 100644 --- a/codegen/src/passes/find_reflect_types.rs +++ b/codegen/src/passes/find_reflect_types.rs @@ -1,13 +1,18 @@ -use log::{debug, info}; +use itertools::Itertools; use rustc_hir::def_id::LOCAL_CRATE; +use rustc_middle::ty::AdtDef; -use crate::{Args, BevyCtxt, DEF_PATHS_REFLECT, ReflectType}; +use crate::{ + Args, BevyCtxt, DEF_PATHS_REFLECT, + candidate::{Annotated, GenerationCandidate, GenerationExclusionNote}, +}; /// Finds all reflect types which we can wrap in the crate as well as sorts the final list. pub(crate) fn find_reflect_types(ctxt: &mut BevyCtxt<'_>, args: &Args) -> bool { let tcx = &ctxt.tcx; let ignored_types = match &args.cmd { crate::Command::Generate { ignored_types, .. } => ignored_types, + crate::Command::ListTypes => &vec![], _ => return true, }; @@ -21,12 +26,6 @@ pub(crate) fn find_reflect_types(ctxt: &mut BevyCtxt<'_>, args: &Args) -> bool { continue; } - debug!( - "Found Reflect impls in crate: {}, with path: {}", - tcx.crate_name(LOCAL_CRATE), - def_path_str - ); - // this returns non-local impls as well let reflect_trait_impls = tcx.trait_impls_of(trait_did); @@ -34,48 +33,93 @@ pub(crate) fn find_reflect_types(ctxt: &mut BevyCtxt<'_>, args: &Args) -> bool { // non blanket impls may also contain generics but those will be contained within another type i.e. `impl Default for Vec` // ignore anything with a generic, so blanket_impls are out for now // we also make sure to only work over types and impls directly in the local crate - let reflect_adts_did = reflect_trait_impls + let (reflect_adts_did, excluded_candidates): (Vec<_>, Vec<_>) = reflect_trait_impls .non_blanket_impls() .iter() .flat_map(|(self_ty, impl_dids)| impl_dids.iter().zip(std::iter::repeat(self_ty))) - .filter_map(|(impl_did, self_ty)| { + .map(|(impl_did, self_ty)| { + let mut early_candidate = GenerationCandidate::>::default(); + + let did = match self_ty.def() { + Some(ty) => ty, + None => { + return Err(early_candidate.with_note(GenerationExclusionNote::Reason( + format!("impl block {impl_did:?}, has no self type"), + ))); + } + }; + + early_candidate.did = Some(did); + + if !impl_did.is_local() { + return Err(early_candidate.with_note(GenerationExclusionNote::Reason( + format!("impl block {impl_did:?}, is not local"), + ))); + } + let generics = tcx.generics_of(*impl_did); - (impl_did.is_local() && + if generics.count() > 0 { + return Err(early_candidate.with_note(GenerationExclusionNote::Reason( + format!("impl block {impl_did:?}, has generics"), + ))); + } + // only non parametrized simple types are allowed, i.e. "MyStruct" is allowed but "MyStruct" isn't - generics.count() == 0 && - self_ty.def().is_some_and(|did| { - let short_form = format!("{}::{}",ctxt.tcx.crate_name(LOCAL_CRATE),ctxt.tcx.item_name(did)); - if ignored_types.contains(&short_form) || ignored_types.contains(&tcx.def_path_str(did)) { info!("Ignoring type: {:?}", tcx.def_path_str(did)); - return false; - }; - let adt_generics = tcx.generics_of(did); - tcx.visibility(did).is_public() && adt_generics.count() == 0 - })) - .then(|| self_ty.def().unwrap()) - }) - .filter(|t| { - if ctxt.path_finder.find_import_paths_no_fallback(*t).is_none() { - debug!("Skipping type: {t:?}, as it has no public path available"); - false - } else { - true + let short_form = format!( + "{}::{}", + ctxt.tcx.crate_name(LOCAL_CRATE), + ctxt.tcx.item_name(did) + ); + + if ignored_types.contains(&short_form) + || ignored_types.contains(&tcx.def_path_str(did)) + { + return Err(early_candidate.with_note(GenerationExclusionNote::Reason( + format!("type {short_form} explicitly excluded by user"), + ))); + }; + + let adt_generics = tcx.generics_of(did); + + if adt_generics.count() > 0 { + return Err(early_candidate.with_note(GenerationExclusionNote::Reason( + format!("type has generics: {adt_generics:?}"), + ))); } - }) - .inspect(|impl_| debug!("On type: {:?}", tcx.item_name(*impl_))) - .map(|did| (did, ReflectType::default())); - ctxt.reflect_types.extend(reflect_adts_did); + let visibility = tcx.visibility(did); + if !visibility.is_public() { + return Err(early_candidate.with_note(GenerationExclusionNote::Reason( + format!("type has non-public visibility: {visibility:?}"), + ))); + } + + if ctxt + .path_finder + .find_import_paths_no_fallback(did) + .is_none() + && did.is_local() + { + return Err(early_candidate.with_note(GenerationExclusionNote::Reason( + "type is local and has no public import paths".to_string(), + ))); + } + + let adt = ctxt.tcx.adt_def(did); + + Ok(early_candidate.promote(adt)) + }) + .partition_result(); + ctxt.reflect_types + .extend(reflect_adts_did.into_iter().map(|a| (a.def.did(), a))); + ctxt.excluded_reflect_types.extend(excluded_candidates); } ctxt.reflect_types .sort_by_cached_key(|did, _| tcx.item_name(*did)); - if args.cmd.is_list_types() { - for did in ctxt.reflect_types.keys() { - println!("{:?}", tcx.def_path_str(did)); - } - return false; - } + log::info!("Found: {} types", ctxt.reflect_types.len()); + log::info!("Excluded: {} types", ctxt.excluded_reflect_types.len()); true } diff --git a/codegen/src/passes/find_trait_impls.rs b/codegen/src/passes/find_trait_impls.rs index ffaaa80bab..cb1e220daf 100644 --- a/codegen/src/passes/find_trait_impls.rs +++ b/codegen/src/passes/find_trait_impls.rs @@ -1,5 +1,3 @@ -use std::collections::HashMap; - use log::trace; use rustc_hir::def_id::DefId; use rustc_infer::{ @@ -79,8 +77,7 @@ pub(crate) fn find_trait_impls(ctxt: &mut BevyCtxt<'_>, _args: &Args) -> bool { } } - assert!(type_ctxt.trait_impls.is_none(), "trait impls already set!"); - type_ctxt.trait_impls = Some(HashMap::from_iter(impls)); + type_ctxt.trait_impls.extend(impls); } true } diff --git a/codegen/src/passes/populate_template_data.rs b/codegen/src/passes/populate_template_data.rs index f47847d2cf..3c81a01f48 100644 --- a/codegen/src/passes/populate_template_data.rs +++ b/codegen/src/passes/populate_template_data.rs @@ -2,14 +2,12 @@ use std::{borrow::Cow, convert::identity, panic}; use log::{trace, warn}; use rustc_hir::def_id::{DefId, LOCAL_CRATE}; -use rustc_middle::ty::{ - AdtDef, FieldDef, GenericArg, GenericParamDefKind, TraitRef, Ty, TyKind, TypingEnv, -}; +use rustc_middle::ty::{AdtDef, GenericArg, GenericParamDefKind, TraitRef, Ty, TyKind, TypingEnv}; use rustc_span::Symbol; use crate::{ - Arg, Args, BevyCtxt, Field, Function, FunctionContext, Item, Output, ReflectType, - TemplateContext, Variant, + Arg, Args, BevyCtxt, Field, Function, Item, Output, TemplateContext, Variant, + candidate::{FunctionCandidate, VariantCandidate}, }; /// Converts the BevyCtxt into simpler data that can be used in templates directly, /// Clears the BevyCtxt by clearing data structures after it uses them. @@ -23,11 +21,7 @@ pub(crate) fn populate_template_data(ctxt: &mut BevyCtxt<'_>, args: &Args) -> bo let display_diagnostic = tcx.get_diagnostic_item(Symbol::intern("Display")).unwrap(); for (reflect_ty_did, ty_ctxt) in ctxt.reflect_types.drain(..).collect::>().into_iter() { - let fn_ctxts = ty_ctxt - .valid_functions - .as_ref() - .expect("Missing function context for a type, were all the passes run correctly?"); - + let fn_ctxts = &ty_ctxt.functions; let has_static_methods = fn_ctxts.iter().any(|fn_ctxt| !fn_ctxt.has_self); let mut functions = process_functions(ctxt, fn_ctxts); @@ -45,24 +39,25 @@ pub(crate) fn populate_template_data(ctxt: &mut BevyCtxt<'_>, args: &Args) -> bo ) }); - let variant = ty_ctxt.variant_data.as_ref().unwrap(); + let def = &ty_ctxt.def; - let is_tuple_struct = variant.is_struct() - && variant + let is_tuple_struct = def.is_struct() + && def .all_fields() .next() .is_some_and(|f| f.name.as_str().chars().all(|c| c.is_numeric())); - let variants = variant - .variants() + let variants = ty_ctxt + .variants .iter() .map(|variant| Variant { - docstrings: docstrings(ctxt.tcx.get_all_attrs(variant.def_id)), - name: variant.name.to_ident_string().into(), - fields: process_fields(ctxt, variant.fields.iter(), &ty_ctxt), + docstrings: docstrings(ctxt.tcx.get_all_attrs(variant.def.def_id)), + name: variant.def.name.to_ident_string().into(), + fields: process_fields(ctxt, variant), }) .collect::>(); - let trait_impls = ty_ctxt.trait_impls.as_ref().unwrap(); + + let trait_impls = ty_ctxt.trait_impls; let item = Item { ident: tcx.item_name(reflect_ty_did).to_ident_string(), import_path: import_path(ctxt, reflect_ty_did), @@ -103,68 +98,69 @@ pub(crate) fn populate_template_data(ctxt: &mut BevyCtxt<'_>, args: &Args) -> bo true } -pub(crate) fn process_fields<'f, I: Iterator>( - ctxt: &BevyCtxt, - fields: I, - ty_ctxt: &ReflectType, +pub(crate) fn process_fields<'ctx>( + ctxt: &BevyCtxt<'ctx>, + variant: &VariantCandidate<'ctx>, ) -> Vec { - fields + variant + .fields + .iter() .map(|field| Field { docstrings: docstrings(ctxt.tcx.get_all_attrs(field.did)), ident: field.name.to_ident_string(), ty: ty_to_string(ctxt, ctxt.tcx.type_of(field.did).skip_binder(), false), - reflection_strategy: *ty_ctxt - .get_field_reflection_strat(field.did) - .unwrap_or_else(|| panic!("{ty_ctxt:#?}")), + reflection_strategy: field.reflection_strategy, }) .collect() } -pub(crate) fn process_functions(ctxt: &BevyCtxt, fns: &[FunctionContext]) -> Vec { +pub(crate) fn process_functions<'tcx>( + ctxt: &BevyCtxt<'tcx>, + fns: &[FunctionCandidate<'tcx>], +) -> Vec { fns.iter() .map(|fn_ctxt| { - let fn_sig = ctxt.tcx.fn_sig(fn_ctxt.def_id).skip_binder().skip_binder(); let args = ctxt .tcx - .fn_arg_idents(fn_ctxt.def_id) + .fn_arg_idents(fn_ctxt.did) .iter() - .zip(fn_sig.inputs()) + .zip(fn_ctxt.sig.inputs()) .enumerate() .map(|(idx, (ident, ty))| { let normalized_ty = ctxt.tcx.normalize_erasing_regions( - TypingEnv::non_body_analysis(ctxt.tcx, fn_ctxt.def_id), + TypingEnv::non_body_analysis(ctxt.tcx, fn_ctxt.did), *ty, ); Arg { ident: ident.map(|s| s.to_string()).unwrap_or(format!("arg_{idx}")), ty: ty_to_string(ctxt, normalized_ty, false), proxy_ty: ty_to_string(ctxt, normalized_ty, true), - reflection_strategy: fn_ctxt.reflection_strategies[idx], + reflection_strategy: fn_ctxt.arguments[idx].reflection_strategy, } }) .collect(); let out_ty = ctxt.tcx.normalize_erasing_regions( - TypingEnv::non_body_analysis(ctxt.tcx, fn_ctxt.def_id), - fn_sig.output(), + TypingEnv::non_body_analysis(ctxt.tcx, fn_ctxt.did), + fn_ctxt.sig.output(), ); let output = Output { ty: ty_to_string(ctxt, out_ty, false), proxy_ty: ty_to_string(ctxt, out_ty, true), - reflection_strategy: *fn_ctxt.reflection_strategies.last().unwrap(), + reflection_strategy: fn_ctxt.ret.reflection_strategy, }; let is_unsafe = fn_ctxt.is_unsafe; Function { is_unsafe, - ident: ctxt.tcx.item_name(fn_ctxt.def_id).to_ident_string(), + ident: ctxt.tcx.item_name(fn_ctxt.did).to_ident_string(), args, output, has_self: fn_ctxt.has_self, - docstrings: docstrings(ctxt.tcx.get_all_attrs(fn_ctxt.def_id)), - from_trait_path: fn_ctxt.trait_and_impl_did.map(|(_, impl_did)| { + docstrings: docstrings(ctxt.tcx.get_all_attrs(fn_ctxt.did)), + from_trait_path: fn_ctxt.kind.as_trait_fn().map(|(_, impl_did)| { let trait_ref = ctxt.tcx.impl_trait_ref(impl_did).skip_binder(); trait_ref_to_string(ctxt, trait_ref) diff --git a/codegen/templates/footer.tera b/codegen/templates/footer.tera index 7992020867..82e2c1544c 100644 --- a/codegen/templates/footer.tera +++ b/codegen/templates/footer.tera @@ -1,10 +1,3 @@ -{% if args.self_is_bms_lua %} -{% set bms_lua_path="crate" %} -{% else %} -{% set bms_lua_path="bevy_mod_scripting::lua"%} -{% endif %} - - pub struct {{ "ScriptingPlugin" | prefix_cratename | convert_case(case="upper_camel")}}; {% for item in items %} diff --git a/crates/bindings/bevy_a11y_bms_bindings/src/lib.rs b/crates/bindings/bevy_a11y_bms_bindings/src/lib.rs index f041856a82..7b7f72cd41 100644 --- a/crates/bindings/bevy_a11y_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_a11y_bms_bindings/src/lib.rs @@ -1,15 +1,18 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyA11YScriptingPlugin; pub(crate) fn register_accessibility_requested_functions(world: &mut World) { @@ -80,53 +83,58 @@ pub(crate) fn register_manage_accessibility_updates_functions(world: &mut World) bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_a11y::ManageAccessibilityUpdates, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_a11y::ManageAccessibilityUpdates>| { - let output: Val<::bevy_a11y::ManageAccessibilityUpdates> = { - { - let output: Val<::bevy_a11y::ManageAccessibilityUpdates> = - <::bevy_a11y::ManageAccessibilityUpdates as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "get", - |_self: Ref<::bevy_a11y::ManageAccessibilityUpdates>| { - let output: bool = { - { - let output: bool = ::bevy_a11y::ManageAccessibilityUpdates::get(&_self).into(); - output - } - }; - output - }, - " Returns `true` if Bevy's ECS should update the accessibility tree.", - &["_self"], - ) - .register_documented( - "set", - |mut _self: Mut<::bevy_a11y::ManageAccessibilityUpdates>, value: bool| { - let output: () = { - { - let output: () = - ::bevy_a11y::ManageAccessibilityUpdates::set(&mut _self, value).into(); - output - } - }; - output - }, - " Sets whether Bevy's ECS should update the accessibility tree.", - &["_self", "value"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_a11y::ManageAccessibilityUpdates>| { + let output: Val<::bevy_a11y::ManageAccessibilityUpdates> = { + { + let output: Val<::bevy_a11y::ManageAccessibilityUpdates> = <::bevy_a11y::ManageAccessibilityUpdates as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "get", + |_self: Ref<::bevy_a11y::ManageAccessibilityUpdates>| { + let output: bool = { + { + let output: bool = ::bevy_a11y::ManageAccessibilityUpdates::get( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns `true` if Bevy's ECS should update the accessibility tree.", + &["_self"], + ) + .register_documented( + "set", + |mut _self: Mut<::bevy_a11y::ManageAccessibilityUpdates>, value: bool| { + let output: () = { + { + let output: () = ::bevy_a11y::ManageAccessibilityUpdates::set( + &mut _self, + value, + ) + .into(); + output + } + }; + output + }, + " Sets whether Bevy's ECS should update the accessibility tree.", + &["_self", "value"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry diff --git a/crates/bindings/bevy_animation_bms_bindings/src/lib.rs b/crates/bindings/bevy_animation_bms_bindings/src/lib.rs index 34a8730c8f..9670f0b3b2 100644 --- a/crates/bindings/bevy_animation_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_animation_bms_bindings/src/lib.rs @@ -1,39 +1,41 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyAnimationScriptingPlugin; pub(crate) fn register_animation_node_type_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_animation::graph::AnimationNodeType, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_animation::graph::AnimationNodeType>| { - let output: Val<::bevy_animation::graph::AnimationNodeType> = { - { - let output: Val<::bevy_animation::graph::AnimationNodeType> = - <::bevy_animation::graph::AnimationNodeType as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_animation::graph::AnimationNodeType>| { + let output: Val<::bevy_animation::graph::AnimationNodeType> = { + { + let output: Val<::bevy_animation::graph::AnimationNodeType> = <::bevy_animation::graph::AnimationNodeType as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -122,77 +124,78 @@ pub(crate) fn register_threaded_animation_graphs_functions(world: &mut World) { } pub(crate) fn register_animation_clip_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_animation::prelude::AnimationClip, + ::bevy_animation::AnimationClip, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_animation::prelude::AnimationClip>| { - let output: Val<::bevy_animation::prelude::AnimationClip> = { - { - let output: Val<::bevy_animation::prelude::AnimationClip> = - <::bevy_animation::prelude::AnimationClip as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "duration", - |_self: Ref<::bevy_animation::prelude::AnimationClip>| { - let output: f32 = { - { - let output: f32 = - ::bevy_animation::prelude::AnimationClip::duration(&_self).into(); - output - } - }; - output - }, - " Duration of the clip, represented in seconds.", - &["_self"], - ) - .register_documented( - "set_duration", - |mut _self: Mut<::bevy_animation::prelude::AnimationClip>, duration_sec: f32| { - let output: () = { - { - let output: () = ::bevy_animation::prelude::AnimationClip::set_duration( - &mut _self, - duration_sec, - ) - .into(); - output - } - }; - output - }, - " Set the duration of the clip in seconds.", - &["_self", "duration_sec"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_animation::AnimationClip>| { + let output: Val<::bevy_animation::AnimationClip> = { + { + let output: Val<::bevy_animation::AnimationClip> = <::bevy_animation::AnimationClip as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "duration", + |_self: Ref<::bevy_animation::AnimationClip>| { + let output: f32 = { + { + let output: f32 = ::bevy_animation::AnimationClip::duration( + &_self, + ) + .into(); + output + } + }; + output + }, + " Duration of the clip, represented in seconds.", + &["_self"], + ) + .register_documented( + "set_duration", + |mut _self: Mut<::bevy_animation::AnimationClip>, duration_sec: f32| { + let output: () = { + { + let output: () = ::bevy_animation::AnimationClip::set_duration( + &mut _self, + duration_sec, + ) + .into(); + output + } + }; + output + }, + " Set the duration of the clip in seconds.", + &["_self", "duration_sec"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_animation::prelude::AnimationClip, + ::bevy_animation::AnimationClip, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_animation_player_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_animation::prelude::AnimationPlayer, + ::bevy_animation::AnimationPlayer, >::new(world) .register_documented( "all_finished", - |_self: Ref<::bevy_animation::prelude::AnimationPlayer>| { + |_self: Ref<::bevy_animation::AnimationPlayer>| { let output: bool = { { - let output: bool = ::bevy_animation::prelude::AnimationPlayer::all_finished( + let output: bool = ::bevy_animation::AnimationPlayer::all_finished( &_self, ) .into(); @@ -206,10 +209,10 @@ pub(crate) fn register_animation_player_functions(world: &mut World) { ) .register_documented( "all_paused", - |_self: Ref<::bevy_animation::prelude::AnimationPlayer>| { + |_self: Ref<::bevy_animation::AnimationPlayer>| { let output: bool = { { - let output: bool = ::bevy_animation::prelude::AnimationPlayer::all_paused( + let output: bool = ::bevy_animation::AnimationPlayer::all_paused( &_self, ) .into(); @@ -223,10 +226,10 @@ pub(crate) fn register_animation_player_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_animation::prelude::AnimationPlayer>| { - let output: Val<::bevy_animation::prelude::AnimationPlayer> = { + |_self: Ref<::bevy_animation::AnimationPlayer>| { + let output: Val<::bevy_animation::AnimationPlayer> = { { - let output: Val<::bevy_animation::prelude::AnimationPlayer> = <::bevy_animation::prelude::AnimationPlayer as ::std::clone::Clone>::clone( + let output: Val<::bevy_animation::AnimationPlayer> = <::bevy_animation::AnimationPlayer as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -241,12 +244,12 @@ pub(crate) fn register_animation_player_functions(world: &mut World) { .register_documented( "clone_from", | - mut _self: Mut<::bevy_animation::prelude::AnimationPlayer>, - source: Ref<::bevy_animation::prelude::AnimationPlayer>| + mut _self: Mut<::bevy_animation::AnimationPlayer>, + source: Ref<::bevy_animation::AnimationPlayer>| { let output: () = { { - let output: () = <::bevy_animation::prelude::AnimationPlayer as ::std::clone::Clone>::clone_from( + let output: () = <::bevy_animation::AnimationPlayer as ::std::clone::Clone>::clone_from( &mut _self, &source, ) @@ -263,7 +266,7 @@ pub(crate) fn register_animation_player_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_animation::prelude::AnimationPlayer, + ::bevy_animation::AnimationPlayer, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -421,22 +424,23 @@ pub(crate) fn register_animation_target_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_animation::AnimationTarget, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_animation::AnimationTarget>| { - let output: Val<::bevy_animation::AnimationTarget> = { - { - let output: Val<::bevy_animation::AnimationTarget> = - <::bevy_animation::AnimationTarget as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_animation::AnimationTarget>| { + let output: Val<::bevy_animation::AnimationTarget> = { + { + let output: Val<::bevy_animation::AnimationTarget> = <::bevy_animation::AnimationTarget as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry diff --git a/crates/bindings/bevy_asset_bms_bindings/src/lib.rs b/crates/bindings/bevy_asset_bms_bindings/src/lib.rs index bb5bb0887c..4c474c9c87 100644 --- a/crates/bindings/bevy_asset_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_asset_bms_bindings/src/lib.rs @@ -1,78 +1,100 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyAssetScriptingPlugin; pub(crate) fn register_untyped_handle_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_asset::prelude::UntypedHandle, + ::bevy_asset::UntypedHandle, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_asset::prelude::UntypedHandle>| { - let output: Val<::bevy_asset::prelude::UntypedHandle> = { - { - let output: Val<::bevy_asset::prelude::UntypedHandle> = - <::bevy_asset::prelude::UntypedHandle as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_asset::prelude::UntypedHandle>, - other: Ref<::bevy_asset::prelude::UntypedHandle>| { - let output: bool = { - { - let output: bool = - <::bevy_asset::prelude::UntypedHandle as ::core::cmp::PartialEq< - ::bevy_asset::prelude::UntypedHandle, + .register_documented( + "clone", + |_self: Ref<::bevy_asset::UntypedHandle>| { + let output: Val<::bevy_asset::UntypedHandle> = { + { + let output: Val<::bevy_asset::UntypedHandle> = <::bevy_asset::UntypedHandle as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_asset::UntypedHandle>, + other: Ref<::bevy_asset::UntypedHandle>| + { + let output: bool = { + { + let output: bool = <::bevy_asset::UntypedHandle as ::core::cmp::PartialEq< + ::bevy_asset::UntypedHandle, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "id", - |_self: Ref<::bevy_asset::prelude::UntypedHandle>| { - let output: Val<::bevy_asset::UntypedAssetId> = { - { - let output: Val<::bevy_asset::UntypedAssetId> = - ::bevy_asset::prelude::UntypedHandle::id(&_self).into(); - output - } - }; - output - }, - " Returns the [`UntypedAssetId`] for the referenced asset.", - &["_self"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "id", + |_self: Ref<::bevy_asset::UntypedHandle>| { + let output: Val<::bevy_asset::UntypedAssetId> = { + { + let output: Val<::bevy_asset::UntypedAssetId> = ::bevy_asset::UntypedHandle::id( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the [`UntypedAssetId`] for the referenced asset.", + &["_self"], + ) + .register_documented( + "type_id", + |_self: Ref<::bevy_asset::UntypedHandle>| { + let output: Val<::core::any::TypeId> = { + { + let output: Val<::core::any::TypeId> = ::bevy_asset::UntypedHandle::type_id( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the [`TypeId`] of the referenced [`Asset`].", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_asset::prelude::UntypedHandle, + ::bevy_asset::UntypedHandle, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -80,39 +102,60 @@ pub(crate) fn register_untyped_asset_id_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_asset::UntypedAssetId, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_asset::UntypedAssetId>| { - let output: Val<::bevy_asset::UntypedAssetId> = { - { - let output: Val<::bevy_asset::UntypedAssetId> = - <::bevy_asset::UntypedAssetId as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_asset::UntypedAssetId>, other: Ref<::bevy_asset::UntypedAssetId>| { - let output: bool = { - { - let output: bool = <::bevy_asset::UntypedAssetId as ::core::cmp::PartialEq< - ::bevy_asset::UntypedAssetId, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_asset::UntypedAssetId>| { + let output: Val<::bevy_asset::UntypedAssetId> = { + { + let output: Val<::bevy_asset::UntypedAssetId> = <::bevy_asset::UntypedAssetId as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_asset::UntypedAssetId>, + other: Ref<::bevy_asset::UntypedAssetId>| + { + let output: bool = { + { + let output: bool = <::bevy_asset::UntypedAssetId as ::core::cmp::PartialEq< + ::bevy_asset::UntypedAssetId, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "type_id", + |_self: Ref<::bevy_asset::UntypedAssetId>| { + let output: Val<::core::any::TypeId> = { + { + let output: Val<::core::any::TypeId> = ::bevy_asset::UntypedAssetId::type_id( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the stored [`TypeId`] of the referenced [`Asset`].", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry diff --git a/crates/bindings/bevy_camera_bms_bindings/src/lib.rs b/crates/bindings/bevy_camera_bms_bindings/src/lib.rs index 6b441af726..0b49890149 100644 --- a/crates/bindings/bevy_camera_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_camera_bms_bindings/src/lib.rs @@ -1,42 +1,46 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyCameraScriptingPlugin; pub(crate) fn register_clear_color_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_camera::prelude::ClearColor, + ::bevy_camera::ClearColor, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_camera::prelude::ClearColor>| { - let output: Val<::bevy_camera::prelude::ClearColor> = { - { - let output: Val<::bevy_camera::prelude::ClearColor> = - <::bevy_camera::prelude::ClearColor as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_camera::ClearColor>| { + let output: Val<::bevy_camera::ClearColor> = { + { + let output: Val<::bevy_camera::ClearColor> = <::bevy_camera::ClearColor as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_camera::prelude::ClearColor, + ::bevy_camera::ClearColor, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -344,14 +348,31 @@ pub(crate) fn register_visibility_functions(world: &mut World) { } pub(crate) fn register_camera_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_camera::prelude::Camera, + ::bevy_camera::Camera, >::new(world) + .register_documented( + "clip_from_view", + |_self: Ref<::bevy_camera::Camera>| { + let output: Val<::glam::Mat4> = { + { + let output: Val<::glam::Mat4> = ::bevy_camera::Camera::clip_from_view( + &_self, + ) + .into(); + output + } + }; + output + }, + " The projection matrix computed using this camera's [`Projection`](super::projection::Projection).", + &["_self"], + ) .register_documented( "clone", - |_self: Ref<::bevy_camera::prelude::Camera>| { - let output: Val<::bevy_camera::prelude::Camera> = { + |_self: Ref<::bevy_camera::Camera>| { + let output: Val<::bevy_camera::Camera> = { { - let output: Val<::bevy_camera::prelude::Camera> = <::bevy_camera::prelude::Camera as ::std::clone::Clone>::clone( + let output: Val<::bevy_camera::Camera> = <::bevy_camera::Camera as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -365,10 +386,10 @@ pub(crate) fn register_camera_functions(world: &mut World) { ) .register_documented( "depth_ndc_to_view_z", - |_self: Ref<::bevy_camera::prelude::Camera>, ndc_depth: f32| { + |_self: Ref<::bevy_camera::Camera>, ndc_depth: f32| { let output: f32 = { { - let output: f32 = ::bevy_camera::prelude::Camera::depth_ndc_to_view_z( + let output: f32 = ::bevy_camera::Camera::depth_ndc_to_view_z( &_self, ndc_depth, ) @@ -383,10 +404,10 @@ pub(crate) fn register_camera_functions(world: &mut World) { ) .register_documented( "depth_ndc_to_view_z_2d", - |_self: Ref<::bevy_camera::prelude::Camera>, ndc_depth: f32| { + |_self: Ref<::bevy_camera::Camera>, ndc_depth: f32| { let output: f32 = { { - let output: f32 = ::bevy_camera::prelude::Camera::depth_ndc_to_view_z_2d( + let output: f32 = ::bevy_camera::Camera::depth_ndc_to_view_z_2d( &_self, ndc_depth, ) @@ -401,10 +422,10 @@ pub(crate) fn register_camera_functions(world: &mut World) { ) .register_documented( "target_scaling_factor", - |_self: Ref<::bevy_camera::prelude::Camera>| { + |_self: Ref<::bevy_camera::Camera>| { let output: ::std::option::Option = { { - let output: ::std::option::Option = ::bevy_camera::prelude::Camera::target_scaling_factor( + let output: ::std::option::Option = ::bevy_camera::Camera::target_scaling_factor( &_self, ) .into(); @@ -420,108 +441,107 @@ pub(crate) fn register_camera_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_camera::prelude::Camera, + ::bevy_camera::Camera, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_camera_2_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_camera::prelude::Camera2d, + ::bevy_camera::Camera2d, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_camera::prelude::Camera2d>| { - let output: Val<::bevy_camera::prelude::Camera2d> = { - { - let output: Val<::bevy_camera::prelude::Camera2d> = - <::bevy_camera::prelude::Camera2d as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_camera::Camera2d>| { + let output: Val<::bevy_camera::Camera2d> = { + { + let output: Val<::bevy_camera::Camera2d> = <::bevy_camera::Camera2d as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_camera::prelude::Camera2d, + ::bevy_camera::Camera2d, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_camera_3_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_camera::prelude::Camera3d, + ::bevy_camera::Camera3d, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_camera::prelude::Camera3d>| { - let output: Val<::bevy_camera::prelude::Camera3d> = { - { - let output: Val<::bevy_camera::prelude::Camera3d> = - <::bevy_camera::prelude::Camera3d as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_camera::Camera3d>| { + let output: Val<::bevy_camera::Camera3d> = { + { + let output: Val<::bevy_camera::Camera3d> = <::bevy_camera::Camera3d as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_camera::prelude::Camera3d, + ::bevy_camera::Camera3d, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_clear_color_config_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_camera::prelude::ClearColorConfig, + ::bevy_camera::ClearColorConfig, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_camera::prelude::ClearColorConfig>| { - let output: Val<::bevy_camera::prelude::ClearColorConfig> = { - { - let output: Val<::bevy_camera::prelude::ClearColorConfig> = - <::bevy_camera::prelude::ClearColorConfig as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_camera::ClearColorConfig>| { + let output: Val<::bevy_camera::ClearColorConfig> = { + { + let output: Val<::bevy_camera::ClearColorConfig> = <::bevy_camera::ClearColorConfig as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_camera::prelude::ClearColorConfig, + ::bevy_camera::ClearColorConfig, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_orthographic_projection_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_camera::prelude::OrthographicProjection, + ::bevy_camera::OrthographicProjection, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_camera::prelude::OrthographicProjection>| { - let output: Val<::bevy_camera::prelude::OrthographicProjection> = { + |_self: Ref<::bevy_camera::OrthographicProjection>| { + let output: Val<::bevy_camera::OrthographicProjection> = { { - let output: Val< - ::bevy_camera::prelude::OrthographicProjection, - > = <::bevy_camera::prelude::OrthographicProjection as ::std::clone::Clone>::clone( + let output: Val<::bevy_camera::OrthographicProjection> = <::bevy_camera::OrthographicProjection as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -536,11 +556,9 @@ pub(crate) fn register_orthographic_projection_functions(world: &mut World) { .register_documented( "default_2d", || { - let output: Val<::bevy_camera::prelude::OrthographicProjection> = { + let output: Val<::bevy_camera::OrthographicProjection> = { { - let output: Val< - ::bevy_camera::prelude::OrthographicProjection, - > = ::bevy_camera::prelude::OrthographicProjection::default_2d() + let output: Val<::bevy_camera::OrthographicProjection> = ::bevy_camera::OrthographicProjection::default_2d() .into(); output } @@ -553,11 +571,9 @@ pub(crate) fn register_orthographic_projection_functions(world: &mut World) { .register_documented( "default_3d", || { - let output: Val<::bevy_camera::prelude::OrthographicProjection> = { + let output: Val<::bevy_camera::OrthographicProjection> = { { - let output: Val< - ::bevy_camera::prelude::OrthographicProjection, - > = ::bevy_camera::prelude::OrthographicProjection::default_3d() + let output: Val<::bevy_camera::OrthographicProjection> = ::bevy_camera::OrthographicProjection::default_3d() .into(); output } @@ -571,20 +587,20 @@ pub(crate) fn register_orthographic_projection_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_camera::prelude::OrthographicProjection, + ::bevy_camera::OrthographicProjection, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_perspective_projection_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_camera::prelude::PerspectiveProjection, + ::bevy_camera::PerspectiveProjection, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_camera::prelude::PerspectiveProjection>| { - let output: Val<::bevy_camera::prelude::PerspectiveProjection> = { + |_self: Ref<::bevy_camera::PerspectiveProjection>| { + let output: Val<::bevy_camera::PerspectiveProjection> = { { - let output: Val<::bevy_camera::prelude::PerspectiveProjection> = <::bevy_camera::prelude::PerspectiveProjection as ::std::clone::Clone>::clone( + let output: Val<::bevy_camera::PerspectiveProjection> = <::bevy_camera::PerspectiveProjection as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -600,20 +616,20 @@ pub(crate) fn register_perspective_projection_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_camera::prelude::PerspectiveProjection, + ::bevy_camera::PerspectiveProjection, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_projection_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_camera::prelude::Projection, + ::bevy_camera::Projection, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_camera::prelude::Projection>| { - let output: Val<::bevy_camera::prelude::Projection> = { + |_self: Ref<::bevy_camera::Projection>| { + let output: Val<::bevy_camera::Projection> = { { - let output: Val<::bevy_camera::prelude::Projection> = <::bevy_camera::prelude::Projection as ::std::clone::Clone>::clone( + let output: Val<::bevy_camera::Projection> = <::bevy_camera::Projection as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -627,10 +643,10 @@ pub(crate) fn register_projection_functions(world: &mut World) { ) .register_documented( "is_perspective", - |_self: Ref<::bevy_camera::prelude::Projection>| { + |_self: Ref<::bevy_camera::Projection>| { let output: bool = { { - let output: bool = ::bevy_camera::prelude::Projection::is_perspective( + let output: bool = ::bevy_camera::Projection::is_perspective( &_self, ) .into(); @@ -646,7 +662,7 @@ pub(crate) fn register_projection_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_camera::prelude::Projection, + ::bevy_camera::Projection, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -654,22 +670,115 @@ pub(crate) fn register_frustum_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_camera::primitives::Frustum, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_camera::primitives::Frustum>| { - let output: Val<::bevy_camera::primitives::Frustum> = { - { - let output: Val<::bevy_camera::primitives::Frustum> = - <::bevy_camera::primitives::Frustum as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_camera::primitives::Frustum>| { + let output: Val<::bevy_camera::primitives::Frustum> = { + { + let output: Val<::bevy_camera::primitives::Frustum> = <::bevy_camera::primitives::Frustum as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "contains_aabb", + | + _self: Ref<::bevy_camera::primitives::Frustum>, + aabb: Ref<::bevy_camera::primitives::Aabb>, + world_from_local: Ref<::glam::Affine3A>| + { + let output: bool = { + { + let output: bool = ::bevy_camera::primitives::Frustum::contains_aabb( + &_self, + &aabb, + &world_from_local, + ) + .into(); + output + } + }; + output + }, + " Check if the frustum contains the Axis-Aligned Bounding Box (AABB).\n Referenced from: [Frustum Culling](https://learnopengl.com/Guest-Articles/2021/Scene/Frustum-Culling)", + &["_self", "aabb", "world_from_local"], + ) + .register_documented( + "from_clip_from_world", + |clip_from_world: Ref<::glam::Mat4>| { + let output: Val<::bevy_camera::primitives::Frustum> = { + { + let output: Val<::bevy_camera::primitives::Frustum> = ::bevy_camera::primitives::Frustum::from_clip_from_world( + &clip_from_world, + ) + .into(); + output + } + }; + output + }, + " Returns a frustum derived from `clip_from_world`.", + &["clip_from_world"], + ) + .register_documented( + "from_clip_from_world_custom_far", + | + clip_from_world: Ref<::glam::Mat4>, + view_translation: Ref<::glam::Vec3>, + view_backward: Ref<::glam::Vec3>, + far: f32| + { + let output: Val<::bevy_camera::primitives::Frustum> = { + { + let output: Val<::bevy_camera::primitives::Frustum> = ::bevy_camera::primitives::Frustum::from_clip_from_world_custom_far( + &clip_from_world, + &view_translation, + &view_backward, + far, + ) + .into(); + output + } + }; + output + }, + " Returns a frustum derived from `clip_from_world`,\n but with a custom far plane.", + &["clip_from_world", "view_translation", "view_backward", "far"], + ) + .register_documented( + "intersects_obb", + | + _self: Ref<::bevy_camera::primitives::Frustum>, + aabb: Ref<::bevy_camera::primitives::Aabb>, + world_from_local: Ref<::glam::Affine3A>, + intersect_near: bool, + intersect_far: bool| + { + let output: bool = { + { + let output: bool = ::bevy_camera::primitives::Frustum::intersects_obb( + &_self, + &aabb, + &world_from_local, + intersect_near, + intersect_far, + ) + .into(); + output + } + }; + output + }, + " Checks if an Oriented Bounding Box (obb) intersects the frustum.", + &["_self", "aabb", "world_from_local", "intersect_near", "intersect_far"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -682,39 +791,126 @@ pub(crate) fn register_visible_entities_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_camera::visibility::VisibleEntities, >::new(world) - .register_documented( - "clear_all", - |mut _self: Mut<::bevy_camera::visibility::VisibleEntities>| { - let output: () = { - { - let output: () = - ::bevy_camera::visibility::VisibleEntities::clear_all(&mut _self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_camera::visibility::VisibleEntities>| { - let output: Val<::bevy_camera::visibility::VisibleEntities> = { - { - let output: Val<::bevy_camera::visibility::VisibleEntities> = - <::bevy_camera::visibility::VisibleEntities as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clear", + | + mut _self: Mut<::bevy_camera::visibility::VisibleEntities>, + type_id: Val<::std::any::TypeId>| + { + let output: () = { + { + let output: () = ::bevy_camera::visibility::VisibleEntities::clear( + &mut _self, + type_id.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "type_id"], + ) + .register_documented( + "clear_all", + |mut _self: Mut<::bevy_camera::visibility::VisibleEntities>| { + let output: () = { + { + let output: () = ::bevy_camera::visibility::VisibleEntities::clear_all( + &mut _self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_camera::visibility::VisibleEntities>| { + let output: Val<::bevy_camera::visibility::VisibleEntities> = { + { + let output: Val<::bevy_camera::visibility::VisibleEntities> = <::bevy_camera::visibility::VisibleEntities as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "is_empty", + | + _self: Ref<::bevy_camera::visibility::VisibleEntities>, + type_id: Val<::std::any::TypeId>| + { + let output: bool = { + { + let output: bool = ::bevy_camera::visibility::VisibleEntities::is_empty( + &_self, + type_id.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "type_id"], + ) + .register_documented( + "len", + | + _self: Ref<::bevy_camera::visibility::VisibleEntities>, + type_id: Val<::std::any::TypeId>| + { + let output: usize = { + { + let output: usize = ::bevy_camera::visibility::VisibleEntities::len( + &_self, + type_id.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "type_id"], + ) + .register_documented( + "push", + | + mut _self: Mut<::bevy_camera::visibility::VisibleEntities>, + entity: Val<::bevy_ecs::entity::Entity>, + type_id: Val<::std::any::TypeId>| + { + let output: () = { + { + let output: () = ::bevy_camera::visibility::VisibleEntities::push( + &mut _self, + entity.into_inner(), + type_id.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "entity", "type_id"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -727,6 +923,24 @@ pub(crate) fn register_viewport_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_camera::Viewport, >::new(world) + .register_documented( + "clamp_to_size", + |mut _self: Mut<::bevy_camera::Viewport>, size: Val<::glam::UVec2>| { + let output: () = { + { + let output: () = ::bevy_camera::Viewport::clamp_to_size( + &mut _self, + size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Cut the viewport rectangle so that it lies inside a rectangle of the\n given size.\n If either of the viewport's position coordinates lies outside the given\n dimensions, it will be moved just inside first. If either of the given\n dimensions is zero, the position and size of the viewport rectangle will\n both be set to zero in that dimension.", + &["_self", "size"], + ) .register_documented( "clone", |_self: Ref<::bevy_camera::Viewport>| { @@ -768,38 +982,43 @@ pub(crate) fn register_sub_camera_view_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_camera::SubCameraView, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_camera::SubCameraView>| { - let output: Val<::bevy_camera::SubCameraView> = { - { - let output: Val<::bevy_camera::SubCameraView> = - <::bevy_camera::SubCameraView as ::std::clone::Clone>::clone(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_camera::SubCameraView>, other: Ref<::bevy_camera::SubCameraView>| { - let output: bool = { - { - let output: bool = <::bevy_camera::SubCameraView as ::std::cmp::PartialEq< - ::bevy_camera::SubCameraView, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_camera::SubCameraView>| { + let output: Val<::bevy_camera::SubCameraView> = { + { + let output: Val<::bevy_camera::SubCameraView> = <::bevy_camera::SubCameraView as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_camera::SubCameraView>, + other: Ref<::bevy_camera::SubCameraView>| + { + let output: bool = { + { + let output: bool = <::bevy_camera::SubCameraView as ::std::cmp::PartialEq< + ::bevy_camera::SubCameraView, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -856,24 +1075,23 @@ pub(crate) fn register_camera_main_texture_usages_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_camera::CameraMainTextureUsages, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_camera::CameraMainTextureUsages>| { - let output: Val<::bevy_camera::CameraMainTextureUsages> = { - { - let output: Val<::bevy_camera::CameraMainTextureUsages> = - <::bevy_camera::CameraMainTextureUsages as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_camera::CameraMainTextureUsages>| { + let output: Val<::bevy_camera::CameraMainTextureUsages> = { + { + let output: Val<::bevy_camera::CameraMainTextureUsages> = <::bevy_camera::CameraMainTextureUsages as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1113,22 +1331,23 @@ pub(crate) fn register_camera_3_d_depth_load_op_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_camera::Camera3dDepthLoadOp, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_camera::Camera3dDepthLoadOp>| { - let output: Val<::bevy_camera::Camera3dDepthLoadOp> = { - { - let output: Val<::bevy_camera::Camera3dDepthLoadOp> = - <::bevy_camera::Camera3dDepthLoadOp as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_camera::Camera3dDepthLoadOp>| { + let output: Val<::bevy_camera::Camera3dDepthLoadOp> = { + { + let output: Val<::bevy_camera::Camera3dDepthLoadOp> = <::bevy_camera::Camera3dDepthLoadOp as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1141,24 +1360,23 @@ pub(crate) fn register_camera_3_d_depth_texture_usage_functions(world: &mut Worl bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_camera::Camera3dDepthTextureUsage, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_camera::Camera3dDepthTextureUsage>| { - let output: Val<::bevy_camera::Camera3dDepthTextureUsage> = { - { - let output: Val<::bevy_camera::Camera3dDepthTextureUsage> = - <::bevy_camera::Camera3dDepthTextureUsage as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_camera::Camera3dDepthTextureUsage>| { + let output: Val<::bevy_camera::Camera3dDepthTextureUsage> = { + { + let output: Val<::bevy_camera::Camera3dDepthTextureUsage> = <::bevy_camera::Camera3dDepthTextureUsage as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1220,40 +1438,118 @@ pub(crate) fn register_aabb_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_camera::primitives::Aabb, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_camera::primitives::Aabb>| { - let output: Val<::bevy_camera::primitives::Aabb> = { - { - let output: Val<::bevy_camera::primitives::Aabb> = - <::bevy_camera::primitives::Aabb as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_camera::primitives::Aabb>, - other: Ref<::bevy_camera::primitives::Aabb>| { - let output: bool = { - { - let output: bool = <::bevy_camera::primitives::Aabb as ::std::cmp::PartialEq< - ::bevy_camera::primitives::Aabb, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_camera::primitives::Aabb>| { + let output: Val<::bevy_camera::primitives::Aabb> = { + { + let output: Val<::bevy_camera::primitives::Aabb> = <::bevy_camera::primitives::Aabb as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_camera::primitives::Aabb>, + other: Ref<::bevy_camera::primitives::Aabb>| + { + let output: bool = { + { + let output: bool = <::bevy_camera::primitives::Aabb as ::std::cmp::PartialEq< + ::bevy_camera::primitives::Aabb, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "from_min_max", + |minimum: Val<::glam::Vec3>, maximum: Val<::glam::Vec3>| { + let output: Val<::bevy_camera::primitives::Aabb> = { + { + let output: Val<::bevy_camera::primitives::Aabb> = ::bevy_camera::primitives::Aabb::from_min_max( + minimum.into_inner(), + maximum.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["minimum", "maximum"], + ) + .register_documented( + "max", + |_self: Ref<::bevy_camera::primitives::Aabb>| { + let output: Val<::glam::Vec3A> = { + { + let output: Val<::glam::Vec3A> = ::bevy_camera::primitives::Aabb::max( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "min", + |_self: Ref<::bevy_camera::primitives::Aabb>| { + let output: Val<::glam::Vec3A> = { + { + let output: Val<::glam::Vec3A> = ::bevy_camera::primitives::Aabb::min( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "relative_radius", + | + _self: Ref<::bevy_camera::primitives::Aabb>, + p_normal: Ref<::glam::Vec3A>, + world_from_local: Ref<::glam::Mat3A>| + { + let output: f32 = { + { + let output: f32 = ::bevy_camera::primitives::Aabb::relative_radius( + &_self, + &p_normal, + &world_from_local, + ) + .into(); + output + } + }; + output + }, + " Calculate the relative radius of the AABB with respect to a plane", + &["_self", "p_normal", "world_from_local"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1266,24 +1562,23 @@ pub(crate) fn register_cubemap_frusta_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_camera::primitives::CubemapFrusta, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_camera::primitives::CubemapFrusta>| { - let output: Val<::bevy_camera::primitives::CubemapFrusta> = { - { - let output: Val<::bevy_camera::primitives::CubemapFrusta> = - <::bevy_camera::primitives::CubemapFrusta as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_camera::primitives::CubemapFrusta>| { + let output: Val<::bevy_camera::primitives::CubemapFrusta> = { + { + let output: Val<::bevy_camera::primitives::CubemapFrusta> = <::bevy_camera::primitives::CubemapFrusta as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1296,24 +1591,23 @@ pub(crate) fn register_cubemap_layout_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_camera::primitives::CubemapLayout, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_camera::primitives::CubemapLayout>| { - let output: Val<::bevy_camera::primitives::CubemapLayout> = { - { - let output: Val<::bevy_camera::primitives::CubemapLayout> = - <::bevy_camera::primitives::CubemapLayout as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_camera::primitives::CubemapLayout>| { + let output: Val<::bevy_camera::primitives::CubemapLayout> = { + { + let output: Val<::bevy_camera::primitives::CubemapLayout> = <::bevy_camera::primitives::CubemapLayout as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1326,24 +1620,23 @@ pub(crate) fn register_cascades_frusta_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_camera::primitives::CascadesFrusta, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_camera::primitives::CascadesFrusta>| { - let output: Val<::bevy_camera::primitives::CascadesFrusta> = { - { - let output: Val<::bevy_camera::primitives::CascadesFrusta> = - <::bevy_camera::primitives::CascadesFrusta as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_camera::primitives::CascadesFrusta>| { + let output: Val<::bevy_camera::primitives::CascadesFrusta> = { + { + let output: Val<::bevy_camera::primitives::CascadesFrusta> = <::bevy_camera::primitives::CascadesFrusta as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1356,22 +1649,23 @@ pub(crate) fn register_custom_projection_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_camera::CustomProjection, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_camera::CustomProjection>| { - let output: Val<::bevy_camera::CustomProjection> = { - { - let output: Val<::bevy_camera::CustomProjection> = - <::bevy_camera::CustomProjection as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_camera::CustomProjection>| { + let output: Val<::bevy_camera::CustomProjection> = { + { + let output: Val<::bevy_camera::CustomProjection> = <::bevy_camera::CustomProjection as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1413,24 +1707,23 @@ pub(crate) fn register_visibility_class_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_camera::visibility::VisibilityClass, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_camera::visibility::VisibilityClass>| { - let output: Val<::bevy_camera::visibility::VisibilityClass> = { - { - let output: Val<::bevy_camera::visibility::VisibilityClass> = - <::bevy_camera::visibility::VisibilityClass as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_camera::visibility::VisibilityClass>| { + let output: Val<::bevy_camera::visibility::VisibilityClass> = { + { + let output: Val<::bevy_camera::visibility::VisibilityClass> = <::bevy_camera::visibility::VisibilityClass as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry diff --git a/crates/bindings/bevy_color_bms_bindings/src/lib.rs b/crates/bindings/bevy_color_bms_bindings/src/lib.rs index b6cc20cc82..7d513da6ea 100644 --- a/crates/bindings/bevy_color_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_color_bms_bindings/src/lib.rs @@ -1,27 +1,30 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyColorScriptingPlugin; pub(crate) fn register_color_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_color::prelude::Color, + ::bevy_color::Color, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_color::prelude::Color>| { - let output: Val<::bevy_color::prelude::Color> = { + |_self: Ref<::bevy_color::Color>| { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = <::bevy_color::prelude::Color as ::core::clone::Clone>::clone( + let output: Val<::bevy_color::Color> = <::bevy_color::Color as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -35,14 +38,11 @@ pub(crate) fn register_color_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_color::prelude::Color>, - other: Ref<::bevy_color::prelude::Color>| - { + |_self: Ref<::bevy_color::Color>, other: Ref<::bevy_color::Color>| { let output: bool = { { - let output: bool = <::bevy_color::prelude::Color as ::core::cmp::PartialEq< - ::bevy_color::prelude::Color, + let output: bool = <::bevy_color::Color as ::core::cmp::PartialEq< + ::bevy_color::Color, >>::eq(&_self, &other) .into(); output @@ -56,9 +56,9 @@ pub(crate) fn register_color_functions(world: &mut World) { .register_documented( "hsl", |hue: f32, saturation: f32, lightness: f32| { - let output: Val<::bevy_color::prelude::Color> = { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = ::bevy_color::prelude::Color::hsl( + let output: Val<::bevy_color::Color> = ::bevy_color::Color::hsl( hue, saturation, lightness, @@ -75,9 +75,9 @@ pub(crate) fn register_color_functions(world: &mut World) { .register_documented( "hsla", |hue: f32, saturation: f32, lightness: f32, alpha: f32| { - let output: Val<::bevy_color::prelude::Color> = { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = ::bevy_color::prelude::Color::hsla( + let output: Val<::bevy_color::Color> = ::bevy_color::Color::hsla( hue, saturation, lightness, @@ -95,9 +95,9 @@ pub(crate) fn register_color_functions(world: &mut World) { .register_documented( "hsv", |hue: f32, saturation: f32, value: f32| { - let output: Val<::bevy_color::prelude::Color> = { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = ::bevy_color::prelude::Color::hsv( + let output: Val<::bevy_color::Color> = ::bevy_color::Color::hsv( hue, saturation, value, @@ -114,9 +114,9 @@ pub(crate) fn register_color_functions(world: &mut World) { .register_documented( "hsva", |hue: f32, saturation: f32, value: f32, alpha: f32| { - let output: Val<::bevy_color::prelude::Color> = { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = ::bevy_color::prelude::Color::hsva( + let output: Val<::bevy_color::Color> = ::bevy_color::Color::hsva( hue, saturation, value, @@ -134,9 +134,9 @@ pub(crate) fn register_color_functions(world: &mut World) { .register_documented( "hwb", |hue: f32, whiteness: f32, blackness: f32| { - let output: Val<::bevy_color::prelude::Color> = { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = ::bevy_color::prelude::Color::hwb( + let output: Val<::bevy_color::Color> = ::bevy_color::Color::hwb( hue, whiteness, blackness, @@ -153,9 +153,9 @@ pub(crate) fn register_color_functions(world: &mut World) { .register_documented( "hwba", |hue: f32, whiteness: f32, blackness: f32, alpha: f32| { - let output: Val<::bevy_color::prelude::Color> = { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = ::bevy_color::prelude::Color::hwba( + let output: Val<::bevy_color::Color> = ::bevy_color::Color::hwba( hue, whiteness, blackness, @@ -173,9 +173,9 @@ pub(crate) fn register_color_functions(world: &mut World) { .register_documented( "lab", |lightness: f32, a: f32, b: f32| { - let output: Val<::bevy_color::prelude::Color> = { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = ::bevy_color::prelude::Color::lab( + let output: Val<::bevy_color::Color> = ::bevy_color::Color::lab( lightness, a, b, @@ -192,9 +192,9 @@ pub(crate) fn register_color_functions(world: &mut World) { .register_documented( "laba", |lightness: f32, a: f32, b: f32, alpha: f32| { - let output: Val<::bevy_color::prelude::Color> = { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = ::bevy_color::prelude::Color::laba( + let output: Val<::bevy_color::Color> = ::bevy_color::Color::laba( lightness, a, b, @@ -212,9 +212,9 @@ pub(crate) fn register_color_functions(world: &mut World) { .register_documented( "lch", |lightness: f32, chroma: f32, hue: f32| { - let output: Val<::bevy_color::prelude::Color> = { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = ::bevy_color::prelude::Color::lch( + let output: Val<::bevy_color::Color> = ::bevy_color::Color::lch( lightness, chroma, hue, @@ -231,9 +231,9 @@ pub(crate) fn register_color_functions(world: &mut World) { .register_documented( "lcha", |lightness: f32, chroma: f32, hue: f32, alpha: f32| { - let output: Val<::bevy_color::prelude::Color> = { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = ::bevy_color::prelude::Color::lcha( + let output: Val<::bevy_color::Color> = ::bevy_color::Color::lcha( lightness, chroma, hue, @@ -251,9 +251,9 @@ pub(crate) fn register_color_functions(world: &mut World) { .register_documented( "linear_rgb", |red: f32, green: f32, blue: f32| { - let output: Val<::bevy_color::prelude::Color> = { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = ::bevy_color::prelude::Color::linear_rgb( + let output: Val<::bevy_color::Color> = ::bevy_color::Color::linear_rgb( red, green, blue, @@ -270,9 +270,9 @@ pub(crate) fn register_color_functions(world: &mut World) { .register_documented( "linear_rgba", |red: f32, green: f32, blue: f32, alpha: f32| { - let output: Val<::bevy_color::prelude::Color> = { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = ::bevy_color::prelude::Color::linear_rgba( + let output: Val<::bevy_color::Color> = ::bevy_color::Color::linear_rgba( red, green, blue, @@ -290,9 +290,9 @@ pub(crate) fn register_color_functions(world: &mut World) { .register_documented( "oklab", |lightness: f32, a: f32, b: f32| { - let output: Val<::bevy_color::prelude::Color> = { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = ::bevy_color::prelude::Color::oklab( + let output: Val<::bevy_color::Color> = ::bevy_color::Color::oklab( lightness, a, b, @@ -309,9 +309,9 @@ pub(crate) fn register_color_functions(world: &mut World) { .register_documented( "oklaba", |lightness: f32, a: f32, b: f32, alpha: f32| { - let output: Val<::bevy_color::prelude::Color> = { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = ::bevy_color::prelude::Color::oklaba( + let output: Val<::bevy_color::Color> = ::bevy_color::Color::oklaba( lightness, a, b, @@ -329,9 +329,9 @@ pub(crate) fn register_color_functions(world: &mut World) { .register_documented( "oklch", |lightness: f32, chroma: f32, hue: f32| { - let output: Val<::bevy_color::prelude::Color> = { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = ::bevy_color::prelude::Color::oklch( + let output: Val<::bevy_color::Color> = ::bevy_color::Color::oklch( lightness, chroma, hue, @@ -348,9 +348,9 @@ pub(crate) fn register_color_functions(world: &mut World) { .register_documented( "oklcha", |lightness: f32, chroma: f32, hue: f32, alpha: f32| { - let output: Val<::bevy_color::prelude::Color> = { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = ::bevy_color::prelude::Color::oklcha( + let output: Val<::bevy_color::Color> = ::bevy_color::Color::oklcha( lightness, chroma, hue, @@ -368,9 +368,9 @@ pub(crate) fn register_color_functions(world: &mut World) { .register_documented( "srgb", |red: f32, green: f32, blue: f32| { - let output: Val<::bevy_color::prelude::Color> = { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = ::bevy_color::prelude::Color::srgb( + let output: Val<::bevy_color::Color> = ::bevy_color::Color::srgb( red, green, blue, @@ -387,9 +387,9 @@ pub(crate) fn register_color_functions(world: &mut World) { .register_documented( "srgb_from_array", |array: [f32; 3]| { - let output: Val<::bevy_color::prelude::Color> = { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = ::bevy_color::prelude::Color::srgb_from_array( + let output: Val<::bevy_color::Color> = ::bevy_color::Color::srgb_from_array( array, ) .into(); @@ -404,9 +404,9 @@ pub(crate) fn register_color_functions(world: &mut World) { .register_documented( "srgb_u8", |red: u8, green: u8, blue: u8| { - let output: Val<::bevy_color::prelude::Color> = { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = ::bevy_color::prelude::Color::srgb_u8( + let output: Val<::bevy_color::Color> = ::bevy_color::Color::srgb_u8( red, green, blue, @@ -423,9 +423,9 @@ pub(crate) fn register_color_functions(world: &mut World) { .register_documented( "srgba", |red: f32, green: f32, blue: f32, alpha: f32| { - let output: Val<::bevy_color::prelude::Color> = { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = ::bevy_color::prelude::Color::srgba( + let output: Val<::bevy_color::Color> = ::bevy_color::Color::srgba( red, green, blue, @@ -443,9 +443,9 @@ pub(crate) fn register_color_functions(world: &mut World) { .register_documented( "srgba_u8", |red: u8, green: u8, blue: u8, alpha: u8| { - let output: Val<::bevy_color::prelude::Color> = { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = ::bevy_color::prelude::Color::srgba_u8( + let output: Val<::bevy_color::Color> = ::bevy_color::Color::srgba_u8( red, green, blue, @@ -462,10 +462,10 @@ pub(crate) fn register_color_functions(world: &mut World) { ) .register_documented( "to_linear", - |_self: Ref<::bevy_color::prelude::Color>| { - let output: Val<::bevy_color::prelude::LinearRgba> = { + |_self: Ref<::bevy_color::Color>| { + let output: Val<::bevy_color::LinearRgba> = { { - let output: Val<::bevy_color::prelude::LinearRgba> = ::bevy_color::prelude::Color::to_linear( + let output: Val<::bevy_color::LinearRgba> = ::bevy_color::Color::to_linear( &_self, ) .into(); @@ -479,10 +479,10 @@ pub(crate) fn register_color_functions(world: &mut World) { ) .register_documented( "to_srgba", - |_self: Ref<::bevy_color::prelude::Color>| { - let output: Val<::bevy_color::prelude::Srgba> = { + |_self: Ref<::bevy_color::Color>| { + let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::prelude::Srgba> = ::bevy_color::prelude::Color::to_srgba( + let output: Val<::bevy_color::Srgba> = ::bevy_color::Color::to_srgba( &_self, ) .into(); @@ -497,9 +497,9 @@ pub(crate) fn register_color_functions(world: &mut World) { .register_documented( "xyz", |x: f32, y: f32, z: f32| { - let output: Val<::bevy_color::prelude::Color> = { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = ::bevy_color::prelude::Color::xyz( + let output: Val<::bevy_color::Color> = ::bevy_color::Color::xyz( x, y, z, @@ -516,9 +516,9 @@ pub(crate) fn register_color_functions(world: &mut World) { .register_documented( "xyza", |x: f32, y: f32, z: f32, alpha: f32| { - let output: Val<::bevy_color::prelude::Color> = { + let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::prelude::Color> = ::bevy_color::prelude::Color::xyza( + let output: Val<::bevy_color::Color> = ::bevy_color::Color::xyza( x, y, z, @@ -537,24 +537,21 @@ pub(crate) fn register_color_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_color::prelude::Color, + ::bevy_color::Color, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_srgba_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_color::prelude::Srgba, + ::bevy_color::Srgba, >::new(world) .register_documented( "add", - | - _self: Val<::bevy_color::prelude::Srgba>, - rhs: Val<::bevy_color::prelude::Srgba>| - { - let output: Val<::bevy_color::prelude::Srgba> = { - { - let output: Val<::bevy_color::prelude::Srgba> = <::bevy_color::prelude::Srgba as ::core::ops::Add< - ::bevy_color::prelude::Srgba, + |_self: Val<::bevy_color::Srgba>, rhs: Val<::bevy_color::Srgba>| { + let output: Val<::bevy_color::Srgba> = { + { + let output: Val<::bevy_color::Srgba> = <::bevy_color::Srgba as ::core::ops::Add< + ::bevy_color::Srgba, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output @@ -567,10 +564,10 @@ pub(crate) fn register_srgba_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_color::prelude::Srgba>| { - let output: Val<::bevy_color::prelude::Srgba> = { + |_self: Ref<::bevy_color::Srgba>| { + let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::prelude::Srgba> = <::bevy_color::prelude::Srgba as ::core::clone::Clone>::clone( + let output: Val<::bevy_color::Srgba> = <::bevy_color::Srgba as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -584,10 +581,10 @@ pub(crate) fn register_srgba_functions(world: &mut World) { ) .register_documented( "div", - |_self: Val<::bevy_color::prelude::Srgba>, rhs: f32| { - let output: Val<::bevy_color::prelude::Srgba> = { + |_self: Val<::bevy_color::Srgba>, rhs: f32| { + let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::prelude::Srgba> = <::bevy_color::prelude::Srgba as ::core::ops::Div< + let output: Val<::bevy_color::Srgba> = <::bevy_color::Srgba as ::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -601,14 +598,11 @@ pub(crate) fn register_srgba_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_color::prelude::Srgba>, - other: Ref<::bevy_color::prelude::Srgba>| - { + |_self: Ref<::bevy_color::Srgba>, other: Ref<::bevy_color::Srgba>| { let output: bool = { { - let output: bool = <::bevy_color::prelude::Srgba as ::core::cmp::PartialEq< - ::bevy_color::prelude::Srgba, + let output: bool = <::bevy_color::Srgba as ::core::cmp::PartialEq< + ::bevy_color::Srgba, >>::eq(&_self, &other) .into(); output @@ -624,9 +618,7 @@ pub(crate) fn register_srgba_functions(world: &mut World) { |value: f32| { let output: f32 = { { - let output: f32 = ::bevy_color::prelude::Srgba::gamma_function( - value, - ) + let output: f32 = ::bevy_color::Srgba::gamma_function(value) .into(); output } @@ -641,7 +633,7 @@ pub(crate) fn register_srgba_functions(world: &mut World) { |value: f32| { let output: f32 = { { - let output: f32 = ::bevy_color::prelude::Srgba::gamma_function_inverse( + let output: f32 = ::bevy_color::Srgba::gamma_function_inverse( value, ) .into(); @@ -655,10 +647,10 @@ pub(crate) fn register_srgba_functions(world: &mut World) { ) .register_documented( "mul", - |_self: Val<::bevy_color::prelude::Srgba>, rhs: f32| { - let output: Val<::bevy_color::prelude::Srgba> = { + |_self: Val<::bevy_color::Srgba>, rhs: f32| { + let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::prelude::Srgba> = <::bevy_color::prelude::Srgba as ::core::ops::Mul< + let output: Val<::bevy_color::Srgba> = <::bevy_color::Srgba as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -672,10 +664,10 @@ pub(crate) fn register_srgba_functions(world: &mut World) { ) .register_documented( "neg", - |_self: Val<::bevy_color::prelude::Srgba>| { - let output: Val<::bevy_color::prelude::Srgba> = { + |_self: Val<::bevy_color::Srgba>| { + let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::prelude::Srgba> = <::bevy_color::prelude::Srgba as ::core::ops::Neg>::neg( + let output: Val<::bevy_color::Srgba> = <::bevy_color::Srgba as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -690,9 +682,9 @@ pub(crate) fn register_srgba_functions(world: &mut World) { .register_documented( "new", |red: f32, green: f32, blue: f32, alpha: f32| { - let output: Val<::bevy_color::prelude::Srgba> = { + let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::prelude::Srgba> = ::bevy_color::prelude::Srgba::new( + let output: Val<::bevy_color::Srgba> = ::bevy_color::Srgba::new( red, green, blue, @@ -710,9 +702,9 @@ pub(crate) fn register_srgba_functions(world: &mut World) { .register_documented( "rgb", |red: f32, green: f32, blue: f32| { - let output: Val<::bevy_color::prelude::Srgba> = { + let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::prelude::Srgba> = ::bevy_color::prelude::Srgba::rgb( + let output: Val<::bevy_color::Srgba> = ::bevy_color::Srgba::rgb( red, green, blue, @@ -729,9 +721,9 @@ pub(crate) fn register_srgba_functions(world: &mut World) { .register_documented( "rgb_u8", |r: u8, g: u8, b: u8| { - let output: Val<::bevy_color::prelude::Srgba> = { + let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::prelude::Srgba> = ::bevy_color::prelude::Srgba::rgb_u8( + let output: Val<::bevy_color::Srgba> = ::bevy_color::Srgba::rgb_u8( r, g, b, @@ -748,9 +740,9 @@ pub(crate) fn register_srgba_functions(world: &mut World) { .register_documented( "rgba_u8", |r: u8, g: u8, b: u8, a: u8| { - let output: Val<::bevy_color::prelude::Srgba> = { + let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::prelude::Srgba> = ::bevy_color::prelude::Srgba::rgba_u8( + let output: Val<::bevy_color::Srgba> = ::bevy_color::Srgba::rgba_u8( r, g, b, @@ -767,14 +759,11 @@ pub(crate) fn register_srgba_functions(world: &mut World) { ) .register_documented( "sub", - | - _self: Val<::bevy_color::prelude::Srgba>, - rhs: Val<::bevy_color::prelude::Srgba>| - { - let output: Val<::bevy_color::prelude::Srgba> = { - { - let output: Val<::bevy_color::prelude::Srgba> = <::bevy_color::prelude::Srgba as ::core::ops::Sub< - ::bevy_color::prelude::Srgba, + |_self: Val<::bevy_color::Srgba>, rhs: Val<::bevy_color::Srgba>| { + let output: Val<::bevy_color::Srgba> = { + { + let output: Val<::bevy_color::Srgba> = <::bevy_color::Srgba as ::core::ops::Sub< + ::bevy_color::Srgba, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output @@ -787,10 +776,10 @@ pub(crate) fn register_srgba_functions(world: &mut World) { ) .register_documented( "to_hex", - |_self: Ref<::bevy_color::prelude::Srgba>| { + |_self: Ref<::bevy_color::Srgba>| { let output: ::std::string::String = { { - let output: ::std::string::String = ::bevy_color::prelude::Srgba::to_hex( + let output: ::std::string::String = ::bevy_color::Srgba::to_hex( &_self, ) .into(); @@ -804,10 +793,10 @@ pub(crate) fn register_srgba_functions(world: &mut World) { ) .register_documented( "with_blue", - |_self: Val<::bevy_color::prelude::Srgba>, blue: f32| { - let output: Val<::bevy_color::prelude::Srgba> = { + |_self: Val<::bevy_color::Srgba>, blue: f32| { + let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::prelude::Srgba> = ::bevy_color::prelude::Srgba::with_blue( + let output: Val<::bevy_color::Srgba> = ::bevy_color::Srgba::with_blue( _self.into_inner(), blue, ) @@ -822,10 +811,10 @@ pub(crate) fn register_srgba_functions(world: &mut World) { ) .register_documented( "with_green", - |_self: Val<::bevy_color::prelude::Srgba>, green: f32| { - let output: Val<::bevy_color::prelude::Srgba> = { + |_self: Val<::bevy_color::Srgba>, green: f32| { + let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::prelude::Srgba> = ::bevy_color::prelude::Srgba::with_green( + let output: Val<::bevy_color::Srgba> = ::bevy_color::Srgba::with_green( _self.into_inner(), green, ) @@ -840,10 +829,10 @@ pub(crate) fn register_srgba_functions(world: &mut World) { ) .register_documented( "with_red", - |_self: Val<::bevy_color::prelude::Srgba>, red: f32| { - let output: Val<::bevy_color::prelude::Srgba> = { + |_self: Val<::bevy_color::Srgba>, red: f32| { + let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::prelude::Srgba> = ::bevy_color::prelude::Srgba::with_red( + let output: Val<::bevy_color::Srgba> = ::bevy_color::Srgba::with_red( _self.into_inner(), red, ) @@ -860,24 +849,21 @@ pub(crate) fn register_srgba_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_color::prelude::Srgba, + ::bevy_color::Srgba, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_linear_rgba_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_color::prelude::LinearRgba, + ::bevy_color::LinearRgba, >::new(world) .register_documented( "add", - | - _self: Val<::bevy_color::prelude::LinearRgba>, - rhs: Val<::bevy_color::prelude::LinearRgba>| - { - let output: Val<::bevy_color::prelude::LinearRgba> = { - { - let output: Val<::bevy_color::prelude::LinearRgba> = <::bevy_color::prelude::LinearRgba as ::core::ops::Add< - ::bevy_color::prelude::LinearRgba, + |_self: Val<::bevy_color::LinearRgba>, rhs: Val<::bevy_color::LinearRgba>| { + let output: Val<::bevy_color::LinearRgba> = { + { + let output: Val<::bevy_color::LinearRgba> = <::bevy_color::LinearRgba as ::core::ops::Add< + ::bevy_color::LinearRgba, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output @@ -890,12 +876,10 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { ) .register_documented( "as_u32", - |_self: Ref<::bevy_color::prelude::LinearRgba>| { + |_self: Ref<::bevy_color::LinearRgba>| { let output: u32 = { { - let output: u32 = ::bevy_color::prelude::LinearRgba::as_u32( - &_self, - ) + let output: u32 = ::bevy_color::LinearRgba::as_u32(&_self) .into(); output } @@ -907,10 +891,10 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_color::prelude::LinearRgba>| { - let output: Val<::bevy_color::prelude::LinearRgba> = { + |_self: Ref<::bevy_color::LinearRgba>| { + let output: Val<::bevy_color::LinearRgba> = { { - let output: Val<::bevy_color::prelude::LinearRgba> = <::bevy_color::prelude::LinearRgba as ::core::clone::Clone>::clone( + let output: Val<::bevy_color::LinearRgba> = <::bevy_color::LinearRgba as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -924,10 +908,10 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { ) .register_documented( "div", - |_self: Val<::bevy_color::prelude::LinearRgba>, rhs: f32| { - let output: Val<::bevy_color::prelude::LinearRgba> = { + |_self: Val<::bevy_color::LinearRgba>, rhs: f32| { + let output: Val<::bevy_color::LinearRgba> = { { - let output: Val<::bevy_color::prelude::LinearRgba> = <::bevy_color::prelude::LinearRgba as ::core::ops::Div< + let output: Val<::bevy_color::LinearRgba> = <::bevy_color::LinearRgba as ::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -941,14 +925,11 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_color::prelude::LinearRgba>, - other: Ref<::bevy_color::prelude::LinearRgba>| - { + |_self: Ref<::bevy_color::LinearRgba>, other: Ref<::bevy_color::LinearRgba>| { let output: bool = { { - let output: bool = <::bevy_color::prelude::LinearRgba as ::core::cmp::PartialEq< - ::bevy_color::prelude::LinearRgba, + let output: bool = <::bevy_color::LinearRgba as ::core::cmp::PartialEq< + ::bevy_color::LinearRgba, >>::eq(&_self, &other) .into(); output @@ -961,10 +942,10 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { ) .register_documented( "mul", - |_self: Val<::bevy_color::prelude::LinearRgba>, rhs: f32| { - let output: Val<::bevy_color::prelude::LinearRgba> = { + |_self: Val<::bevy_color::LinearRgba>, rhs: f32| { + let output: Val<::bevy_color::LinearRgba> = { { - let output: Val<::bevy_color::prelude::LinearRgba> = <::bevy_color::prelude::LinearRgba as ::core::ops::Mul< + let output: Val<::bevy_color::LinearRgba> = <::bevy_color::LinearRgba as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -978,10 +959,10 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { ) .register_documented( "neg", - |_self: Val<::bevy_color::prelude::LinearRgba>| { - let output: Val<::bevy_color::prelude::LinearRgba> = { + |_self: Val<::bevy_color::LinearRgba>| { + let output: Val<::bevy_color::LinearRgba> = { { - let output: Val<::bevy_color::prelude::LinearRgba> = <::bevy_color::prelude::LinearRgba as ::core::ops::Neg>::neg( + let output: Val<::bevy_color::LinearRgba> = <::bevy_color::LinearRgba as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -996,9 +977,9 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { .register_documented( "new", |red: f32, green: f32, blue: f32, alpha: f32| { - let output: Val<::bevy_color::prelude::LinearRgba> = { + let output: Val<::bevy_color::LinearRgba> = { { - let output: Val<::bevy_color::prelude::LinearRgba> = ::bevy_color::prelude::LinearRgba::new( + let output: Val<::bevy_color::LinearRgba> = ::bevy_color::LinearRgba::new( red, green, blue, @@ -1016,9 +997,9 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { .register_documented( "rgb", |red: f32, green: f32, blue: f32| { - let output: Val<::bevy_color::prelude::LinearRgba> = { + let output: Val<::bevy_color::LinearRgba> = { { - let output: Val<::bevy_color::prelude::LinearRgba> = ::bevy_color::prelude::LinearRgba::rgb( + let output: Val<::bevy_color::LinearRgba> = ::bevy_color::LinearRgba::rgb( red, green, blue, @@ -1034,14 +1015,11 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { ) .register_documented( "sub", - | - _self: Val<::bevy_color::prelude::LinearRgba>, - rhs: Val<::bevy_color::prelude::LinearRgba>| - { - let output: Val<::bevy_color::prelude::LinearRgba> = { - { - let output: Val<::bevy_color::prelude::LinearRgba> = <::bevy_color::prelude::LinearRgba as ::core::ops::Sub< - ::bevy_color::prelude::LinearRgba, + |_self: Val<::bevy_color::LinearRgba>, rhs: Val<::bevy_color::LinearRgba>| { + let output: Val<::bevy_color::LinearRgba> = { + { + let output: Val<::bevy_color::LinearRgba> = <::bevy_color::LinearRgba as ::core::ops::Sub< + ::bevy_color::LinearRgba, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output @@ -1054,10 +1032,10 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { ) .register_documented( "with_blue", - |_self: Val<::bevy_color::prelude::LinearRgba>, blue: f32| { - let output: Val<::bevy_color::prelude::LinearRgba> = { + |_self: Val<::bevy_color::LinearRgba>, blue: f32| { + let output: Val<::bevy_color::LinearRgba> = { { - let output: Val<::bevy_color::prelude::LinearRgba> = ::bevy_color::prelude::LinearRgba::with_blue( + let output: Val<::bevy_color::LinearRgba> = ::bevy_color::LinearRgba::with_blue( _self.into_inner(), blue, ) @@ -1072,10 +1050,10 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { ) .register_documented( "with_green", - |_self: Val<::bevy_color::prelude::LinearRgba>, green: f32| { - let output: Val<::bevy_color::prelude::LinearRgba> = { + |_self: Val<::bevy_color::LinearRgba>, green: f32| { + let output: Val<::bevy_color::LinearRgba> = { { - let output: Val<::bevy_color::prelude::LinearRgba> = ::bevy_color::prelude::LinearRgba::with_green( + let output: Val<::bevy_color::LinearRgba> = ::bevy_color::LinearRgba::with_green( _self.into_inner(), green, ) @@ -1090,10 +1068,10 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { ) .register_documented( "with_red", - |_self: Val<::bevy_color::prelude::LinearRgba>, red: f32| { - let output: Val<::bevy_color::prelude::LinearRgba> = { + |_self: Val<::bevy_color::LinearRgba>, red: f32| { + let output: Val<::bevy_color::LinearRgba> = { { - let output: Val<::bevy_color::prelude::LinearRgba> = ::bevy_color::prelude::LinearRgba::with_red( + let output: Val<::bevy_color::LinearRgba> = ::bevy_color::LinearRgba::with_red( _self.into_inner(), red, ) @@ -1110,20 +1088,20 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_color::prelude::LinearRgba, + ::bevy_color::LinearRgba, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_hsla_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_color::prelude::Hsla, + ::bevy_color::Hsla, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_color::prelude::Hsla>| { - let output: Val<::bevy_color::prelude::Hsla> = { + |_self: Ref<::bevy_color::Hsla>| { + let output: Val<::bevy_color::Hsla> = { { - let output: Val<::bevy_color::prelude::Hsla> = <::bevy_color::prelude::Hsla as ::core::clone::Clone>::clone( + let output: Val<::bevy_color::Hsla> = <::bevy_color::Hsla as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -1137,14 +1115,11 @@ pub(crate) fn register_hsla_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_color::prelude::Hsla>, - other: Ref<::bevy_color::prelude::Hsla>| - { + |_self: Ref<::bevy_color::Hsla>, other: Ref<::bevy_color::Hsla>| { let output: bool = { { - let output: bool = <::bevy_color::prelude::Hsla as ::core::cmp::PartialEq< - ::bevy_color::prelude::Hsla, + let output: bool = <::bevy_color::Hsla as ::core::cmp::PartialEq< + ::bevy_color::Hsla, >>::eq(&_self, &other) .into(); output @@ -1158,9 +1133,9 @@ pub(crate) fn register_hsla_functions(world: &mut World) { .register_documented( "hsl", |hue: f32, saturation: f32, lightness: f32| { - let output: Val<::bevy_color::prelude::Hsla> = { + let output: Val<::bevy_color::Hsla> = { { - let output: Val<::bevy_color::prelude::Hsla> = ::bevy_color::prelude::Hsla::hsl( + let output: Val<::bevy_color::Hsla> = ::bevy_color::Hsla::hsl( hue, saturation, lightness, @@ -1177,9 +1152,9 @@ pub(crate) fn register_hsla_functions(world: &mut World) { .register_documented( "new", |hue: f32, saturation: f32, lightness: f32, alpha: f32| { - let output: Val<::bevy_color::prelude::Hsla> = { + let output: Val<::bevy_color::Hsla> = { { - let output: Val<::bevy_color::prelude::Hsla> = ::bevy_color::prelude::Hsla::new( + let output: Val<::bevy_color::Hsla> = ::bevy_color::Hsla::new( hue, saturation, lightness, @@ -1197,9 +1172,9 @@ pub(crate) fn register_hsla_functions(world: &mut World) { .register_documented( "sequential_dispersed", |index: u32| { - let output: Val<::bevy_color::prelude::Hsla> = { + let output: Val<::bevy_color::Hsla> = { { - let output: Val<::bevy_color::prelude::Hsla> = ::bevy_color::prelude::Hsla::sequential_dispersed( + let output: Val<::bevy_color::Hsla> = ::bevy_color::Hsla::sequential_dispersed( index, ) .into(); @@ -1213,10 +1188,10 @@ pub(crate) fn register_hsla_functions(world: &mut World) { ) .register_documented( "with_lightness", - |_self: Val<::bevy_color::prelude::Hsla>, lightness: f32| { - let output: Val<::bevy_color::prelude::Hsla> = { + |_self: Val<::bevy_color::Hsla>, lightness: f32| { + let output: Val<::bevy_color::Hsla> = { { - let output: Val<::bevy_color::prelude::Hsla> = ::bevy_color::prelude::Hsla::with_lightness( + let output: Val<::bevy_color::Hsla> = ::bevy_color::Hsla::with_lightness( _self.into_inner(), lightness, ) @@ -1231,10 +1206,10 @@ pub(crate) fn register_hsla_functions(world: &mut World) { ) .register_documented( "with_saturation", - |_self: Val<::bevy_color::prelude::Hsla>, saturation: f32| { - let output: Val<::bevy_color::prelude::Hsla> = { + |_self: Val<::bevy_color::Hsla>, saturation: f32| { + let output: Val<::bevy_color::Hsla> = { { - let output: Val<::bevy_color::prelude::Hsla> = ::bevy_color::prelude::Hsla::with_saturation( + let output: Val<::bevy_color::Hsla> = ::bevy_color::Hsla::with_saturation( _self.into_inner(), saturation, ) @@ -1251,20 +1226,20 @@ pub(crate) fn register_hsla_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_color::prelude::Hsla, + ::bevy_color::Hsla, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_hsva_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_color::prelude::Hsva, + ::bevy_color::Hsva, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_color::prelude::Hsva>| { - let output: Val<::bevy_color::prelude::Hsva> = { + |_self: Ref<::bevy_color::Hsva>| { + let output: Val<::bevy_color::Hsva> = { { - let output: Val<::bevy_color::prelude::Hsva> = <::bevy_color::prelude::Hsva as ::core::clone::Clone>::clone( + let output: Val<::bevy_color::Hsva> = <::bevy_color::Hsva as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -1278,14 +1253,11 @@ pub(crate) fn register_hsva_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_color::prelude::Hsva>, - other: Ref<::bevy_color::prelude::Hsva>| - { + |_self: Ref<::bevy_color::Hsva>, other: Ref<::bevy_color::Hsva>| { let output: bool = { { - let output: bool = <::bevy_color::prelude::Hsva as ::core::cmp::PartialEq< - ::bevy_color::prelude::Hsva, + let output: bool = <::bevy_color::Hsva as ::core::cmp::PartialEq< + ::bevy_color::Hsva, >>::eq(&_self, &other) .into(); output @@ -1299,9 +1271,9 @@ pub(crate) fn register_hsva_functions(world: &mut World) { .register_documented( "hsv", |hue: f32, saturation: f32, value: f32| { - let output: Val<::bevy_color::prelude::Hsva> = { + let output: Val<::bevy_color::Hsva> = { { - let output: Val<::bevy_color::prelude::Hsva> = ::bevy_color::prelude::Hsva::hsv( + let output: Val<::bevy_color::Hsva> = ::bevy_color::Hsva::hsv( hue, saturation, value, @@ -1318,9 +1290,9 @@ pub(crate) fn register_hsva_functions(world: &mut World) { .register_documented( "new", |hue: f32, saturation: f32, value: f32, alpha: f32| { - let output: Val<::bevy_color::prelude::Hsva> = { + let output: Val<::bevy_color::Hsva> = { { - let output: Val<::bevy_color::prelude::Hsva> = ::bevy_color::prelude::Hsva::new( + let output: Val<::bevy_color::Hsva> = ::bevy_color::Hsva::new( hue, saturation, value, @@ -1337,10 +1309,10 @@ pub(crate) fn register_hsva_functions(world: &mut World) { ) .register_documented( "with_saturation", - |_self: Val<::bevy_color::prelude::Hsva>, saturation: f32| { - let output: Val<::bevy_color::prelude::Hsva> = { + |_self: Val<::bevy_color::Hsva>, saturation: f32| { + let output: Val<::bevy_color::Hsva> = { { - let output: Val<::bevy_color::prelude::Hsva> = ::bevy_color::prelude::Hsva::with_saturation( + let output: Val<::bevy_color::Hsva> = ::bevy_color::Hsva::with_saturation( _self.into_inner(), saturation, ) @@ -1355,10 +1327,10 @@ pub(crate) fn register_hsva_functions(world: &mut World) { ) .register_documented( "with_value", - |_self: Val<::bevy_color::prelude::Hsva>, value: f32| { - let output: Val<::bevy_color::prelude::Hsva> = { + |_self: Val<::bevy_color::Hsva>, value: f32| { + let output: Val<::bevy_color::Hsva> = { { - let output: Val<::bevy_color::prelude::Hsva> = ::bevy_color::prelude::Hsva::with_value( + let output: Val<::bevy_color::Hsva> = ::bevy_color::Hsva::with_value( _self.into_inner(), value, ) @@ -1375,20 +1347,20 @@ pub(crate) fn register_hsva_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_color::prelude::Hsva, + ::bevy_color::Hsva, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_hwba_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_color::prelude::Hwba, + ::bevy_color::Hwba, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_color::prelude::Hwba>| { - let output: Val<::bevy_color::prelude::Hwba> = { + |_self: Ref<::bevy_color::Hwba>| { + let output: Val<::bevy_color::Hwba> = { { - let output: Val<::bevy_color::prelude::Hwba> = <::bevy_color::prelude::Hwba as ::core::clone::Clone>::clone( + let output: Val<::bevy_color::Hwba> = <::bevy_color::Hwba as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -1402,14 +1374,11 @@ pub(crate) fn register_hwba_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_color::prelude::Hwba>, - other: Ref<::bevy_color::prelude::Hwba>| - { + |_self: Ref<::bevy_color::Hwba>, other: Ref<::bevy_color::Hwba>| { let output: bool = { { - let output: bool = <::bevy_color::prelude::Hwba as ::core::cmp::PartialEq< - ::bevy_color::prelude::Hwba, + let output: bool = <::bevy_color::Hwba as ::core::cmp::PartialEq< + ::bevy_color::Hwba, >>::eq(&_self, &other) .into(); output @@ -1423,9 +1392,9 @@ pub(crate) fn register_hwba_functions(world: &mut World) { .register_documented( "hwb", |hue: f32, whiteness: f32, blackness: f32| { - let output: Val<::bevy_color::prelude::Hwba> = { + let output: Val<::bevy_color::Hwba> = { { - let output: Val<::bevy_color::prelude::Hwba> = ::bevy_color::prelude::Hwba::hwb( + let output: Val<::bevy_color::Hwba> = ::bevy_color::Hwba::hwb( hue, whiteness, blackness, @@ -1442,9 +1411,9 @@ pub(crate) fn register_hwba_functions(world: &mut World) { .register_documented( "new", |hue: f32, whiteness: f32, blackness: f32, alpha: f32| { - let output: Val<::bevy_color::prelude::Hwba> = { + let output: Val<::bevy_color::Hwba> = { { - let output: Val<::bevy_color::prelude::Hwba> = ::bevy_color::prelude::Hwba::new( + let output: Val<::bevy_color::Hwba> = ::bevy_color::Hwba::new( hue, whiteness, blackness, @@ -1461,10 +1430,10 @@ pub(crate) fn register_hwba_functions(world: &mut World) { ) .register_documented( "with_blackness", - |_self: Val<::bevy_color::prelude::Hwba>, blackness: f32| { - let output: Val<::bevy_color::prelude::Hwba> = { + |_self: Val<::bevy_color::Hwba>, blackness: f32| { + let output: Val<::bevy_color::Hwba> = { { - let output: Val<::bevy_color::prelude::Hwba> = ::bevy_color::prelude::Hwba::with_blackness( + let output: Val<::bevy_color::Hwba> = ::bevy_color::Hwba::with_blackness( _self.into_inner(), blackness, ) @@ -1479,10 +1448,10 @@ pub(crate) fn register_hwba_functions(world: &mut World) { ) .register_documented( "with_whiteness", - |_self: Val<::bevy_color::prelude::Hwba>, whiteness: f32| { - let output: Val<::bevy_color::prelude::Hwba> = { + |_self: Val<::bevy_color::Hwba>, whiteness: f32| { + let output: Val<::bevy_color::Hwba> = { { - let output: Val<::bevy_color::prelude::Hwba> = ::bevy_color::prelude::Hwba::with_whiteness( + let output: Val<::bevy_color::Hwba> = ::bevy_color::Hwba::with_whiteness( _self.into_inner(), whiteness, ) @@ -1499,24 +1468,21 @@ pub(crate) fn register_hwba_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_color::prelude::Hwba, + ::bevy_color::Hwba, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_laba_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_color::prelude::Laba, + ::bevy_color::Laba, >::new(world) .register_documented( "add", - | - _self: Val<::bevy_color::prelude::Laba>, - rhs: Val<::bevy_color::prelude::Laba>| - { - let output: Val<::bevy_color::prelude::Laba> = { - { - let output: Val<::bevy_color::prelude::Laba> = <::bevy_color::prelude::Laba as ::core::ops::Add< - ::bevy_color::prelude::Laba, + |_self: Val<::bevy_color::Laba>, rhs: Val<::bevy_color::Laba>| { + let output: Val<::bevy_color::Laba> = { + { + let output: Val<::bevy_color::Laba> = <::bevy_color::Laba as ::core::ops::Add< + ::bevy_color::Laba, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output @@ -1529,10 +1495,10 @@ pub(crate) fn register_laba_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_color::prelude::Laba>| { - let output: Val<::bevy_color::prelude::Laba> = { + |_self: Ref<::bevy_color::Laba>| { + let output: Val<::bevy_color::Laba> = { { - let output: Val<::bevy_color::prelude::Laba> = <::bevy_color::prelude::Laba as ::core::clone::Clone>::clone( + let output: Val<::bevy_color::Laba> = <::bevy_color::Laba as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -1546,10 +1512,10 @@ pub(crate) fn register_laba_functions(world: &mut World) { ) .register_documented( "div", - |_self: Val<::bevy_color::prelude::Laba>, rhs: f32| { - let output: Val<::bevy_color::prelude::Laba> = { + |_self: Val<::bevy_color::Laba>, rhs: f32| { + let output: Val<::bevy_color::Laba> = { { - let output: Val<::bevy_color::prelude::Laba> = <::bevy_color::prelude::Laba as ::core::ops::Div< + let output: Val<::bevy_color::Laba> = <::bevy_color::Laba as ::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -1563,14 +1529,11 @@ pub(crate) fn register_laba_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_color::prelude::Laba>, - other: Ref<::bevy_color::prelude::Laba>| - { + |_self: Ref<::bevy_color::Laba>, other: Ref<::bevy_color::Laba>| { let output: bool = { { - let output: bool = <::bevy_color::prelude::Laba as ::core::cmp::PartialEq< - ::bevy_color::prelude::Laba, + let output: bool = <::bevy_color::Laba as ::core::cmp::PartialEq< + ::bevy_color::Laba, >>::eq(&_self, &other) .into(); output @@ -1584,9 +1547,9 @@ pub(crate) fn register_laba_functions(world: &mut World) { .register_documented( "lab", |lightness: f32, a: f32, b: f32| { - let output: Val<::bevy_color::prelude::Laba> = { + let output: Val<::bevy_color::Laba> = { { - let output: Val<::bevy_color::prelude::Laba> = ::bevy_color::prelude::Laba::lab( + let output: Val<::bevy_color::Laba> = ::bevy_color::Laba::lab( lightness, a, b, @@ -1602,10 +1565,10 @@ pub(crate) fn register_laba_functions(world: &mut World) { ) .register_documented( "mul", - |_self: Val<::bevy_color::prelude::Laba>, rhs: f32| { - let output: Val<::bevy_color::prelude::Laba> = { + |_self: Val<::bevy_color::Laba>, rhs: f32| { + let output: Val<::bevy_color::Laba> = { { - let output: Val<::bevy_color::prelude::Laba> = <::bevy_color::prelude::Laba as ::core::ops::Mul< + let output: Val<::bevy_color::Laba> = <::bevy_color::Laba as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -1619,10 +1582,10 @@ pub(crate) fn register_laba_functions(world: &mut World) { ) .register_documented( "neg", - |_self: Val<::bevy_color::prelude::Laba>| { - let output: Val<::bevy_color::prelude::Laba> = { + |_self: Val<::bevy_color::Laba>| { + let output: Val<::bevy_color::Laba> = { { - let output: Val<::bevy_color::prelude::Laba> = <::bevy_color::prelude::Laba as ::core::ops::Neg>::neg( + let output: Val<::bevy_color::Laba> = <::bevy_color::Laba as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -1637,9 +1600,9 @@ pub(crate) fn register_laba_functions(world: &mut World) { .register_documented( "new", |lightness: f32, a: f32, b: f32, alpha: f32| { - let output: Val<::bevy_color::prelude::Laba> = { + let output: Val<::bevy_color::Laba> = { { - let output: Val<::bevy_color::prelude::Laba> = ::bevy_color::prelude::Laba::new( + let output: Val<::bevy_color::Laba> = ::bevy_color::Laba::new( lightness, a, b, @@ -1656,14 +1619,11 @@ pub(crate) fn register_laba_functions(world: &mut World) { ) .register_documented( "sub", - | - _self: Val<::bevy_color::prelude::Laba>, - rhs: Val<::bevy_color::prelude::Laba>| - { - let output: Val<::bevy_color::prelude::Laba> = { - { - let output: Val<::bevy_color::prelude::Laba> = <::bevy_color::prelude::Laba as ::core::ops::Sub< - ::bevy_color::prelude::Laba, + |_self: Val<::bevy_color::Laba>, rhs: Val<::bevy_color::Laba>| { + let output: Val<::bevy_color::Laba> = { + { + let output: Val<::bevy_color::Laba> = <::bevy_color::Laba as ::core::ops::Sub< + ::bevy_color::Laba, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output @@ -1676,10 +1636,10 @@ pub(crate) fn register_laba_functions(world: &mut World) { ) .register_documented( "with_lightness", - |_self: Val<::bevy_color::prelude::Laba>, lightness: f32| { - let output: Val<::bevy_color::prelude::Laba> = { + |_self: Val<::bevy_color::Laba>, lightness: f32| { + let output: Val<::bevy_color::Laba> = { { - let output: Val<::bevy_color::prelude::Laba> = ::bevy_color::prelude::Laba::with_lightness( + let output: Val<::bevy_color::Laba> = ::bevy_color::Laba::with_lightness( _self.into_inner(), lightness, ) @@ -1696,20 +1656,20 @@ pub(crate) fn register_laba_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_color::prelude::Laba, + ::bevy_color::Laba, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_lcha_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_color::prelude::Lcha, + ::bevy_color::Lcha, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_color::prelude::Lcha>| { - let output: Val<::bevy_color::prelude::Lcha> = { + |_self: Ref<::bevy_color::Lcha>| { + let output: Val<::bevy_color::Lcha> = { { - let output: Val<::bevy_color::prelude::Lcha> = <::bevy_color::prelude::Lcha as ::core::clone::Clone>::clone( + let output: Val<::bevy_color::Lcha> = <::bevy_color::Lcha as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -1723,14 +1683,11 @@ pub(crate) fn register_lcha_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_color::prelude::Lcha>, - other: Ref<::bevy_color::prelude::Lcha>| - { + |_self: Ref<::bevy_color::Lcha>, other: Ref<::bevy_color::Lcha>| { let output: bool = { { - let output: bool = <::bevy_color::prelude::Lcha as ::core::cmp::PartialEq< - ::bevy_color::prelude::Lcha, + let output: bool = <::bevy_color::Lcha as ::core::cmp::PartialEq< + ::bevy_color::Lcha, >>::eq(&_self, &other) .into(); output @@ -1744,9 +1701,9 @@ pub(crate) fn register_lcha_functions(world: &mut World) { .register_documented( "lch", |lightness: f32, chroma: f32, hue: f32| { - let output: Val<::bevy_color::prelude::Lcha> = { + let output: Val<::bevy_color::Lcha> = { { - let output: Val<::bevy_color::prelude::Lcha> = ::bevy_color::prelude::Lcha::lch( + let output: Val<::bevy_color::Lcha> = ::bevy_color::Lcha::lch( lightness, chroma, hue, @@ -1763,9 +1720,9 @@ pub(crate) fn register_lcha_functions(world: &mut World) { .register_documented( "new", |lightness: f32, chroma: f32, hue: f32, alpha: f32| { - let output: Val<::bevy_color::prelude::Lcha> = { + let output: Val<::bevy_color::Lcha> = { { - let output: Val<::bevy_color::prelude::Lcha> = ::bevy_color::prelude::Lcha::new( + let output: Val<::bevy_color::Lcha> = ::bevy_color::Lcha::new( lightness, chroma, hue, @@ -1783,9 +1740,9 @@ pub(crate) fn register_lcha_functions(world: &mut World) { .register_documented( "sequential_dispersed", |index: u32| { - let output: Val<::bevy_color::prelude::Lcha> = { + let output: Val<::bevy_color::Lcha> = { { - let output: Val<::bevy_color::prelude::Lcha> = ::bevy_color::prelude::Lcha::sequential_dispersed( + let output: Val<::bevy_color::Lcha> = ::bevy_color::Lcha::sequential_dispersed( index, ) .into(); @@ -1799,10 +1756,10 @@ pub(crate) fn register_lcha_functions(world: &mut World) { ) .register_documented( "with_chroma", - |_self: Val<::bevy_color::prelude::Lcha>, chroma: f32| { - let output: Val<::bevy_color::prelude::Lcha> = { + |_self: Val<::bevy_color::Lcha>, chroma: f32| { + let output: Val<::bevy_color::Lcha> = { { - let output: Val<::bevy_color::prelude::Lcha> = ::bevy_color::prelude::Lcha::with_chroma( + let output: Val<::bevy_color::Lcha> = ::bevy_color::Lcha::with_chroma( _self.into_inner(), chroma, ) @@ -1817,10 +1774,10 @@ pub(crate) fn register_lcha_functions(world: &mut World) { ) .register_documented( "with_lightness", - |_self: Val<::bevy_color::prelude::Lcha>, lightness: f32| { - let output: Val<::bevy_color::prelude::Lcha> = { + |_self: Val<::bevy_color::Lcha>, lightness: f32| { + let output: Val<::bevy_color::Lcha> = { { - let output: Val<::bevy_color::prelude::Lcha> = ::bevy_color::prelude::Lcha::with_lightness( + let output: Val<::bevy_color::Lcha> = ::bevy_color::Lcha::with_lightness( _self.into_inner(), lightness, ) @@ -1837,24 +1794,21 @@ pub(crate) fn register_lcha_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_color::prelude::Lcha, + ::bevy_color::Lcha, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_oklaba_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_color::prelude::Oklaba, + ::bevy_color::Oklaba, >::new(world) .register_documented( "add", - | - _self: Val<::bevy_color::prelude::Oklaba>, - rhs: Val<::bevy_color::prelude::Oklaba>| - { - let output: Val<::bevy_color::prelude::Oklaba> = { - { - let output: Val<::bevy_color::prelude::Oklaba> = <::bevy_color::prelude::Oklaba as ::core::ops::Add< - ::bevy_color::prelude::Oklaba, + |_self: Val<::bevy_color::Oklaba>, rhs: Val<::bevy_color::Oklaba>| { + let output: Val<::bevy_color::Oklaba> = { + { + let output: Val<::bevy_color::Oklaba> = <::bevy_color::Oklaba as ::core::ops::Add< + ::bevy_color::Oklaba, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output @@ -1867,10 +1821,10 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_color::prelude::Oklaba>| { - let output: Val<::bevy_color::prelude::Oklaba> = { + |_self: Ref<::bevy_color::Oklaba>| { + let output: Val<::bevy_color::Oklaba> = { { - let output: Val<::bevy_color::prelude::Oklaba> = <::bevy_color::prelude::Oklaba as ::core::clone::Clone>::clone( + let output: Val<::bevy_color::Oklaba> = <::bevy_color::Oklaba as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -1884,10 +1838,10 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { ) .register_documented( "div", - |_self: Val<::bevy_color::prelude::Oklaba>, rhs: f32| { - let output: Val<::bevy_color::prelude::Oklaba> = { + |_self: Val<::bevy_color::Oklaba>, rhs: f32| { + let output: Val<::bevy_color::Oklaba> = { { - let output: Val<::bevy_color::prelude::Oklaba> = <::bevy_color::prelude::Oklaba as ::core::ops::Div< + let output: Val<::bevy_color::Oklaba> = <::bevy_color::Oklaba as ::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -1901,14 +1855,11 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_color::prelude::Oklaba>, - other: Ref<::bevy_color::prelude::Oklaba>| - { + |_self: Ref<::bevy_color::Oklaba>, other: Ref<::bevy_color::Oklaba>| { let output: bool = { { - let output: bool = <::bevy_color::prelude::Oklaba as ::core::cmp::PartialEq< - ::bevy_color::prelude::Oklaba, + let output: bool = <::bevy_color::Oklaba as ::core::cmp::PartialEq< + ::bevy_color::Oklaba, >>::eq(&_self, &other) .into(); output @@ -1922,9 +1873,9 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { .register_documented( "lab", |lightness: f32, a: f32, b: f32| { - let output: Val<::bevy_color::prelude::Oklaba> = { + let output: Val<::bevy_color::Oklaba> = { { - let output: Val<::bevy_color::prelude::Oklaba> = ::bevy_color::prelude::Oklaba::lab( + let output: Val<::bevy_color::Oklaba> = ::bevy_color::Oklaba::lab( lightness, a, b, @@ -1940,10 +1891,10 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { ) .register_documented( "mul", - |_self: Val<::bevy_color::prelude::Oklaba>, rhs: f32| { - let output: Val<::bevy_color::prelude::Oklaba> = { + |_self: Val<::bevy_color::Oklaba>, rhs: f32| { + let output: Val<::bevy_color::Oklaba> = { { - let output: Val<::bevy_color::prelude::Oklaba> = <::bevy_color::prelude::Oklaba as ::core::ops::Mul< + let output: Val<::bevy_color::Oklaba> = <::bevy_color::Oklaba as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -1957,10 +1908,10 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { ) .register_documented( "neg", - |_self: Val<::bevy_color::prelude::Oklaba>| { - let output: Val<::bevy_color::prelude::Oklaba> = { + |_self: Val<::bevy_color::Oklaba>| { + let output: Val<::bevy_color::Oklaba> = { { - let output: Val<::bevy_color::prelude::Oklaba> = <::bevy_color::prelude::Oklaba as ::core::ops::Neg>::neg( + let output: Val<::bevy_color::Oklaba> = <::bevy_color::Oklaba as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -1975,9 +1926,9 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { .register_documented( "new", |lightness: f32, a: f32, b: f32, alpha: f32| { - let output: Val<::bevy_color::prelude::Oklaba> = { + let output: Val<::bevy_color::Oklaba> = { { - let output: Val<::bevy_color::prelude::Oklaba> = ::bevy_color::prelude::Oklaba::new( + let output: Val<::bevy_color::Oklaba> = ::bevy_color::Oklaba::new( lightness, a, b, @@ -1994,14 +1945,11 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { ) .register_documented( "sub", - | - _self: Val<::bevy_color::prelude::Oklaba>, - rhs: Val<::bevy_color::prelude::Oklaba>| - { - let output: Val<::bevy_color::prelude::Oklaba> = { - { - let output: Val<::bevy_color::prelude::Oklaba> = <::bevy_color::prelude::Oklaba as ::core::ops::Sub< - ::bevy_color::prelude::Oklaba, + |_self: Val<::bevy_color::Oklaba>, rhs: Val<::bevy_color::Oklaba>| { + let output: Val<::bevy_color::Oklaba> = { + { + let output: Val<::bevy_color::Oklaba> = <::bevy_color::Oklaba as ::core::ops::Sub< + ::bevy_color::Oklaba, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output @@ -2014,10 +1962,10 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { ) .register_documented( "with_a", - |_self: Val<::bevy_color::prelude::Oklaba>, a: f32| { - let output: Val<::bevy_color::prelude::Oklaba> = { + |_self: Val<::bevy_color::Oklaba>, a: f32| { + let output: Val<::bevy_color::Oklaba> = { { - let output: Val<::bevy_color::prelude::Oklaba> = ::bevy_color::prelude::Oklaba::with_a( + let output: Val<::bevy_color::Oklaba> = ::bevy_color::Oklaba::with_a( _self.into_inner(), a, ) @@ -2032,10 +1980,10 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { ) .register_documented( "with_b", - |_self: Val<::bevy_color::prelude::Oklaba>, b: f32| { - let output: Val<::bevy_color::prelude::Oklaba> = { + |_self: Val<::bevy_color::Oklaba>, b: f32| { + let output: Val<::bevy_color::Oklaba> = { { - let output: Val<::bevy_color::prelude::Oklaba> = ::bevy_color::prelude::Oklaba::with_b( + let output: Val<::bevy_color::Oklaba> = ::bevy_color::Oklaba::with_b( _self.into_inner(), b, ) @@ -2050,10 +1998,10 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { ) .register_documented( "with_lightness", - |_self: Val<::bevy_color::prelude::Oklaba>, lightness: f32| { - let output: Val<::bevy_color::prelude::Oklaba> = { + |_self: Val<::bevy_color::Oklaba>, lightness: f32| { + let output: Val<::bevy_color::Oklaba> = { { - let output: Val<::bevy_color::prelude::Oklaba> = ::bevy_color::prelude::Oklaba::with_lightness( + let output: Val<::bevy_color::Oklaba> = ::bevy_color::Oklaba::with_lightness( _self.into_inner(), lightness, ) @@ -2070,20 +2018,20 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_color::prelude::Oklaba, + ::bevy_color::Oklaba, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_oklcha_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_color::prelude::Oklcha, + ::bevy_color::Oklcha, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_color::prelude::Oklcha>| { - let output: Val<::bevy_color::prelude::Oklcha> = { + |_self: Ref<::bevy_color::Oklcha>| { + let output: Val<::bevy_color::Oklcha> = { { - let output: Val<::bevy_color::prelude::Oklcha> = <::bevy_color::prelude::Oklcha as ::core::clone::Clone>::clone( + let output: Val<::bevy_color::Oklcha> = <::bevy_color::Oklcha as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -2097,14 +2045,11 @@ pub(crate) fn register_oklcha_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_color::prelude::Oklcha>, - other: Ref<::bevy_color::prelude::Oklcha>| - { + |_self: Ref<::bevy_color::Oklcha>, other: Ref<::bevy_color::Oklcha>| { let output: bool = { { - let output: bool = <::bevy_color::prelude::Oklcha as ::core::cmp::PartialEq< - ::bevy_color::prelude::Oklcha, + let output: bool = <::bevy_color::Oklcha as ::core::cmp::PartialEq< + ::bevy_color::Oklcha, >>::eq(&_self, &other) .into(); output @@ -2118,9 +2063,9 @@ pub(crate) fn register_oklcha_functions(world: &mut World) { .register_documented( "lch", |lightness: f32, chroma: f32, hue: f32| { - let output: Val<::bevy_color::prelude::Oklcha> = { + let output: Val<::bevy_color::Oklcha> = { { - let output: Val<::bevy_color::prelude::Oklcha> = ::bevy_color::prelude::Oklcha::lch( + let output: Val<::bevy_color::Oklcha> = ::bevy_color::Oklcha::lch( lightness, chroma, hue, @@ -2137,9 +2082,9 @@ pub(crate) fn register_oklcha_functions(world: &mut World) { .register_documented( "new", |lightness: f32, chroma: f32, hue: f32, alpha: f32| { - let output: Val<::bevy_color::prelude::Oklcha> = { + let output: Val<::bevy_color::Oklcha> = { { - let output: Val<::bevy_color::prelude::Oklcha> = ::bevy_color::prelude::Oklcha::new( + let output: Val<::bevy_color::Oklcha> = ::bevy_color::Oklcha::new( lightness, chroma, hue, @@ -2157,9 +2102,9 @@ pub(crate) fn register_oklcha_functions(world: &mut World) { .register_documented( "sequential_dispersed", |index: u32| { - let output: Val<::bevy_color::prelude::Oklcha> = { + let output: Val<::bevy_color::Oklcha> = { { - let output: Val<::bevy_color::prelude::Oklcha> = ::bevy_color::prelude::Oklcha::sequential_dispersed( + let output: Val<::bevy_color::Oklcha> = ::bevy_color::Oklcha::sequential_dispersed( index, ) .into(); @@ -2173,10 +2118,10 @@ pub(crate) fn register_oklcha_functions(world: &mut World) { ) .register_documented( "with_chroma", - |_self: Val<::bevy_color::prelude::Oklcha>, chroma: f32| { - let output: Val<::bevy_color::prelude::Oklcha> = { + |_self: Val<::bevy_color::Oklcha>, chroma: f32| { + let output: Val<::bevy_color::Oklcha> = { { - let output: Val<::bevy_color::prelude::Oklcha> = ::bevy_color::prelude::Oklcha::with_chroma( + let output: Val<::bevy_color::Oklcha> = ::bevy_color::Oklcha::with_chroma( _self.into_inner(), chroma, ) @@ -2191,10 +2136,10 @@ pub(crate) fn register_oklcha_functions(world: &mut World) { ) .register_documented( "with_lightness", - |_self: Val<::bevy_color::prelude::Oklcha>, lightness: f32| { - let output: Val<::bevy_color::prelude::Oklcha> = { + |_self: Val<::bevy_color::Oklcha>, lightness: f32| { + let output: Val<::bevy_color::Oklcha> = { { - let output: Val<::bevy_color::prelude::Oklcha> = ::bevy_color::prelude::Oklcha::with_lightness( + let output: Val<::bevy_color::Oklcha> = ::bevy_color::Oklcha::with_lightness( _self.into_inner(), lightness, ) @@ -2211,24 +2156,21 @@ pub(crate) fn register_oklcha_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_color::prelude::Oklcha, + ::bevy_color::Oklcha, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_xyza_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_color::prelude::Xyza, + ::bevy_color::Xyza, >::new(world) .register_documented( "add", - | - _self: Val<::bevy_color::prelude::Xyza>, - rhs: Val<::bevy_color::prelude::Xyza>| - { - let output: Val<::bevy_color::prelude::Xyza> = { - { - let output: Val<::bevy_color::prelude::Xyza> = <::bevy_color::prelude::Xyza as ::core::ops::Add< - ::bevy_color::prelude::Xyza, + |_self: Val<::bevy_color::Xyza>, rhs: Val<::bevy_color::Xyza>| { + let output: Val<::bevy_color::Xyza> = { + { + let output: Val<::bevy_color::Xyza> = <::bevy_color::Xyza as ::core::ops::Add< + ::bevy_color::Xyza, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output @@ -2241,10 +2183,10 @@ pub(crate) fn register_xyza_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_color::prelude::Xyza>| { - let output: Val<::bevy_color::prelude::Xyza> = { + |_self: Ref<::bevy_color::Xyza>| { + let output: Val<::bevy_color::Xyza> = { { - let output: Val<::bevy_color::prelude::Xyza> = <::bevy_color::prelude::Xyza as ::core::clone::Clone>::clone( + let output: Val<::bevy_color::Xyza> = <::bevy_color::Xyza as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -2258,10 +2200,10 @@ pub(crate) fn register_xyza_functions(world: &mut World) { ) .register_documented( "div", - |_self: Val<::bevy_color::prelude::Xyza>, rhs: f32| { - let output: Val<::bevy_color::prelude::Xyza> = { + |_self: Val<::bevy_color::Xyza>, rhs: f32| { + let output: Val<::bevy_color::Xyza> = { { - let output: Val<::bevy_color::prelude::Xyza> = <::bevy_color::prelude::Xyza as ::core::ops::Div< + let output: Val<::bevy_color::Xyza> = <::bevy_color::Xyza as ::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -2275,14 +2217,11 @@ pub(crate) fn register_xyza_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_color::prelude::Xyza>, - other: Ref<::bevy_color::prelude::Xyza>| - { + |_self: Ref<::bevy_color::Xyza>, other: Ref<::bevy_color::Xyza>| { let output: bool = { { - let output: bool = <::bevy_color::prelude::Xyza as ::core::cmp::PartialEq< - ::bevy_color::prelude::Xyza, + let output: bool = <::bevy_color::Xyza as ::core::cmp::PartialEq< + ::bevy_color::Xyza, >>::eq(&_self, &other) .into(); output @@ -2295,10 +2234,10 @@ pub(crate) fn register_xyza_functions(world: &mut World) { ) .register_documented( "mul", - |_self: Val<::bevy_color::prelude::Xyza>, rhs: f32| { - let output: Val<::bevy_color::prelude::Xyza> = { + |_self: Val<::bevy_color::Xyza>, rhs: f32| { + let output: Val<::bevy_color::Xyza> = { { - let output: Val<::bevy_color::prelude::Xyza> = <::bevy_color::prelude::Xyza as ::core::ops::Mul< + let output: Val<::bevy_color::Xyza> = <::bevy_color::Xyza as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -2312,10 +2251,10 @@ pub(crate) fn register_xyza_functions(world: &mut World) { ) .register_documented( "neg", - |_self: Val<::bevy_color::prelude::Xyza>| { - let output: Val<::bevy_color::prelude::Xyza> = { + |_self: Val<::bevy_color::Xyza>| { + let output: Val<::bevy_color::Xyza> = { { - let output: Val<::bevy_color::prelude::Xyza> = <::bevy_color::prelude::Xyza as ::core::ops::Neg>::neg( + let output: Val<::bevy_color::Xyza> = <::bevy_color::Xyza as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -2330,9 +2269,9 @@ pub(crate) fn register_xyza_functions(world: &mut World) { .register_documented( "new", |x: f32, y: f32, z: f32, alpha: f32| { - let output: Val<::bevy_color::prelude::Xyza> = { + let output: Val<::bevy_color::Xyza> = { { - let output: Val<::bevy_color::prelude::Xyza> = ::bevy_color::prelude::Xyza::new( + let output: Val<::bevy_color::Xyza> = ::bevy_color::Xyza::new( x, y, z, @@ -2349,14 +2288,11 @@ pub(crate) fn register_xyza_functions(world: &mut World) { ) .register_documented( "sub", - | - _self: Val<::bevy_color::prelude::Xyza>, - rhs: Val<::bevy_color::prelude::Xyza>| - { - let output: Val<::bevy_color::prelude::Xyza> = { - { - let output: Val<::bevy_color::prelude::Xyza> = <::bevy_color::prelude::Xyza as ::core::ops::Sub< - ::bevy_color::prelude::Xyza, + |_self: Val<::bevy_color::Xyza>, rhs: Val<::bevy_color::Xyza>| { + let output: Val<::bevy_color::Xyza> = { + { + let output: Val<::bevy_color::Xyza> = <::bevy_color::Xyza as ::core::ops::Sub< + ::bevy_color::Xyza, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output @@ -2369,10 +2305,10 @@ pub(crate) fn register_xyza_functions(world: &mut World) { ) .register_documented( "with_x", - |_self: Val<::bevy_color::prelude::Xyza>, x: f32| { - let output: Val<::bevy_color::prelude::Xyza> = { + |_self: Val<::bevy_color::Xyza>, x: f32| { + let output: Val<::bevy_color::Xyza> = { { - let output: Val<::bevy_color::prelude::Xyza> = ::bevy_color::prelude::Xyza::with_x( + let output: Val<::bevy_color::Xyza> = ::bevy_color::Xyza::with_x( _self.into_inner(), x, ) @@ -2387,10 +2323,10 @@ pub(crate) fn register_xyza_functions(world: &mut World) { ) .register_documented( "with_y", - |_self: Val<::bevy_color::prelude::Xyza>, y: f32| { - let output: Val<::bevy_color::prelude::Xyza> = { + |_self: Val<::bevy_color::Xyza>, y: f32| { + let output: Val<::bevy_color::Xyza> = { { - let output: Val<::bevy_color::prelude::Xyza> = ::bevy_color::prelude::Xyza::with_y( + let output: Val<::bevy_color::Xyza> = ::bevy_color::Xyza::with_y( _self.into_inner(), y, ) @@ -2405,10 +2341,10 @@ pub(crate) fn register_xyza_functions(world: &mut World) { ) .register_documented( "with_z", - |_self: Val<::bevy_color::prelude::Xyza>, z: f32| { - let output: Val<::bevy_color::prelude::Xyza> = { + |_self: Val<::bevy_color::Xyza>, z: f32| { + let output: Val<::bevy_color::Xyza> = { { - let output: Val<::bevy_color::prelude::Xyza> = ::bevy_color::prelude::Xyza::with_z( + let output: Val<::bevy_color::Xyza> = ::bevy_color::Xyza::with_z( _self.into_inner(), z, ) @@ -2424,9 +2360,9 @@ pub(crate) fn register_xyza_functions(world: &mut World) { .register_documented( "xyz", |x: f32, y: f32, z: f32| { - let output: Val<::bevy_color::prelude::Xyza> = { + let output: Val<::bevy_color::Xyza> = { { - let output: Val<::bevy_color::prelude::Xyza> = ::bevy_color::prelude::Xyza::xyz( + let output: Val<::bevy_color::Xyza> = ::bevy_color::Xyza::xyz( x, y, z, @@ -2444,7 +2380,7 @@ pub(crate) fn register_xyza_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_color::prelude::Xyza, + ::bevy_color::Xyza, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } diff --git a/crates/bindings/bevy_core_pipeline_bms_bindings/src/lib.rs b/crates/bindings/bevy_core_pipeline_bms_bindings/src/lib.rs index 7e0b870b04..b554da9d4d 100644 --- a/crates/bindings/bevy_core_pipeline_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_core_pipeline_bms_bindings/src/lib.rs @@ -1,36 +1,41 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyCorePipelineScriptingPlugin; pub(crate) fn register_skybox_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_core_pipeline::Skybox, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_core_pipeline::Skybox>| { - let output: Val<::bevy_core_pipeline::Skybox> = { - { - let output: Val<::bevy_core_pipeline::Skybox> = - <::bevy_core_pipeline::Skybox as ::std::clone::Clone>::clone(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_core_pipeline::Skybox>| { + let output: Val<::bevy_core_pipeline::Skybox> = { + { + let output: Val<::bevy_core_pipeline::Skybox> = <::bevy_core_pipeline::Skybox as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -293,7 +298,9 @@ pub(crate) fn register_normal_prepass_functions(world: &mut World) { bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_order_independent_transparency_settings_functions(world: &mut World) { +pub(crate) fn register_order_independent_transparency_settings_functions( + world: &mut World, +) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_core_pipeline::oit::OrderIndependentTransparencySettings, >::new(world) diff --git a/crates/bindings/bevy_ecs_bms_bindings/src/lib.rs b/crates/bindings/bevy_ecs_bms_bindings/src/lib.rs index 631ec06ac8..54b59c65d9 100644 --- a/crates/bindings/bevy_ecs_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_ecs_bms_bindings/src/lib.rs @@ -1,15 +1,18 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyEcsScriptingPlugin; pub(crate) fn register_entity_functions(world: &mut World) { @@ -372,22 +375,23 @@ pub(crate) fn register_despawn_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_ecs::lifecycle::Despawn, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ecs::lifecycle::Despawn>| { - let output: Val<::bevy_ecs::lifecycle::Despawn> = { - { - let output: Val<::bevy_ecs::lifecycle::Despawn> = - <::bevy_ecs::lifecycle::Despawn as ::core::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_ecs::lifecycle::Despawn>| { + let output: Val<::bevy_ecs::lifecycle::Despawn> = { + { + let output: Val<::bevy_ecs::lifecycle::Despawn> = <::bevy_ecs::lifecycle::Despawn as ::core::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -400,22 +404,23 @@ pub(crate) fn register_insert_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_ecs::lifecycle::Insert, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ecs::lifecycle::Insert>| { - let output: Val<::bevy_ecs::lifecycle::Insert> = { - { - let output: Val<::bevy_ecs::lifecycle::Insert> = - <::bevy_ecs::lifecycle::Insert as ::core::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_ecs::lifecycle::Insert>| { + let output: Val<::bevy_ecs::lifecycle::Insert> = { + { + let output: Val<::bevy_ecs::lifecycle::Insert> = <::bevy_ecs::lifecycle::Insert as ::core::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -428,22 +433,23 @@ pub(crate) fn register_remove_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_ecs::lifecycle::Remove, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ecs::lifecycle::Remove>| { - let output: Val<::bevy_ecs::lifecycle::Remove> = { - { - let output: Val<::bevy_ecs::lifecycle::Remove> = - <::bevy_ecs::lifecycle::Remove as ::core::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_ecs::lifecycle::Remove>| { + let output: Val<::bevy_ecs::lifecycle::Remove> = { + { + let output: Val<::bevy_ecs::lifecycle::Remove> = <::bevy_ecs::lifecycle::Remove as ::core::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -456,22 +462,23 @@ pub(crate) fn register_replace_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_ecs::lifecycle::Replace, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ecs::lifecycle::Replace>| { - let output: Val<::bevy_ecs::lifecycle::Replace> = { - { - let output: Val<::bevy_ecs::lifecycle::Replace> = - <::bevy_ecs::lifecycle::Replace as ::core::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_ecs::lifecycle::Replace>| { + let output: Val<::bevy_ecs::lifecycle::Replace> = { + { + let output: Val<::bevy_ecs::lifecycle::Replace> = <::bevy_ecs::lifecycle::Replace as ::core::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -521,8 +528,10 @@ pub(crate) fn register_name_functions(world: &mut World) { let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::bevy_ecs::name::Name, bevy_mod_scripting_bindings::MarkAsGenerated>( - ); + .register_type_data::< + ::bevy_ecs::name::Name, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_default_query_filters_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -930,14 +939,14 @@ pub(crate) fn register_component_ticks_functions(world: &mut World) { } pub(crate) fn register_entity_hash_set_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ecs::entity::hash_set::EntityHashSet, + ::bevy_ecs::entity::EntityHashSet, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ecs::entity::hash_set::EntityHashSet>| { + |_self: Ref<::bevy_ecs::entity::EntityHashSet>| { let output: () = { { - let output: () = <::bevy_ecs::entity::hash_set::EntityHashSet as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_ecs::entity::EntityHashSet as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -951,10 +960,10 @@ pub(crate) fn register_entity_hash_set_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ecs::entity::hash_set::EntityHashSet>| { - let output: Val<::bevy_ecs::entity::hash_set::EntityHashSet> = { + |_self: Ref<::bevy_ecs::entity::EntityHashSet>| { + let output: Val<::bevy_ecs::entity::EntityHashSet> = { { - let output: Val<::bevy_ecs::entity::hash_set::EntityHashSet> = <::bevy_ecs::entity::hash_set::EntityHashSet as ::core::clone::Clone>::clone( + let output: Val<::bevy_ecs::entity::EntityHashSet> = <::bevy_ecs::entity::EntityHashSet as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -969,13 +978,13 @@ pub(crate) fn register_entity_hash_set_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_ecs::entity::hash_set::EntityHashSet>, - other: Ref<::bevy_ecs::entity::hash_set::EntityHashSet>| + _self: Ref<::bevy_ecs::entity::EntityHashSet>, + other: Ref<::bevy_ecs::entity::EntityHashSet>| { let output: bool = { { - let output: bool = <::bevy_ecs::entity::hash_set::EntityHashSet as ::core::cmp::PartialEq< - ::bevy_ecs::entity::hash_set::EntityHashSet, + let output: bool = <::bevy_ecs::entity::EntityHashSet as ::core::cmp::PartialEq< + ::bevy_ecs::entity::EntityHashSet, >>::eq(&_self, &other) .into(); output @@ -988,10 +997,10 @@ pub(crate) fn register_entity_hash_set_functions(world: &mut World) { ) .register_documented( "is_empty", - |_self: Ref<::bevy_ecs::entity::hash_set::EntityHashSet>| { + |_self: Ref<::bevy_ecs::entity::EntityHashSet>| { let output: bool = { { - let output: bool = ::bevy_ecs::entity::hash_set::EntityHashSet::is_empty( + let output: bool = ::bevy_ecs::entity::EntityHashSet::is_empty( &_self, ) .into(); @@ -1005,10 +1014,10 @@ pub(crate) fn register_entity_hash_set_functions(world: &mut World) { ) .register_documented( "len", - |_self: Ref<::bevy_ecs::entity::hash_set::EntityHashSet>| { + |_self: Ref<::bevy_ecs::entity::EntityHashSet>| { let output: usize = { { - let output: usize = ::bevy_ecs::entity::hash_set::EntityHashSet::len( + let output: usize = ::bevy_ecs::entity::EntityHashSet::len( &_self, ) .into(); @@ -1023,9 +1032,9 @@ pub(crate) fn register_entity_hash_set_functions(world: &mut World) { .register_documented( "new", || { - let output: Val<::bevy_ecs::entity::hash_set::EntityHashSet> = { + let output: Val<::bevy_ecs::entity::EntityHashSet> = { { - let output: Val<::bevy_ecs::entity::hash_set::EntityHashSet> = ::bevy_ecs::entity::hash_set::EntityHashSet::new() + let output: Val<::bevy_ecs::entity::EntityHashSet> = ::bevy_ecs::entity::EntityHashSet::new() .into(); output } @@ -1038,9 +1047,9 @@ pub(crate) fn register_entity_hash_set_functions(world: &mut World) { .register_documented( "with_capacity", |n: usize| { - let output: Val<::bevy_ecs::entity::hash_set::EntityHashSet> = { + let output: Val<::bevy_ecs::entity::EntityHashSet> = { { - let output: Val<::bevy_ecs::entity::hash_set::EntityHashSet> = ::bevy_ecs::entity::hash_set::EntityHashSet::with_capacity( + let output: Val<::bevy_ecs::entity::EntityHashSet> = ::bevy_ecs::entity::EntityHashSet::with_capacity( n, ) .into(); @@ -1056,7 +1065,7 @@ pub(crate) fn register_entity_hash_set_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ecs::entity::hash_set::EntityHashSet, + ::bevy_ecs::entity::EntityHashSet, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -1265,22 +1274,23 @@ pub(crate) fn register_entity_hash_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_ecs::entity::EntityHash, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ecs::entity::EntityHash>| { - let output: Val<::bevy_ecs::entity::EntityHash> = { - { - let output: Val<::bevy_ecs::entity::EntityHash> = - <::bevy_ecs::entity::EntityHash as ::core::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_ecs::entity::EntityHash>| { + let output: Val<::bevy_ecs::entity::EntityHash> = { + { + let output: Val<::bevy_ecs::entity::EntityHash> = <::bevy_ecs::entity::EntityHash as ::core::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1293,24 +1303,23 @@ pub(crate) fn register_disabled_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_ecs::entity_disabling::Disabled, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ecs::entity_disabling::Disabled>| { - let output: Val<::bevy_ecs::entity_disabling::Disabled> = { - { - let output: Val<::bevy_ecs::entity_disabling::Disabled> = - <::bevy_ecs::entity_disabling::Disabled as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_ecs::entity_disabling::Disabled>| { + let output: Val<::bevy_ecs::entity_disabling::Disabled> = { + { + let output: Val<::bevy_ecs::entity_disabling::Disabled> = <::bevy_ecs::entity_disabling::Disabled as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1323,24 +1332,23 @@ pub(crate) fn register_internal_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_ecs::entity_disabling::Internal, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ecs::entity_disabling::Internal>| { - let output: Val<::bevy_ecs::entity_disabling::Internal> = { - { - let output: Val<::bevy_ecs::entity_disabling::Internal> = - <::bevy_ecs::entity_disabling::Internal as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_ecs::entity_disabling::Internal>| { + let output: Val<::bevy_ecs::entity_disabling::Internal> = { + { + let output: Val<::bevy_ecs::entity_disabling::Internal> = <::bevy_ecs::entity_disabling::Internal as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry diff --git a/crates/bindings/bevy_gizmos_bms_bindings/src/lib.rs b/crates/bindings/bevy_gizmos_bms_bindings/src/lib.rs index 4d5f5056f4..b56509a878 100644 --- a/crates/bindings/bevy_gizmos_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_gizmos_bms_bindings/src/lib.rs @@ -1,39 +1,41 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyGizmosScriptingPlugin; pub(crate) fn register_aabb_gizmo_config_group_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_gizmos::aabb::AabbGizmoConfigGroup, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_gizmos::aabb::AabbGizmoConfigGroup>| { - let output: Val<::bevy_gizmos::aabb::AabbGizmoConfigGroup> = { - { - let output: Val<::bevy_gizmos::aabb::AabbGizmoConfigGroup> = - <::bevy_gizmos::aabb::AabbGizmoConfigGroup as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_gizmos::aabb::AabbGizmoConfigGroup>| { + let output: Val<::bevy_gizmos::aabb::AabbGizmoConfigGroup> = { + { + let output: Val<::bevy_gizmos::aabb::AabbGizmoConfigGroup> = <::bevy_gizmos::aabb::AabbGizmoConfigGroup as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -70,22 +72,23 @@ pub(crate) fn register_gizmo_config_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_gizmos::config::GizmoConfig, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_gizmos::config::GizmoConfig>| { - let output: Val<::bevy_gizmos::config::GizmoConfig> = { - { - let output: Val<::bevy_gizmos::config::GizmoConfig> = - <::bevy_gizmos::config::GizmoConfig as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_gizmos::config::GizmoConfig>| { + let output: Val<::bevy_gizmos::config::GizmoConfig> = { + { + let output: Val<::bevy_gizmos::config::GizmoConfig> = <::bevy_gizmos::config::GizmoConfig as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -110,24 +113,23 @@ pub(crate) fn register_gizmo_line_config_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_gizmos::config::GizmoLineConfig, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_gizmos::config::GizmoLineConfig>| { - let output: Val<::bevy_gizmos::config::GizmoLineConfig> = { - { - let output: Val<::bevy_gizmos::config::GizmoLineConfig> = - <::bevy_gizmos::config::GizmoLineConfig as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_gizmos::config::GizmoLineConfig>| { + let output: Val<::bevy_gizmos::config::GizmoLineConfig> = { + { + let output: Val<::bevy_gizmos::config::GizmoLineConfig> = <::bevy_gizmos::config::GizmoLineConfig as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -206,43 +208,43 @@ pub(crate) fn register_gizmo_line_style_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_gizmos::config::GizmoLineStyle, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_gizmos::config::GizmoLineStyle>| { - let output: Val<::bevy_gizmos::config::GizmoLineStyle> = { - { - let output: Val<::bevy_gizmos::config::GizmoLineStyle> = - <::bevy_gizmos::config::GizmoLineStyle as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_gizmos::config::GizmoLineStyle>, - other: Ref<::bevy_gizmos::config::GizmoLineStyle>| { - let output: bool = { - { - let output: bool = - <::bevy_gizmos::config::GizmoLineStyle as ::std::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_gizmos::config::GizmoLineStyle>| { + let output: Val<::bevy_gizmos::config::GizmoLineStyle> = { + { + let output: Val<::bevy_gizmos::config::GizmoLineStyle> = <::bevy_gizmos::config::GizmoLineStyle as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_gizmos::config::GizmoLineStyle>, + other: Ref<::bevy_gizmos::config::GizmoLineStyle>| + { + let output: bool = { + { + let output: bool = <::bevy_gizmos::config::GizmoLineStyle as ::std::cmp::PartialEq< ::bevy_gizmos::config::GizmoLineStyle, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -255,22 +257,23 @@ pub(crate) fn register_gizmo_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_gizmos::retained::Gizmo, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_gizmos::retained::Gizmo>| { - let output: Val<::bevy_gizmos::retained::Gizmo> = { - { - let output: Val<::bevy_gizmos::retained::Gizmo> = - <::bevy_gizmos::retained::Gizmo as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_gizmos::retained::Gizmo>| { + let output: Val<::bevy_gizmos::retained::Gizmo> = { + { + let output: Val<::bevy_gizmos::retained::Gizmo> = <::bevy_gizmos::retained::Gizmo as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -283,24 +286,23 @@ pub(crate) fn register_light_gizmo_color_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_gizmos::light::LightGizmoColor, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_gizmos::light::LightGizmoColor>| { - let output: Val<::bevy_gizmos::light::LightGizmoColor> = { - { - let output: Val<::bevy_gizmos::light::LightGizmoColor> = - <::bevy_gizmos::light::LightGizmoColor as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_gizmos::light::LightGizmoColor>| { + let output: Val<::bevy_gizmos::light::LightGizmoColor> = { + { + let output: Val<::bevy_gizmos::light::LightGizmoColor> = <::bevy_gizmos::light::LightGizmoColor as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry diff --git a/crates/bindings/bevy_gltf_bms_bindings/src/lib.rs b/crates/bindings/bevy_gltf_bms_bindings/src/lib.rs index 84d859283b..8fa50833ee 100644 --- a/crates/bindings/bevy_gltf_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_gltf_bms_bindings/src/lib.rs @@ -1,42 +1,46 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyGltfScriptingPlugin; pub(crate) fn register_gltf_extras_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_gltf::prelude::GltfExtras, + ::bevy_gltf::GltfExtras, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_gltf::prelude::GltfExtras>| { - let output: Val<::bevy_gltf::prelude::GltfExtras> = { - { - let output: Val<::bevy_gltf::prelude::GltfExtras> = - <::bevy_gltf::prelude::GltfExtras as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_gltf::GltfExtras>| { + let output: Val<::bevy_gltf::GltfExtras> = { + { + let output: Val<::bevy_gltf::GltfExtras> = <::bevy_gltf::GltfExtras as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_gltf::prelude::GltfExtras, + ::bevy_gltf::GltfExtras, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -44,21 +48,23 @@ pub(crate) fn register_gltf_scene_extras_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_gltf::GltfSceneExtras, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_gltf::GltfSceneExtras>| { - let output: Val<::bevy_gltf::GltfSceneExtras> = { - { - let output: Val<::bevy_gltf::GltfSceneExtras> = - <::bevy_gltf::GltfSceneExtras as ::std::clone::Clone>::clone(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_gltf::GltfSceneExtras>| { + let output: Val<::bevy_gltf::GltfSceneExtras> = { + { + let output: Val<::bevy_gltf::GltfSceneExtras> = <::bevy_gltf::GltfSceneExtras as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -129,22 +135,23 @@ pub(crate) fn register_gltf_material_extras_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_gltf::GltfMaterialExtras, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_gltf::GltfMaterialExtras>| { - let output: Val<::bevy_gltf::GltfMaterialExtras> = { - { - let output: Val<::bevy_gltf::GltfMaterialExtras> = - <::bevy_gltf::GltfMaterialExtras as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_gltf::GltfMaterialExtras>| { + let output: Val<::bevy_gltf::GltfMaterialExtras> = { + { + let output: Val<::bevy_gltf::GltfMaterialExtras> = <::bevy_gltf::GltfMaterialExtras as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -157,22 +164,23 @@ pub(crate) fn register_gltf_material_name_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_gltf::GltfMaterialName, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_gltf::GltfMaterialName>| { - let output: Val<::bevy_gltf::GltfMaterialName> = { - { - let output: Val<::bevy_gltf::GltfMaterialName> = - <::bevy_gltf::GltfMaterialName as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_gltf::GltfMaterialName>| { + let output: Val<::bevy_gltf::GltfMaterialName> = { + { + let output: Val<::bevy_gltf::GltfMaterialName> = <::bevy_gltf::GltfMaterialName as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry diff --git a/crates/bindings/bevy_image_bms_bindings/src/lib.rs b/crates/bindings/bevy_image_bms_bindings/src/lib.rs index c848cfc71c..db93a339b6 100644 --- a/crates/bindings/bevy_image_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_image_bms_bindings/src/lib.rs @@ -1,27 +1,30 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyImageScriptingPlugin; pub(crate) fn register_texture_atlas_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_image::prelude::TextureAtlas, + ::bevy_image::TextureAtlas, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_image::prelude::TextureAtlas>| { + |_self: Ref<::bevy_image::TextureAtlas>| { let output: () = { { - let output: () = <::bevy_image::prelude::TextureAtlas as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_image::TextureAtlas as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -35,10 +38,10 @@ pub(crate) fn register_texture_atlas_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_image::prelude::TextureAtlas>| { - let output: Val<::bevy_image::prelude::TextureAtlas> = { + |_self: Ref<::bevy_image::TextureAtlas>| { + let output: Val<::bevy_image::TextureAtlas> = { { - let output: Val<::bevy_image::prelude::TextureAtlas> = <::bevy_image::prelude::TextureAtlas as ::std::clone::Clone>::clone( + let output: Val<::bevy_image::TextureAtlas> = <::bevy_image::TextureAtlas as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -53,13 +56,13 @@ pub(crate) fn register_texture_atlas_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_image::prelude::TextureAtlas>, - other: Ref<::bevy_image::prelude::TextureAtlas>| + _self: Ref<::bevy_image::TextureAtlas>, + other: Ref<::bevy_image::TextureAtlas>| { let output: bool = { { - let output: bool = <::bevy_image::prelude::TextureAtlas as ::std::cmp::PartialEq< - ::bevy_image::prelude::TextureAtlas, + let output: bool = <::bevy_image::TextureAtlas as ::std::cmp::PartialEq< + ::bevy_image::TextureAtlas, >>::eq(&_self, &other) .into(); output @@ -72,10 +75,10 @@ pub(crate) fn register_texture_atlas_functions(world: &mut World) { ) .register_documented( "with_index", - |_self: Val<::bevy_image::prelude::TextureAtlas>, index: usize| { - let output: Val<::bevy_image::prelude::TextureAtlas> = { + |_self: Val<::bevy_image::TextureAtlas>, index: usize| { + let output: Val<::bevy_image::TextureAtlas> = { { - let output: Val<::bevy_image::prelude::TextureAtlas> = ::bevy_image::prelude::TextureAtlas::with_index( + let output: Val<::bevy_image::TextureAtlas> = ::bevy_image::TextureAtlas::with_index( _self.into_inner(), index, ) @@ -92,23 +95,23 @@ pub(crate) fn register_texture_atlas_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_image::prelude::TextureAtlas, + ::bevy_image::TextureAtlas, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_texture_atlas_layout_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_image::prelude::TextureAtlasLayout, + ::bevy_image::TextureAtlasLayout, >::new(world) .register_documented( "add_texture", | - mut _self: Mut<::bevy_image::prelude::TextureAtlasLayout>, + mut _self: Mut<::bevy_image::TextureAtlasLayout>, rect: Val<::bevy_math::URect>| { let output: usize = { { - let output: usize = ::bevy_image::prelude::TextureAtlasLayout::add_texture( + let output: usize = ::bevy_image::TextureAtlasLayout::add_texture( &mut _self, rect.into_inner(), ) @@ -123,10 +126,10 @@ pub(crate) fn register_texture_atlas_layout_functions(world: &mut World) { ) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_image::prelude::TextureAtlasLayout>| { + |_self: Ref<::bevy_image::TextureAtlasLayout>| { let output: () = { { - let output: () = <::bevy_image::prelude::TextureAtlasLayout as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_image::TextureAtlasLayout as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -140,10 +143,10 @@ pub(crate) fn register_texture_atlas_layout_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_image::prelude::TextureAtlasLayout>| { - let output: Val<::bevy_image::prelude::TextureAtlasLayout> = { + |_self: Ref<::bevy_image::TextureAtlasLayout>| { + let output: Val<::bevy_image::TextureAtlasLayout> = { { - let output: Val<::bevy_image::prelude::TextureAtlasLayout> = <::bevy_image::prelude::TextureAtlasLayout as ::std::clone::Clone>::clone( + let output: Val<::bevy_image::TextureAtlasLayout> = <::bevy_image::TextureAtlasLayout as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -158,13 +161,13 @@ pub(crate) fn register_texture_atlas_layout_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_image::prelude::TextureAtlasLayout>, - other: Ref<::bevy_image::prelude::TextureAtlasLayout>| + _self: Ref<::bevy_image::TextureAtlasLayout>, + other: Ref<::bevy_image::TextureAtlasLayout>| { let output: bool = { { - let output: bool = <::bevy_image::prelude::TextureAtlasLayout as ::std::cmp::PartialEq< - ::bevy_image::prelude::TextureAtlasLayout, + let output: bool = <::bevy_image::TextureAtlasLayout as ::std::cmp::PartialEq< + ::bevy_image::TextureAtlasLayout, >>::eq(&_self, &other) .into(); output @@ -177,10 +180,10 @@ pub(crate) fn register_texture_atlas_layout_functions(world: &mut World) { ) .register_documented( "is_empty", - |_self: Ref<::bevy_image::prelude::TextureAtlasLayout>| { + |_self: Ref<::bevy_image::TextureAtlasLayout>| { let output: bool = { { - let output: bool = ::bevy_image::prelude::TextureAtlasLayout::is_empty( + let output: bool = ::bevy_image::TextureAtlasLayout::is_empty( &_self, ) .into(); @@ -194,12 +197,10 @@ pub(crate) fn register_texture_atlas_layout_functions(world: &mut World) { ) .register_documented( "len", - |_self: Ref<::bevy_image::prelude::TextureAtlasLayout>| { + |_self: Ref<::bevy_image::TextureAtlasLayout>| { let output: usize = { { - let output: usize = ::bevy_image::prelude::TextureAtlasLayout::len( - &_self, - ) + let output: usize = ::bevy_image::TextureAtlasLayout::len(&_self) .into(); output } @@ -208,25 +209,42 @@ pub(crate) fn register_texture_atlas_layout_functions(world: &mut World) { }, " The number of textures in the [`TextureAtlasLayout`]", &["_self"], + ) + .register_documented( + "new_empty", + |dimensions: Val<::glam::UVec2>| { + let output: Val<::bevy_image::TextureAtlasLayout> = { + { + let output: Val<::bevy_image::TextureAtlasLayout> = ::bevy_image::TextureAtlasLayout::new_empty( + dimensions.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new empty layout with custom `dimensions`", + &["dimensions"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_image::prelude::TextureAtlasLayout, + ::bevy_image::TextureAtlasLayout, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_image_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_image::prelude::Image, + ::bevy_image::Image, >::new(world) .register_documented( "aspect_ratio", - |_self: Ref<::bevy_image::prelude::Image>| { + |_self: Ref<::bevy_image::Image>| { let output: Val<::bevy_math::AspectRatio> = { { - let output: Val<::bevy_math::AspectRatio> = ::bevy_image::prelude::Image::aspect_ratio( + let output: Val<::bevy_math::AspectRatio> = ::bevy_image::Image::aspect_ratio( &_self, ) .into(); @@ -240,10 +258,10 @@ pub(crate) fn register_image_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_image::prelude::Image>| { - let output: Val<::bevy_image::prelude::Image> = { + |_self: Ref<::bevy_image::Image>| { + let output: Val<::bevy_image::Image> = { { - let output: Val<::bevy_image::prelude::Image> = <::bevy_image::prelude::Image as ::std::clone::Clone>::clone( + let output: Val<::bevy_image::Image> = <::bevy_image::Image as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -258,9 +276,9 @@ pub(crate) fn register_image_functions(world: &mut World) { .register_documented( "default_uninit", || { - let output: Val<::bevy_image::prelude::Image> = { + let output: Val<::bevy_image::Image> = { { - let output: Val<::bevy_image::prelude::Image> = ::bevy_image::prelude::Image::default_uninit() + let output: Val<::bevy_image::Image> = ::bevy_image::Image::default_uninit() .into(); output } @@ -272,14 +290,11 @@ pub(crate) fn register_image_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_image::prelude::Image>, - other: Ref<::bevy_image::prelude::Image>| - { + |_self: Ref<::bevy_image::Image>, other: Ref<::bevy_image::Image>| { let output: bool = { { - let output: bool = <::bevy_image::prelude::Image as ::std::cmp::PartialEq< - ::bevy_image::prelude::Image, + let output: bool = <::bevy_image::Image as ::std::cmp::PartialEq< + ::bevy_image::Image, >>::eq(&_self, &other) .into(); output @@ -292,11 +307,10 @@ pub(crate) fn register_image_functions(world: &mut World) { ) .register_documented( "height", - |_self: Ref<::bevy_image::prelude::Image>| { + |_self: Ref<::bevy_image::Image>| { let output: u32 = { { - let output: u32 = ::bevy_image::prelude::Image::height(&_self) - .into(); + let output: u32 = ::bevy_image::Image::height(&_self).into(); output } }; @@ -307,12 +321,10 @@ pub(crate) fn register_image_functions(world: &mut World) { ) .register_documented( "is_compressed", - |_self: Ref<::bevy_image::prelude::Image>| { + |_self: Ref<::bevy_image::Image>| { let output: bool = { { - let output: bool = ::bevy_image::prelude::Image::is_compressed( - &_self, - ) + let output: bool = ::bevy_image::Image::is_compressed(&_self) .into(); output } @@ -322,12 +334,30 @@ pub(crate) fn register_image_functions(world: &mut World) { " Whether the texture format is compressed or uncompressed", &["_self"], ) + .register_documented( + "pixel_data_offset", + |_self: Ref<::bevy_image::Image>, coords: Val<::glam::UVec3>| { + let output: ::std::option::Option = { + { + let output: ::std::option::Option = ::bevy_image::Image::pixel_data_offset( + &_self, + coords.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Compute the byte offset where the data of a specific pixel is stored\n Returns None if the provided coordinates are out of bounds.\n For 2D textures, Z is the layer number. For 1D textures, Y and Z are ignored.", + &["_self", "coords"], + ) .register_documented( "reinterpret_stacked_2d_as_array", - |mut _self: Mut<::bevy_image::prelude::Image>, layers: u32| { + |mut _self: Mut<::bevy_image::Image>, layers: u32| { let output: () = { { - let output: () = ::bevy_image::prelude::Image::reinterpret_stacked_2d_as_array( + let output: () = ::bevy_image::Image::reinterpret_stacked_2d_as_array( &mut _self, layers, ) @@ -340,12 +370,46 @@ pub(crate) fn register_image_functions(world: &mut World) { " Takes a 2D image containing vertically stacked images of the same size, and reinterprets\n it as a 2D array texture, where each of the stacked images becomes one layer of the\n array. This is primarily for use with the `texture2DArray` shader uniform type.\n # Panics\n Panics if the texture is not 2D, has more than one layers or is not evenly dividable into\n the `layers`.", &["_self", "layers"], ) + .register_documented( + "size", + |_self: Ref<::bevy_image::Image>| { + let output: Val<::glam::UVec2> = { + { + let output: Val<::glam::UVec2> = ::bevy_image::Image::size( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the size of a 2D image.", + &["_self"], + ) + .register_documented( + "size_f32", + |_self: Ref<::bevy_image::Image>| { + let output: Val<::glam::Vec2> = { + { + let output: Val<::glam::Vec2> = ::bevy_image::Image::size_f32( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the size of a 2D image as f32.", + &["_self"], + ) .register_documented( "transparent", || { - let output: Val<::bevy_image::prelude::Image> = { + let output: Val<::bevy_image::Image> = { { - let output: Val<::bevy_image::prelude::Image> = ::bevy_image::prelude::Image::transparent() + let output: Val<::bevy_image::Image> = ::bevy_image::Image::transparent() .into(); output } @@ -357,11 +421,10 @@ pub(crate) fn register_image_functions(world: &mut World) { ) .register_documented( "width", - |_self: Ref<::bevy_image::prelude::Image>| { + |_self: Ref<::bevy_image::Image>| { let output: u32 = { { - let output: u32 = ::bevy_image::prelude::Image::width(&_self) - .into(); + let output: u32 = ::bevy_image::Image::width(&_self).into(); output } }; @@ -374,7 +437,7 @@ pub(crate) fn register_image_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_image::prelude::Image, + ::bevy_image::Image, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } diff --git a/crates/bindings/bevy_input_bms_bindings/src/lib.rs b/crates/bindings/bevy_input_bms_bindings/src/lib.rs index 58fc7e1fa2..36947c4ba8 100644 --- a/crates/bindings/bevy_input_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_input_bms_bindings/src/lib.rs @@ -1,21 +1,41 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyInputScriptingPlugin; pub(crate) fn register_gamepad_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_input::gamepad::Gamepad, >::new(world) + .register_documented( + "dpad", + |_self: Ref<::bevy_input::gamepad::Gamepad>| { + let output: Val<::glam::Vec2> = { + { + let output: Val<::glam::Vec2> = ::bevy_input::gamepad::Gamepad::dpad( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the directional pad as a [`Vec2`].", + &["_self"], + ) .register_documented( "just_pressed", | @@ -58,6 +78,23 @@ pub(crate) fn register_gamepad_functions(world: &mut World) { " Returns `true` if the [`GamepadButton`] has been released during the current frame.\n Note: This function does not imply information regarding the current state of [`ButtonInput::pressed`] or [`ButtonInput::just_pressed`].", &["_self", "button_type"], ) + .register_documented( + "left_stick", + |_self: Ref<::bevy_input::gamepad::Gamepad>| { + let output: Val<::glam::Vec2> = { + { + let output: Val<::glam::Vec2> = ::bevy_input::gamepad::Gamepad::left_stick( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the left stick as a [`Vec2`].", + &["_self"], + ) .register_documented( "pressed", | @@ -96,6 +133,23 @@ pub(crate) fn register_gamepad_functions(world: &mut World) { " Returns the USB product ID as assigned by the [vendor], if available.\n [vendor]: Self::vendor_id", &["_self"], ) + .register_documented( + "right_stick", + |_self: Ref<::bevy_input::gamepad::Gamepad>| { + let output: Val<::glam::Vec2> = { + { + let output: Val<::glam::Vec2> = ::bevy_input::gamepad::Gamepad::right_stick( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the right stick as a [`Vec2`].", + &["_self"], + ) .register_documented( "vendor_id", |_self: Ref<::bevy_input::gamepad::Gamepad>| { @@ -257,24 +311,23 @@ pub(crate) fn register_gamepad_settings_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_input::gamepad::GamepadSettings, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_input::gamepad::GamepadSettings>| { - let output: Val<::bevy_input::gamepad::GamepadSettings> = { - { - let output: Val<::bevy_input::gamepad::GamepadSettings> = - <::bevy_input::gamepad::GamepadSettings as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_input::gamepad::GamepadSettings>| { + let output: Val<::bevy_input::gamepad::GamepadSettings> = { + { + let output: Val<::bevy_input::gamepad::GamepadSettings> = <::bevy_input::gamepad::GamepadSettings as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -419,41 +472,43 @@ pub(crate) fn register_touch_input_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_input::touch::TouchInput, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_input::touch::TouchInput>| { - let output: Val<::bevy_input::touch::TouchInput> = { - { - let output: Val<::bevy_input::touch::TouchInput> = - <::bevy_input::touch::TouchInput as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_input::touch::TouchInput>, - other: Ref<::bevy_input::touch::TouchInput>| { - let output: bool = { - { - let output: bool = - <::bevy_input::touch::TouchInput as ::core::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_input::touch::TouchInput>| { + let output: Val<::bevy_input::touch::TouchInput> = { + { + let output: Val<::bevy_input::touch::TouchInput> = <::bevy_input::touch::TouchInput as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_input::touch::TouchInput>, + other: Ref<::bevy_input::touch::TouchInput>| + { + let output: bool = { + { + let output: bool = <::bevy_input::touch::TouchInput as ::core::cmp::PartialEq< ::bevy_input::touch::TouchInput, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -828,41 +883,43 @@ pub(crate) fn register_mouse_motion_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_input::mouse::MouseMotion, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_input::mouse::MouseMotion>| { - let output: Val<::bevy_input::mouse::MouseMotion> = { - { - let output: Val<::bevy_input::mouse::MouseMotion> = - <::bevy_input::mouse::MouseMotion as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_input::mouse::MouseMotion>, - other: Ref<::bevy_input::mouse::MouseMotion>| { - let output: bool = { - { - let output: bool = - <::bevy_input::mouse::MouseMotion as ::core::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_input::mouse::MouseMotion>| { + let output: Val<::bevy_input::mouse::MouseMotion> = { + { + let output: Val<::bevy_input::mouse::MouseMotion> = <::bevy_input::mouse::MouseMotion as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_input::mouse::MouseMotion>, + other: Ref<::bevy_input::mouse::MouseMotion>| + { + let output: bool = { + { + let output: bool = <::bevy_input::mouse::MouseMotion as ::core::cmp::PartialEq< ::bevy_input::mouse::MouseMotion, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -875,41 +932,43 @@ pub(crate) fn register_mouse_wheel_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_input::mouse::MouseWheel, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_input::mouse::MouseWheel>| { - let output: Val<::bevy_input::mouse::MouseWheel> = { - { - let output: Val<::bevy_input::mouse::MouseWheel> = - <::bevy_input::mouse::MouseWheel as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_input::mouse::MouseWheel>, - other: Ref<::bevy_input::mouse::MouseWheel>| { - let output: bool = { - { - let output: bool = - <::bevy_input::mouse::MouseWheel as ::core::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_input::mouse::MouseWheel>| { + let output: Val<::bevy_input::mouse::MouseWheel> = { + { + let output: Val<::bevy_input::mouse::MouseWheel> = <::bevy_input::mouse::MouseWheel as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_input::mouse::MouseWheel>, + other: Ref<::bevy_input::mouse::MouseWheel>| + { + let output: bool = { + { + let output: bool = <::bevy_input::mouse::MouseWheel as ::core::cmp::PartialEq< ::bevy_input::mouse::MouseWheel, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1273,43 +1332,43 @@ pub(crate) fn register_gamepad_event_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_input::gamepad::GamepadEvent, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_input::gamepad::GamepadEvent>| { - let output: Val<::bevy_input::gamepad::GamepadEvent> = { - { - let output: Val<::bevy_input::gamepad::GamepadEvent> = - <::bevy_input::gamepad::GamepadEvent as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_input::gamepad::GamepadEvent>, - other: Ref<::bevy_input::gamepad::GamepadEvent>| { - let output: bool = { - { - let output: bool = - <::bevy_input::gamepad::GamepadEvent as ::core::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_input::gamepad::GamepadEvent>| { + let output: Val<::bevy_input::gamepad::GamepadEvent> = { + { + let output: Val<::bevy_input::gamepad::GamepadEvent> = <::bevy_input::gamepad::GamepadEvent as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_input::gamepad::GamepadEvent>, + other: Ref<::bevy_input::gamepad::GamepadEvent>| + { + let output: bool = { + { + let output: bool = <::bevy_input::gamepad::GamepadEvent as ::core::cmp::PartialEq< ::bevy_input::gamepad::GamepadEvent, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1520,43 +1579,43 @@ pub(crate) fn register_raw_gamepad_event_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_input::gamepad::RawGamepadEvent, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_input::gamepad::RawGamepadEvent>| { - let output: Val<::bevy_input::gamepad::RawGamepadEvent> = { - { - let output: Val<::bevy_input::gamepad::RawGamepadEvent> = - <::bevy_input::gamepad::RawGamepadEvent as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_input::gamepad::RawGamepadEvent>, - other: Ref<::bevy_input::gamepad::RawGamepadEvent>| { - let output: bool = { - { - let output: bool = - <::bevy_input::gamepad::RawGamepadEvent as ::core::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_input::gamepad::RawGamepadEvent>| { + let output: Val<::bevy_input::gamepad::RawGamepadEvent> = { + { + let output: Val<::bevy_input::gamepad::RawGamepadEvent> = <::bevy_input::gamepad::RawGamepadEvent as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_input::gamepad::RawGamepadEvent>, + other: Ref<::bevy_input::gamepad::RawGamepadEvent>| + { + let output: bool = { + { + let output: bool = <::bevy_input::gamepad::RawGamepadEvent as ::core::cmp::PartialEq< ::bevy_input::gamepad::RawGamepadEvent, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1569,43 +1628,43 @@ pub(crate) fn register_pinch_gesture_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_input::gestures::PinchGesture, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_input::gestures::PinchGesture>| { - let output: Val<::bevy_input::gestures::PinchGesture> = { - { - let output: Val<::bevy_input::gestures::PinchGesture> = - <::bevy_input::gestures::PinchGesture as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_input::gestures::PinchGesture>, - other: Ref<::bevy_input::gestures::PinchGesture>| { - let output: bool = { - { - let output: bool = - <::bevy_input::gestures::PinchGesture as ::core::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_input::gestures::PinchGesture>| { + let output: Val<::bevy_input::gestures::PinchGesture> = { + { + let output: Val<::bevy_input::gestures::PinchGesture> = <::bevy_input::gestures::PinchGesture as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_input::gestures::PinchGesture>, + other: Ref<::bevy_input::gestures::PinchGesture>| + { + let output: bool = { + { + let output: bool = <::bevy_input::gestures::PinchGesture as ::core::cmp::PartialEq< ::bevy_input::gestures::PinchGesture, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1618,43 +1677,43 @@ pub(crate) fn register_rotation_gesture_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_input::gestures::RotationGesture, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_input::gestures::RotationGesture>| { - let output: Val<::bevy_input::gestures::RotationGesture> = { - { - let output: Val<::bevy_input::gestures::RotationGesture> = - <::bevy_input::gestures::RotationGesture as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_input::gestures::RotationGesture>, - other: Ref<::bevy_input::gestures::RotationGesture>| { - let output: bool = { - { - let output: bool = - <::bevy_input::gestures::RotationGesture as ::core::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_input::gestures::RotationGesture>| { + let output: Val<::bevy_input::gestures::RotationGesture> = { + { + let output: Val<::bevy_input::gestures::RotationGesture> = <::bevy_input::gestures::RotationGesture as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_input::gestures::RotationGesture>, + other: Ref<::bevy_input::gestures::RotationGesture>| + { + let output: bool = { + { + let output: bool = <::bevy_input::gestures::RotationGesture as ::core::cmp::PartialEq< ::bevy_input::gestures::RotationGesture, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1667,43 +1726,43 @@ pub(crate) fn register_double_tap_gesture_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_input::gestures::DoubleTapGesture, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_input::gestures::DoubleTapGesture>| { - let output: Val<::bevy_input::gestures::DoubleTapGesture> = { - { - let output: Val<::bevy_input::gestures::DoubleTapGesture> = - <::bevy_input::gestures::DoubleTapGesture as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_input::gestures::DoubleTapGesture>, - other: Ref<::bevy_input::gestures::DoubleTapGesture>| { - let output: bool = { - { - let output: bool = - <::bevy_input::gestures::DoubleTapGesture as ::core::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_input::gestures::DoubleTapGesture>| { + let output: Val<::bevy_input::gestures::DoubleTapGesture> = { + { + let output: Val<::bevy_input::gestures::DoubleTapGesture> = <::bevy_input::gestures::DoubleTapGesture as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_input::gestures::DoubleTapGesture>, + other: Ref<::bevy_input::gestures::DoubleTapGesture>| + { + let output: bool = { + { + let output: bool = <::bevy_input::gestures::DoubleTapGesture as ::core::cmp::PartialEq< ::bevy_input::gestures::DoubleTapGesture, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1716,41 +1775,43 @@ pub(crate) fn register_pan_gesture_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_input::gestures::PanGesture, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_input::gestures::PanGesture>| { - let output: Val<::bevy_input::gestures::PanGesture> = { - { - let output: Val<::bevy_input::gestures::PanGesture> = - <::bevy_input::gestures::PanGesture as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_input::gestures::PanGesture>, - other: Ref<::bevy_input::gestures::PanGesture>| { - let output: bool = { - { - let output: bool = - <::bevy_input::gestures::PanGesture as ::core::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_input::gestures::PanGesture>| { + let output: Val<::bevy_input::gestures::PanGesture> = { + { + let output: Val<::bevy_input::gestures::PanGesture> = <::bevy_input::gestures::PanGesture as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_input::gestures::PanGesture>, + other: Ref<::bevy_input::gestures::PanGesture>| + { + let output: bool = { + { + let output: bool = <::bevy_input::gestures::PanGesture as ::core::cmp::PartialEq< ::bevy_input::gestures::PanGesture, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1844,43 +1905,43 @@ pub(crate) fn register_gamepad_connection_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_input::gamepad::GamepadConnection, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_input::gamepad::GamepadConnection>| { - let output: Val<::bevy_input::gamepad::GamepadConnection> = { - { - let output: Val<::bevy_input::gamepad::GamepadConnection> = - <::bevy_input::gamepad::GamepadConnection as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_input::gamepad::GamepadConnection>, - other: Ref<::bevy_input::gamepad::GamepadConnection>| { - let output: bool = { - { - let output: bool = - <::bevy_input::gamepad::GamepadConnection as ::core::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_input::gamepad::GamepadConnection>| { + let output: Val<::bevy_input::gamepad::GamepadConnection> = { + { + let output: Val<::bevy_input::gamepad::GamepadConnection> = <::bevy_input::gamepad::GamepadConnection as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_input::gamepad::GamepadConnection>, + other: Ref<::bevy_input::gamepad::GamepadConnection>| + { + let output: bool = { + { + let output: bool = <::bevy_input::gamepad::GamepadConnection as ::core::cmp::PartialEq< ::bevy_input::gamepad::GamepadConnection, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -2356,24 +2417,23 @@ pub(crate) fn register_button_axis_settings_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_input::gamepad::ButtonAxisSettings, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_input::gamepad::ButtonAxisSettings>| { - let output: Val<::bevy_input::gamepad::ButtonAxisSettings> = { - { - let output: Val<::bevy_input::gamepad::ButtonAxisSettings> = - <::bevy_input::gamepad::ButtonAxisSettings as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_input::gamepad::ButtonAxisSettings>| { + let output: Val<::bevy_input::gamepad::ButtonAxisSettings> = { + { + let output: Val<::bevy_input::gamepad::ButtonAxisSettings> = <::bevy_input::gamepad::ButtonAxisSettings as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -2733,41 +2793,43 @@ pub(crate) fn register_force_touch_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_input::touch::ForceTouch, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_input::touch::ForceTouch>| { - let output: Val<::bevy_input::touch::ForceTouch> = { - { - let output: Val<::bevy_input::touch::ForceTouch> = - <::bevy_input::touch::ForceTouch as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_input::touch::ForceTouch>, - other: Ref<::bevy_input::touch::ForceTouch>| { - let output: bool = { - { - let output: bool = - <::bevy_input::touch::ForceTouch as ::core::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_input::touch::ForceTouch>| { + let output: Val<::bevy_input::touch::ForceTouch> = { + { + let output: Val<::bevy_input::touch::ForceTouch> = <::bevy_input::touch::ForceTouch as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_input::touch::ForceTouch>, + other: Ref<::bevy_input::touch::ForceTouch>| + { + let output: bool = { + { + let output: bool = <::bevy_input::touch::ForceTouch as ::core::cmp::PartialEq< ::bevy_input::touch::ForceTouch, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry diff --git a/crates/bindings/bevy_input_focus_bms_bindings/src/lib.rs b/crates/bindings/bevy_input_focus_bms_bindings/src/lib.rs index 1030ab25b9..ee21c555a6 100644 --- a/crates/bindings/bevy_input_focus_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_input_focus_bms_bindings/src/lib.rs @@ -1,15 +1,18 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyInputFocusScriptingPlugin; pub(crate) fn register_input_focus_functions(world: &mut World) { @@ -100,24 +103,23 @@ pub(crate) fn register_input_focus_visible_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_input_focus::InputFocusVisible, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_input_focus::InputFocusVisible>| { - let output: Val<::bevy_input_focus::InputFocusVisible> = { - { - let output: Val<::bevy_input_focus::InputFocusVisible> = - <::bevy_input_focus::InputFocusVisible as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_input_focus::InputFocusVisible>| { + let output: Val<::bevy_input_focus::InputFocusVisible> = { + { + let output: Val<::bevy_input_focus::InputFocusVisible> = <::bevy_input_focus::InputFocusVisible as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -130,22 +132,23 @@ pub(crate) fn register_auto_focus_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_input_focus::AutoFocus, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_input_focus::AutoFocus>| { - let output: Val<::bevy_input_focus::AutoFocus> = { - { - let output: Val<::bevy_input_focus::AutoFocus> = - <::bevy_input_focus::AutoFocus as ::core::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_input_focus::AutoFocus>| { + let output: Val<::bevy_input_focus::AutoFocus> = { + { + let output: Val<::bevy_input_focus::AutoFocus> = <::bevy_input_focus::AutoFocus as ::core::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry diff --git a/crates/bindings/bevy_light_bms_bindings/src/lib.rs b/crates/bindings/bevy_light_bms_bindings/src/lib.rs index 6bfb72014a..10efa9ee5f 100644 --- a/crates/bindings/bevy_light_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_light_bms_bindings/src/lib.rs @@ -1,44 +1,46 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyLightScriptingPlugin; pub(crate) fn register_clustered_decal_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_light::cluster::ClusteredDecal, + ::bevy_light::ClusteredDecal, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_light::cluster::ClusteredDecal>| { - let output: Val<::bevy_light::cluster::ClusteredDecal> = { - { - let output: Val<::bevy_light::cluster::ClusteredDecal> = - <::bevy_light::cluster::ClusteredDecal as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_light::ClusteredDecal>| { + let output: Val<::bevy_light::ClusteredDecal> = { + { + let output: Val<::bevy_light::ClusteredDecal> = <::bevy_light::ClusteredDecal as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_light::cluster::ClusteredDecal, + ::bevy_light::ClusteredDecal, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -75,22 +77,23 @@ pub(crate) fn register_environment_map_light_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_light::EnvironmentMapLight, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_light::EnvironmentMapLight>| { - let output: Val<::bevy_light::EnvironmentMapLight> = { - { - let output: Val<::bevy_light::EnvironmentMapLight> = - <::bevy_light::EnvironmentMapLight as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_light::EnvironmentMapLight>| { + let output: Val<::bevy_light::EnvironmentMapLight> = { + { + let output: Val<::bevy_light::EnvironmentMapLight> = <::bevy_light::EnvironmentMapLight as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -103,24 +106,23 @@ pub(crate) fn register_generated_environment_map_light_functions(world: &mut Wor bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_light::GeneratedEnvironmentMapLight, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_light::GeneratedEnvironmentMapLight>| { - let output: Val<::bevy_light::GeneratedEnvironmentMapLight> = { - { - let output: Val<::bevy_light::GeneratedEnvironmentMapLight> = - <::bevy_light::GeneratedEnvironmentMapLight as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_light::GeneratedEnvironmentMapLight>| { + let output: Val<::bevy_light::GeneratedEnvironmentMapLight> = { + { + let output: Val<::bevy_light::GeneratedEnvironmentMapLight> = <::bevy_light::GeneratedEnvironmentMapLight as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -133,22 +135,23 @@ pub(crate) fn register_irradiance_volume_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_light::IrradianceVolume, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_light::IrradianceVolume>| { - let output: Val<::bevy_light::IrradianceVolume> = { - { - let output: Val<::bevy_light::IrradianceVolume> = - <::bevy_light::IrradianceVolume as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_light::IrradianceVolume>| { + let output: Val<::bevy_light::IrradianceVolume> = { + { + let output: Val<::bevy_light::IrradianceVolume> = <::bevy_light::IrradianceVolume as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -263,22 +266,23 @@ pub(crate) fn register_volumetric_light_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_light::VolumetricLight, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_light::VolumetricLight>| { - let output: Val<::bevy_light::VolumetricLight> = { - { - let output: Val<::bevy_light::VolumetricLight> = - <::bevy_light::VolumetricLight as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_light::VolumetricLight>| { + let output: Val<::bevy_light::VolumetricLight> = { + { + let output: Val<::bevy_light::VolumetricLight> = <::bevy_light::VolumetricLight as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -289,59 +293,59 @@ pub(crate) fn register_volumetric_light_functions(world: &mut World) { } pub(crate) fn register_cascade_shadow_config_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_light::cascade::CascadeShadowConfig, + ::bevy_light::CascadeShadowConfig, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_light::cascade::CascadeShadowConfig>| { - let output: Val<::bevy_light::cascade::CascadeShadowConfig> = { - { - let output: Val<::bevy_light::cascade::CascadeShadowConfig> = - <::bevy_light::cascade::CascadeShadowConfig as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_light::CascadeShadowConfig>| { + let output: Val<::bevy_light::CascadeShadowConfig> = { + { + let output: Val<::bevy_light::CascadeShadowConfig> = <::bevy_light::CascadeShadowConfig as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_light::cascade::CascadeShadowConfig, + ::bevy_light::CascadeShadowConfig, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_cascades_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_light::cascade::Cascades, + ::bevy_light::Cascades, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_light::cascade::Cascades>| { - let output: Val<::bevy_light::cascade::Cascades> = { - { - let output: Val<::bevy_light::cascade::Cascades> = - <::bevy_light::cascade::Cascades as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_light::Cascades>| { + let output: Val<::bevy_light::Cascades> = { + { + let output: Val<::bevy_light::Cascades> = <::bevy_light::Cascades as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_light::cascade::Cascades, + ::bevy_light::Cascades, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -378,22 +382,23 @@ pub(crate) fn register_point_light_shadow_map_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_light::PointLightShadowMap, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_light::PointLightShadowMap>| { - let output: Val<::bevy_light::PointLightShadowMap> = { - { - let output: Val<::bevy_light::PointLightShadowMap> = - <::bevy_light::PointLightShadowMap as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_light::PointLightShadowMap>| { + let output: Val<::bevy_light::PointLightShadowMap> = { + { + let output: Val<::bevy_light::PointLightShadowMap> = <::bevy_light::PointLightShadowMap as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -406,22 +411,23 @@ pub(crate) fn register_point_light_texture_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_light::PointLightTexture, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_light::PointLightTexture>| { - let output: Val<::bevy_light::PointLightTexture> = { - { - let output: Val<::bevy_light::PointLightTexture> = - <::bevy_light::PointLightTexture as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_light::PointLightTexture>| { + let output: Val<::bevy_light::PointLightTexture> = { + { + let output: Val<::bevy_light::PointLightTexture> = <::bevy_light::PointLightTexture as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -463,22 +469,23 @@ pub(crate) fn register_spot_light_texture_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_light::SpotLightTexture, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_light::SpotLightTexture>| { - let output: Val<::bevy_light::SpotLightTexture> = { - { - let output: Val<::bevy_light::SpotLightTexture> = - <::bevy_light::SpotLightTexture as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_light::SpotLightTexture>| { + let output: Val<::bevy_light::SpotLightTexture> = { + { + let output: Val<::bevy_light::SpotLightTexture> = <::bevy_light::SpotLightTexture as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -491,22 +498,23 @@ pub(crate) fn register_directional_light_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_light::DirectionalLight, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_light::DirectionalLight>| { - let output: Val<::bevy_light::DirectionalLight> = { - { - let output: Val<::bevy_light::DirectionalLight> = - <::bevy_light::DirectionalLight as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_light::DirectionalLight>| { + let output: Val<::bevy_light::DirectionalLight> = { + { + let output: Val<::bevy_light::DirectionalLight> = <::bevy_light::DirectionalLight as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -519,24 +527,23 @@ pub(crate) fn register_directional_light_shadow_map_functions(world: &mut World) bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_light::DirectionalLightShadowMap, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_light::DirectionalLightShadowMap>| { - let output: Val<::bevy_light::DirectionalLightShadowMap> = { - { - let output: Val<::bevy_light::DirectionalLightShadowMap> = - <::bevy_light::DirectionalLightShadowMap as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_light::DirectionalLightShadowMap>| { + let output: Val<::bevy_light::DirectionalLightShadowMap> = { + { + let output: Val<::bevy_light::DirectionalLightShadowMap> = <::bevy_light::DirectionalLightShadowMap as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -549,24 +556,23 @@ pub(crate) fn register_directional_light_texture_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_light::DirectionalLightTexture, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_light::DirectionalLightTexture>| { - let output: Val<::bevy_light::DirectionalLightTexture> = { - { - let output: Val<::bevy_light::DirectionalLightTexture> = - <::bevy_light::DirectionalLightTexture as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_light::DirectionalLightTexture>| { + let output: Val<::bevy_light::DirectionalLightTexture> = { + { + let output: Val<::bevy_light::DirectionalLightTexture> = <::bevy_light::DirectionalLightTexture as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -579,39 +585,43 @@ pub(crate) fn register_not_shadow_caster_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_light::NotShadowCaster, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_light::NotShadowCaster>| { - let output: Val<::bevy_light::NotShadowCaster> = { - { - let output: Val<::bevy_light::NotShadowCaster> = - <::bevy_light::NotShadowCaster as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_light::NotShadowCaster>| { + let output: Val<::bevy_light::NotShadowCaster> = { + { + let output: Val<::bevy_light::NotShadowCaster> = <::bevy_light::NotShadowCaster as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_light::NotShadowCaster>, + other: Ref<::bevy_light::NotShadowCaster>| + { + let output: bool = { + { + let output: bool = <::bevy_light::NotShadowCaster as ::std::cmp::PartialEq< + ::bevy_light::NotShadowCaster, + >>::eq(&_self, &other) .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_light::NotShadowCaster>, other: Ref<::bevy_light::NotShadowCaster>| { - let output: bool = { - { - let output: bool = <::bevy_light::NotShadowCaster as ::std::cmp::PartialEq< - ::bevy_light::NotShadowCaster, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -714,24 +724,23 @@ pub(crate) fn register_cluster_far_z_mode_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_light::cluster::ClusterFarZMode, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_light::cluster::ClusterFarZMode>| { - let output: Val<::bevy_light::cluster::ClusterFarZMode> = { - { - let output: Val<::bevy_light::cluster::ClusterFarZMode> = - <::bevy_light::cluster::ClusterFarZMode as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_light::cluster::ClusterFarZMode>| { + let output: Val<::bevy_light::cluster::ClusterFarZMode> = { + { + let output: Val<::bevy_light::cluster::ClusterFarZMode> = <::bevy_light::cluster::ClusterFarZMode as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -744,24 +753,23 @@ pub(crate) fn register_cluster_z_config_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_light::cluster::ClusterZConfig, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_light::cluster::ClusterZConfig>| { - let output: Val<::bevy_light::cluster::ClusterZConfig> = { - { - let output: Val<::bevy_light::cluster::ClusterZConfig> = - <::bevy_light::cluster::ClusterZConfig as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_light::cluster::ClusterZConfig>| { + let output: Val<::bevy_light::cluster::ClusterZConfig> = { + { + let output: Val<::bevy_light::cluster::ClusterZConfig> = <::bevy_light::cluster::ClusterZConfig as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -774,24 +782,23 @@ pub(crate) fn register_cluster_config_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_light::cluster::ClusterConfig, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_light::cluster::ClusterConfig>| { - let output: Val<::bevy_light::cluster::ClusterConfig> = { - { - let output: Val<::bevy_light::cluster::ClusterConfig> = - <::bevy_light::cluster::ClusterConfig as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_light::cluster::ClusterConfig>| { + let output: Val<::bevy_light::cluster::ClusterConfig> = { + { + let output: Val<::bevy_light::cluster::ClusterConfig> = <::bevy_light::cluster::ClusterConfig as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -804,22 +811,23 @@ pub(crate) fn register_cascade_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_light::cascade::Cascade, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_light::cascade::Cascade>| { - let output: Val<::bevy_light::cascade::Cascade> = { - { - let output: Val<::bevy_light::cascade::Cascade> = - <::bevy_light::cascade::Cascade as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_light::cascade::Cascade>| { + let output: Val<::bevy_light::cascade::Cascade> = { + { + let output: Val<::bevy_light::cascade::Cascade> = <::bevy_light::cascade::Cascade as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry diff --git a/crates/bindings/bevy_math_bms_bindings/src/lib.rs b/crates/bindings/bevy_math_bms_bindings/src/lib.rs index 924a52a34e..223da5c7b9 100644 --- a/crates/bindings/bevy_math_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_math_bms_bindings/src/lib.rs @@ -1,15 +1,18 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyMathScriptingPlugin; pub(crate) fn register_aspect_ratio_functions(world: &mut World) { @@ -423,6 +426,23 @@ pub(crate) fn register_isometry_2_d_functions(world: &mut World) { " Create a two-dimensional isometry from a rotation.", &["rotation"], ) + .register_documented( + "from_translation", + |translation: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_math::Isometry2d> = { + { + let output: Val<::bevy_math::Isometry2d> = ::bevy_math::Isometry2d::from_translation( + translation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a two-dimensional isometry from a translation.", + &["translation"], + ) .register_documented( "from_xy", |x: f32, y: f32| { @@ -476,6 +496,41 @@ pub(crate) fn register_isometry_2_d_functions(world: &mut World) { " Compute `iso1.inverse() * iso2` in a more efficient way for one-shot cases.\n If the same isometry is used multiple times, it is more efficient to instead compute\n the inverse once and use that for each transformation.", &["_self", "rhs"], ) + .register_documented( + "inverse_transform_point", + |_self: Ref<::bevy_math::Isometry2d>, point: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = ::bevy_math::Isometry2d::inverse_transform_point( + &_self, + point.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Transform a point by rotating and translating it using the inverse of this isometry.\n This is more efficient than `iso.inverse().transform_point(point)` for one-shot cases.\n If the same isometry is used multiple times, it is more efficient to instead compute\n the inverse once and use that for each transformation.", + &["_self", "point"], + ) + .register_documented( + "mul", + |_self: Val<::bevy_math::Isometry2d>, rhs: Val<::bevy_math::Dir2>| { + let output: Val<::bevy_math::Dir2> = { + { + let output: Val<::bevy_math::Dir2> = <::bevy_math::Isometry2d as ::core::ops::Mul< + ::bevy_math::Dir2, + >>::mul(_self.into_inner(), rhs.into_inner()) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "mul", |_self: Val<::bevy_math::Isometry2d>, rhs: Val<::bevy_math::Isometry2d>| { @@ -495,11 +550,11 @@ pub(crate) fn register_isometry_2_d_functions(world: &mut World) { ) .register_documented( "mul", - |_self: Val<::bevy_math::Isometry2d>, rhs: Val<::bevy_math::prelude::Dir2>| { - let output: Val<::bevy_math::prelude::Dir2> = { + |_self: Val<::bevy_math::Isometry2d>, rhs: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::prelude::Dir2> = <::bevy_math::Isometry2d as ::core::ops::Mul< - ::bevy_math::prelude::Dir2, + let output: Val<::bevy_math::Vec2> = <::bevy_math::Isometry2d as ::core::ops::Mul< + ::bevy_math::Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output @@ -509,6 +564,42 @@ pub(crate) fn register_isometry_2_d_functions(world: &mut World) { }, "", &["_self", "rhs"], + ) + .register_documented( + "new", + |translation: Val<::bevy_math::Vec2>, rotation: Val<::bevy_math::Rot2>| { + let output: Val<::bevy_math::Isometry2d> = { + { + let output: Val<::bevy_math::Isometry2d> = ::bevy_math::Isometry2d::new( + translation.into_inner(), + rotation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a two-dimensional isometry from a rotation and a translation.", + &["translation", "rotation"], + ) + .register_documented( + "transform_point", + |_self: Ref<::bevy_math::Isometry2d>, point: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = ::bevy_math::Isometry2d::transform_point( + &_self, + point.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Transform a point by rotating and translating it using this isometry.", + &["_self", "point"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); @@ -556,6 +647,23 @@ pub(crate) fn register_isometry_3_d_functions(world: &mut World) { "", &["_self", "other"], ) + .register_documented( + "from_rotation", + |rotation: Val<::bevy_math::Quat>| { + let output: Val<::bevy_math::Isometry3d> = { + { + let output: Val<::bevy_math::Isometry3d> = ::bevy_math::Isometry3d::from_rotation( + rotation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a three-dimensional isometry from a rotation.", + &["rotation"], + ) .register_documented( "from_xyz", |x: f32, y: f32, z: f32| { @@ -610,6 +718,23 @@ pub(crate) fn register_isometry_3_d_functions(world: &mut World) { " Compute `iso1.inverse() * iso2` in a more efficient way for one-shot cases.\n If the same isometry is used multiple times, it is more efficient to instead compute\n the inverse once and use that for each transformation.", &["_self", "rhs"], ) + .register_documented( + "mul", + |_self: Val<::bevy_math::Isometry3d>, rhs: Val<::bevy_math::Dir3>| { + let output: Val<::bevy_math::Dir3> = { + { + let output: Val<::bevy_math::Dir3> = <::bevy_math::Isometry3d as ::core::ops::Mul< + ::bevy_math::Dir3, + >>::mul(_self.into_inner(), rhs.into_inner()) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "mul", |_self: Val<::bevy_math::Isometry3d>, rhs: Val<::bevy_math::Isometry3d>| { @@ -629,11 +754,28 @@ pub(crate) fn register_isometry_3_d_functions(world: &mut World) { ) .register_documented( "mul", - |_self: Val<::bevy_math::Isometry3d>, rhs: Val<::bevy_math::prelude::Dir3>| { - let output: Val<::bevy_math::prelude::Dir3> = { + |_self: Val<::bevy_math::Isometry3d>, rhs: Val<::bevy_math::Vec3>| { + let output: Val<::bevy_math::Vec3> = { + { + let output: Val<::bevy_math::Vec3> = <::bevy_math::Isometry3d as ::core::ops::Mul< + ::bevy_math::Vec3, + >>::mul(_self.into_inner(), rhs.into_inner()) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::bevy_math::Isometry3d>, rhs: Val<::bevy_math::Vec3A>| { + let output: Val<::bevy_math::Vec3A> = { { - let output: Val<::bevy_math::prelude::Dir3> = <::bevy_math::Isometry3d as ::core::ops::Mul< - ::bevy_math::prelude::Dir3, + let output: Val<::bevy_math::Vec3A> = <::bevy_math::Isometry3d as ::core::ops::Mul< + ::bevy_math::Vec3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output @@ -653,86 +795,214 @@ pub(crate) fn register_isometry_3_d_functions(world: &mut World) { >(); } pub(crate) fn register_ray_2_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<::bevy_math::Ray2d>::new( - world, - ) - .register_documented( - "clone", - |_self: Ref<::bevy_math::Ray2d>| { - let output: Val<::bevy_math::Ray2d> = { - { - let output: Val<::bevy_math::Ray2d> = - <::bevy_math::Ray2d as ::core::clone::Clone>::clone(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::Ray2d>, other: Ref<::bevy_math::Ray2d>| { - let output: bool = { - { - let output: bool = <::bevy_math::Ray2d as ::core::cmp::PartialEq< - ::bevy_math::Ray2d, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::Ray2d, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::Ray2d>| { + let output: Val<::bevy_math::Ray2d> = { + { + let output: Val<::bevy_math::Ray2d> = <::bevy_math::Ray2d as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_math::Ray2d>, other: Ref<::bevy_math::Ray2d>| { + let output: bool = { + { + let output: bool = <::bevy_math::Ray2d as ::core::cmp::PartialEq< + ::bevy_math::Ray2d, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "get_point", + |_self: Ref<::bevy_math::Ray2d>, distance: f32| { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = ::bevy_math::Ray2d::get_point( + &_self, + distance, + ) + .into(); + output + } + }; + output + }, + " Get a point at a given distance along the ray", + &["_self", "distance"], + ) + .register_documented( + "intersect_plane", + | + _self: Ref<::bevy_math::Ray2d>, + plane_origin: Val<::bevy_math::Vec2>, + plane: Val<::bevy_math::primitives::Plane2d>| + { + let output: ::core::option::Option = { + { + let output: ::core::option::Option = ::bevy_math::Ray2d::intersect_plane( + &_self, + plane_origin.into_inner(), + plane.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Get the distance to a plane if the ray intersects it", + &["_self", "plane_origin", "plane"], + ) + .register_documented( + "new", + |origin: Val<::bevy_math::Vec2>, direction: Val<::bevy_math::Dir2>| { + let output: Val<::bevy_math::Ray2d> = { + { + let output: Val<::bevy_math::Ray2d> = ::bevy_math::Ray2d::new( + origin.into_inner(), + direction.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new `Ray2d` from a given origin and direction", + &["origin", "direction"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::bevy_math::Ray2d, bevy_mod_scripting_bindings::MarkAsGenerated>(); + .register_type_data::< + ::bevy_math::Ray2d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_ray_3_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<::bevy_math::Ray3d>::new( - world, - ) - .register_documented( - "clone", - |_self: Ref<::bevy_math::Ray3d>| { - let output: Val<::bevy_math::Ray3d> = { - { - let output: Val<::bevy_math::Ray3d> = - <::bevy_math::Ray3d as ::core::clone::Clone>::clone(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::Ray3d>, other: Ref<::bevy_math::Ray3d>| { - let output: bool = { - { - let output: bool = <::bevy_math::Ray3d as ::core::cmp::PartialEq< - ::bevy_math::Ray3d, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::Ray3d, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::Ray3d>| { + let output: Val<::bevy_math::Ray3d> = { + { + let output: Val<::bevy_math::Ray3d> = <::bevy_math::Ray3d as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_math::Ray3d>, other: Ref<::bevy_math::Ray3d>| { + let output: bool = { + { + let output: bool = <::bevy_math::Ray3d as ::core::cmp::PartialEq< + ::bevy_math::Ray3d, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "get_point", + |_self: Ref<::bevy_math::Ray3d>, distance: f32| { + let output: Val<::bevy_math::Vec3> = { + { + let output: Val<::bevy_math::Vec3> = ::bevy_math::Ray3d::get_point( + &_self, + distance, + ) + .into(); + output + } + }; + output + }, + " Get a point at a given distance along the ray", + &["_self", "distance"], + ) + .register_documented( + "intersect_plane", + | + _self: Ref<::bevy_math::Ray3d>, + plane_origin: Val<::bevy_math::Vec3>, + plane: Val<::bevy_math::primitives::InfinitePlane3d>| + { + let output: ::core::option::Option = { + { + let output: ::core::option::Option = ::bevy_math::Ray3d::intersect_plane( + &_self, + plane_origin.into_inner(), + plane.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Get the distance to a plane if the ray intersects it", + &["_self", "plane_origin", "plane"], + ) + .register_documented( + "new", + |origin: Val<::bevy_math::Vec3>, direction: Val<::bevy_math::Dir3>| { + let output: Val<::bevy_math::Ray3d> = { + { + let output: Val<::bevy_math::Ray3d> = ::bevy_math::Ray3d::new( + origin.into_inner(), + direction.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new `Ray3d` from a given origin and direction", + &["origin", "direction"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::bevy_math::Ray3d, bevy_mod_scripting_bindings::MarkAsGenerated>(); + .register_type_data::< + ::bevy_math::Ray3d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_rot_2_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -1027,37 +1297,54 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { ) .register_documented( "mul", - |_self: Val<::bevy_math::Rot2>, rhs: Val<::bevy_math::Rot2>| { - let output: Val<::bevy_math::Rot2> = { + |_self: Val<::bevy_math::Rot2>, direction: Val<::bevy_math::Dir2>| { + let output: Val<::bevy_math::Dir2> = { { - let output: Val<::bevy_math::Rot2> = <::bevy_math::Rot2 as ::core::ops::Mul< - ::bevy_math::Rot2, - >>::mul(_self.into_inner(), rhs.into_inner()) + let output: Val<::bevy_math::Dir2> = <::bevy_math::Rot2 as ::core::ops::Mul< + ::bevy_math::Dir2, + >>::mul(_self.into_inner(), direction.into_inner()) .into(); output } }; output }, - "", - &["_self", "rhs"], + " Rotates the [`Dir2`] using a [`Rot2`].", + &["_self", "direction"], ) .register_documented( "mul", - |_self: Val<::bevy_math::Rot2>, direction: Val<::bevy_math::prelude::Dir2>| { - let output: Val<::bevy_math::prelude::Dir2> = { + |_self: Val<::bevy_math::Rot2>, rhs: Val<::bevy_math::Rot2>| { + let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::prelude::Dir2> = <::bevy_math::Rot2 as ::core::ops::Mul< - ::bevy_math::prelude::Dir2, - >>::mul(_self.into_inner(), direction.into_inner()) + let output: Val<::bevy_math::Rot2> = <::bevy_math::Rot2 as ::core::ops::Mul< + ::bevy_math::Rot2, + >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } }; output }, - " Rotates the [`Dir2`] using a [`Rot2`].", - &["_self", "direction"], + "", + &["_self", "rhs"], + ) + .register_documented( + "mul", + |_self: Val<::bevy_math::Rot2>, rhs: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = <::bevy_math::Rot2 as ::core::ops::Mul< + ::bevy_math::Vec2, + >>::mul(_self.into_inner(), rhs.into_inner()) + .into(); + output + } + }; + output + }, + " Rotates a [`Vec2`] by a [`Rot2`].", + &["_self", "rhs"], ) .register_documented( "nlerp", @@ -1168,18 +1455,38 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::bevy_math::Rot2, bevy_mod_scripting_bindings::MarkAsGenerated>(); + .register_type_data::< + ::bevy_math::Rot2, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_dir_2_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::prelude::Dir2, + ::bevy_math::Dir2, >::new(world) + .register_documented( + "as_vec2", + |_self: Ref<::bevy_math::Dir2>| { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = ::bevy_math::Dir2::as_vec2( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the inner [`Vec2`]", + &["_self"], + ) .register_documented( "clone", - |_self: Ref<::bevy_math::prelude::Dir2>| { - let output: Val<::bevy_math::prelude::Dir2> = { + |_self: Ref<::bevy_math::Dir2>| { + let output: Val<::bevy_math::Dir2> = { { - let output: Val<::bevy_math::prelude::Dir2> = <::bevy_math::prelude::Dir2 as ::core::clone::Clone>::clone( + let output: Val<::bevy_math::Dir2> = <::bevy_math::Dir2 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -1193,14 +1500,11 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_math::prelude::Dir2>, - other: Ref<::bevy_math::prelude::Dir2>| - { + |_self: Ref<::bevy_math::Dir2>, other: Ref<::bevy_math::Dir2>| { let output: bool = { { - let output: bool = <::bevy_math::prelude::Dir2 as ::core::cmp::PartialEq< - ::bevy_math::prelude::Dir2, + let output: bool = <::bevy_math::Dir2 as ::core::cmp::PartialEq< + ::bevy_math::Dir2, >>::eq(&_self, &other) .into(); output @@ -1213,10 +1517,10 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { ) .register_documented( "fast_renormalize", - |_self: Val<::bevy_math::prelude::Dir2>| { - let output: Val<::bevy_math::prelude::Dir2> = { + |_self: Val<::bevy_math::Dir2>| { + let output: Val<::bevy_math::Dir2> = { { - let output: Val<::bevy_math::prelude::Dir2> = ::bevy_math::prelude::Dir2::fast_renormalize( + let output: Val<::bevy_math::Dir2> = ::bevy_math::Dir2::fast_renormalize( _self.into_inner(), ) .into(); @@ -1231,9 +1535,9 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { .register_documented( "from_xy_unchecked", |x: f32, y: f32| { - let output: Val<::bevy_math::prelude::Dir2> = { + let output: Val<::bevy_math::Dir2> = { { - let output: Val<::bevy_math::prelude::Dir2> = ::bevy_math::prelude::Dir2::from_xy_unchecked( + let output: Val<::bevy_math::Dir2> = ::bevy_math::Dir2::from_xy_unchecked( x, y, ) @@ -1246,12 +1550,29 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { " Create a direction from its `x` and `y` components, assuming the resulting vector is normalized.\n # Warning\n The vector produced from `x` and `y` must be normalized, i.e its length must be `1.0`.", &["x", "y"], ) + .register_documented( + "mul", + |_self: Val<::bevy_math::Dir2>, rhs: f32| { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = <::bevy_math::Dir2 as ::core::ops::Mul< + f32, + >>::mul(_self.into_inner(), rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "neg", - |_self: Val<::bevy_math::prelude::Dir2>| { - let output: Val<::bevy_math::prelude::Dir2> = { + |_self: Val<::bevy_math::Dir2>| { + let output: Val<::bevy_math::Dir2> = { { - let output: Val<::bevy_math::prelude::Dir2> = <::bevy_math::prelude::Dir2 as ::core::ops::Neg>::neg( + let output: Val<::bevy_math::Dir2> = <::bevy_math::Dir2 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -1263,15 +1584,29 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "new_unchecked", + |value: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_math::Dir2> = { + { + let output: Val<::bevy_math::Dir2> = ::bevy_math::Dir2::new_unchecked( + value.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a [`Dir2`] from a [`Vec2`] that is already normalized.\n # Warning\n `value` must be normalized, i.e its length must be `1.0`.", + &["value"], + ) .register_documented( "rotation_from", - | - _self: Val<::bevy_math::prelude::Dir2>, - other: Val<::bevy_math::prelude::Dir2>| - { + |_self: Val<::bevy_math::Dir2>, other: Val<::bevy_math::Dir2>| { let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::Rot2> = ::bevy_math::prelude::Dir2::rotation_from( + let output: Val<::bevy_math::Rot2> = ::bevy_math::Dir2::rotation_from( _self.into_inner(), other.into_inner(), ) @@ -1286,10 +1621,10 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { ) .register_documented( "rotation_from_x", - |_self: Val<::bevy_math::prelude::Dir2>| { + |_self: Val<::bevy_math::Dir2>| { let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::Rot2> = ::bevy_math::prelude::Dir2::rotation_from_x( + let output: Val<::bevy_math::Rot2> = ::bevy_math::Dir2::rotation_from_x( _self.into_inner(), ) .into(); @@ -1303,10 +1638,10 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { ) .register_documented( "rotation_from_y", - |_self: Val<::bevy_math::prelude::Dir2>| { + |_self: Val<::bevy_math::Dir2>| { let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::Rot2> = ::bevy_math::prelude::Dir2::rotation_from_y( + let output: Val<::bevy_math::Rot2> = ::bevy_math::Dir2::rotation_from_y( _self.into_inner(), ) .into(); @@ -1320,13 +1655,10 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { ) .register_documented( "rotation_to", - | - _self: Val<::bevy_math::prelude::Dir2>, - other: Val<::bevy_math::prelude::Dir2>| - { + |_self: Val<::bevy_math::Dir2>, other: Val<::bevy_math::Dir2>| { let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::Rot2> = ::bevy_math::prelude::Dir2::rotation_to( + let output: Val<::bevy_math::Rot2> = ::bevy_math::Dir2::rotation_to( _self.into_inner(), other.into_inner(), ) @@ -1341,10 +1673,10 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { ) .register_documented( "rotation_to_x", - |_self: Val<::bevy_math::prelude::Dir2>| { + |_self: Val<::bevy_math::Dir2>| { let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::Rot2> = ::bevy_math::prelude::Dir2::rotation_to_x( + let output: Val<::bevy_math::Rot2> = ::bevy_math::Dir2::rotation_to_x( _self.into_inner(), ) .into(); @@ -1358,10 +1690,10 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { ) .register_documented( "rotation_to_y", - |_self: Val<::bevy_math::prelude::Dir2>| { + |_self: Val<::bevy_math::Dir2>| { let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::Rot2> = ::bevy_math::prelude::Dir2::rotation_to_y( + let output: Val<::bevy_math::Rot2> = ::bevy_math::Dir2::rotation_to_y( _self.into_inner(), ) .into(); @@ -1375,14 +1707,10 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { ) .register_documented( "slerp", - | - _self: Val<::bevy_math::prelude::Dir2>, - rhs: Val<::bevy_math::prelude::Dir2>, - s: f32| - { - let output: Val<::bevy_math::prelude::Dir2> = { + |_self: Val<::bevy_math::Dir2>, rhs: Val<::bevy_math::Dir2>, s: f32| { + let output: Val<::bevy_math::Dir2> = { { - let output: Val<::bevy_math::prelude::Dir2> = ::bevy_math::prelude::Dir2::slerp( + let output: Val<::bevy_math::Dir2> = ::bevy_math::Dir2::slerp( _self.into_inner(), rhs.into_inner(), s, @@ -1400,20 +1728,37 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::prelude::Dir2, + ::bevy_math::Dir2, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_dir_3_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::prelude::Dir3, + ::bevy_math::Dir3, >::new(world) + .register_documented( + "as_vec3", + |_self: Ref<::bevy_math::Dir3>| { + let output: Val<::bevy_math::Vec3> = { + { + let output: Val<::bevy_math::Vec3> = ::bevy_math::Dir3::as_vec3( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the inner [`Vec3`]", + &["_self"], + ) .register_documented( "clone", - |_self: Ref<::bevy_math::prelude::Dir3>| { - let output: Val<::bevy_math::prelude::Dir3> = { + |_self: Ref<::bevy_math::Dir3>| { + let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::prelude::Dir3> = <::bevy_math::prelude::Dir3 as ::core::clone::Clone>::clone( + let output: Val<::bevy_math::Dir3> = <::bevy_math::Dir3 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -1427,14 +1772,11 @@ pub(crate) fn register_dir_3_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_math::prelude::Dir3>, - other: Ref<::bevy_math::prelude::Dir3>| - { + |_self: Ref<::bevy_math::Dir3>, other: Ref<::bevy_math::Dir3>| { let output: bool = { { - let output: bool = <::bevy_math::prelude::Dir3 as ::core::cmp::PartialEq< - ::bevy_math::prelude::Dir3, + let output: bool = <::bevy_math::Dir3 as ::core::cmp::PartialEq< + ::bevy_math::Dir3, >>::eq(&_self, &other) .into(); output @@ -1447,10 +1789,10 @@ pub(crate) fn register_dir_3_functions(world: &mut World) { ) .register_documented( "fast_renormalize", - |_self: Val<::bevy_math::prelude::Dir3>| { - let output: Val<::bevy_math::prelude::Dir3> = { + |_self: Val<::bevy_math::Dir3>| { + let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::prelude::Dir3> = ::bevy_math::prelude::Dir3::fast_renormalize( + let output: Val<::bevy_math::Dir3> = ::bevy_math::Dir3::fast_renormalize( _self.into_inner(), ) .into(); @@ -1465,9 +1807,9 @@ pub(crate) fn register_dir_3_functions(world: &mut World) { .register_documented( "from_xyz_unchecked", |x: f32, y: f32, z: f32| { - let output: Val<::bevy_math::prelude::Dir3> = { + let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::prelude::Dir3> = ::bevy_math::prelude::Dir3::from_xyz_unchecked( + let output: Val<::bevy_math::Dir3> = ::bevy_math::Dir3::from_xyz_unchecked( x, y, z, @@ -1481,12 +1823,29 @@ pub(crate) fn register_dir_3_functions(world: &mut World) { " Create a direction from its `x`, `y`, and `z` components, assuming the resulting vector is normalized.\n # Warning\n The vector produced from `x`, `y`, and `z` must be normalized, i.e its length must be `1.0`.", &["x", "y", "z"], ) + .register_documented( + "mul", + |_self: Val<::bevy_math::Dir3>, rhs: f32| { + let output: Val<::bevy_math::Vec3> = { + { + let output: Val<::bevy_math::Vec3> = <::bevy_math::Dir3 as ::core::ops::Mul< + f32, + >>::mul(_self.into_inner(), rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "neg", - |_self: Val<::bevy_math::prelude::Dir3>| { - let output: Val<::bevy_math::prelude::Dir3> = { + |_self: Val<::bevy_math::Dir3>| { + let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::prelude::Dir3> = <::bevy_math::prelude::Dir3 as ::core::ops::Neg>::neg( + let output: Val<::bevy_math::Dir3> = <::bevy_math::Dir3 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -1498,16 +1857,29 @@ pub(crate) fn register_dir_3_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "new_unchecked", + |value: Val<::bevy_math::Vec3>| { + let output: Val<::bevy_math::Dir3> = { + { + let output: Val<::bevy_math::Dir3> = ::bevy_math::Dir3::new_unchecked( + value.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a [`Dir3`] from a [`Vec3`] that is already normalized.\n # Warning\n `value` must be normalized, i.e its length must be `1.0`.", + &["value"], + ) .register_documented( "slerp", - | - _self: Val<::bevy_math::prelude::Dir3>, - rhs: Val<::bevy_math::prelude::Dir3>, - s: f32| - { - let output: Val<::bevy_math::prelude::Dir3> = { + |_self: Val<::bevy_math::Dir3>, rhs: Val<::bevy_math::Dir3>, s: f32| { + let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::prelude::Dir3> = ::bevy_math::prelude::Dir3::slerp( + let output: Val<::bevy_math::Dir3> = ::bevy_math::Dir3::slerp( _self.into_inner(), rhs.into_inner(), s, @@ -1525,20 +1897,37 @@ pub(crate) fn register_dir_3_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::prelude::Dir3, + ::bevy_math::Dir3, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_dir_3_a_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::prelude::Dir3A, + ::bevy_math::Dir3A, >::new(world) + .register_documented( + "as_vec3a", + |_self: Ref<::bevy_math::Dir3A>| { + let output: Val<::bevy_math::Vec3A> = { + { + let output: Val<::bevy_math::Vec3A> = ::bevy_math::Dir3A::as_vec3a( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the inner [`Vec3A`]", + &["_self"], + ) .register_documented( "clone", - |_self: Ref<::bevy_math::prelude::Dir3A>| { - let output: Val<::bevy_math::prelude::Dir3A> = { + |_self: Ref<::bevy_math::Dir3A>| { + let output: Val<::bevy_math::Dir3A> = { { - let output: Val<::bevy_math::prelude::Dir3A> = <::bevy_math::prelude::Dir3A as ::core::clone::Clone>::clone( + let output: Val<::bevy_math::Dir3A> = <::bevy_math::Dir3A as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -1552,14 +1941,11 @@ pub(crate) fn register_dir_3_a_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_math::prelude::Dir3A>, - other: Ref<::bevy_math::prelude::Dir3A>| - { + |_self: Ref<::bevy_math::Dir3A>, other: Ref<::bevy_math::Dir3A>| { let output: bool = { { - let output: bool = <::bevy_math::prelude::Dir3A as ::core::cmp::PartialEq< - ::bevy_math::prelude::Dir3A, + let output: bool = <::bevy_math::Dir3A as ::core::cmp::PartialEq< + ::bevy_math::Dir3A, >>::eq(&_self, &other) .into(); output @@ -1572,10 +1958,10 @@ pub(crate) fn register_dir_3_a_functions(world: &mut World) { ) .register_documented( "fast_renormalize", - |_self: Val<::bevy_math::prelude::Dir3A>| { - let output: Val<::bevy_math::prelude::Dir3A> = { + |_self: Val<::bevy_math::Dir3A>| { + let output: Val<::bevy_math::Dir3A> = { { - let output: Val<::bevy_math::prelude::Dir3A> = ::bevy_math::prelude::Dir3A::fast_renormalize( + let output: Val<::bevy_math::Dir3A> = ::bevy_math::Dir3A::fast_renormalize( _self.into_inner(), ) .into(); @@ -1590,9 +1976,9 @@ pub(crate) fn register_dir_3_a_functions(world: &mut World) { .register_documented( "from_xyz_unchecked", |x: f32, y: f32, z: f32| { - let output: Val<::bevy_math::prelude::Dir3A> = { + let output: Val<::bevy_math::Dir3A> = { { - let output: Val<::bevy_math::prelude::Dir3A> = ::bevy_math::prelude::Dir3A::from_xyz_unchecked( + let output: Val<::bevy_math::Dir3A> = ::bevy_math::Dir3A::from_xyz_unchecked( x, y, z, @@ -1606,12 +1992,29 @@ pub(crate) fn register_dir_3_a_functions(world: &mut World) { " Create a direction from its `x`, `y`, and `z` components, assuming the resulting vector is normalized.\n # Warning\n The vector produced from `x`, `y`, and `z` must be normalized, i.e its length must be `1.0`.", &["x", "y", "z"], ) + .register_documented( + "mul", + |_self: Val<::bevy_math::Dir3A>, rhs: f32| { + let output: Val<::bevy_math::Vec3A> = { + { + let output: Val<::bevy_math::Vec3A> = <::bevy_math::Dir3A as ::core::ops::Mul< + f32, + >>::mul(_self.into_inner(), rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "neg", - |_self: Val<::bevy_math::prelude::Dir3A>| { - let output: Val<::bevy_math::prelude::Dir3A> = { + |_self: Val<::bevy_math::Dir3A>| { + let output: Val<::bevy_math::Dir3A> = { { - let output: Val<::bevy_math::prelude::Dir3A> = <::bevy_math::prelude::Dir3A as ::core::ops::Neg>::neg( + let output: Val<::bevy_math::Dir3A> = <::bevy_math::Dir3A as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -1623,16 +2026,29 @@ pub(crate) fn register_dir_3_a_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "new_unchecked", + |value: Val<::bevy_math::Vec3A>| { + let output: Val<::bevy_math::Dir3A> = { + { + let output: Val<::bevy_math::Dir3A> = ::bevy_math::Dir3A::new_unchecked( + value.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a [`Dir3A`] from a [`Vec3A`] that is already normalized.\n # Warning\n `value` must be normalized, i.e its length must be `1.0`.", + &["value"], + ) .register_documented( "slerp", - | - _self: Val<::bevy_math::prelude::Dir3A>, - rhs: Val<::bevy_math::prelude::Dir3A>, - s: f32| - { - let output: Val<::bevy_math::prelude::Dir3A> = { + |_self: Val<::bevy_math::Dir3A>, rhs: Val<::bevy_math::Dir3A>, s: f32| { + let output: Val<::bevy_math::Dir3A> = { { - let output: Val<::bevy_math::prelude::Dir3A> = ::bevy_math::prelude::Dir3A::slerp( + let output: Val<::bevy_math::Dir3A> = ::bevy_math::Dir3A::slerp( _self.into_inner(), rhs.into_inner(), s, @@ -1650,20 +2066,20 @@ pub(crate) fn register_dir_3_a_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::prelude::Dir3A, + ::bevy_math::Dir3A, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_i_rect_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::prelude::IRect, + ::bevy_math::IRect, >::new(world) .register_documented( "as_rect", - |_self: Ref<::bevy_math::prelude::IRect>| { - let output: Val<::bevy_math::prelude::Rect> = { + |_self: Ref<::bevy_math::IRect>| { + let output: Val<::bevy_math::Rect> = { { - let output: Val<::bevy_math::prelude::Rect> = ::bevy_math::prelude::IRect::as_rect( + let output: Val<::bevy_math::Rect> = ::bevy_math::IRect::as_rect( &_self, ) .into(); @@ -1677,10 +2093,10 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { ) .register_documented( "as_urect", - |_self: Ref<::bevy_math::prelude::IRect>| { - let output: Val<::bevy_math::prelude::URect> = { + |_self: Ref<::bevy_math::IRect>| { + let output: Val<::bevy_math::URect> = { { - let output: Val<::bevy_math::prelude::URect> = ::bevy_math::prelude::IRect::as_urect( + let output: Val<::bevy_math::URect> = ::bevy_math::IRect::as_urect( &_self, ) .into(); @@ -1694,10 +2110,10 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { ) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_math::prelude::IRect>| { + |_self: Ref<::bevy_math::IRect>| { let output: () = { { - let output: () = <::bevy_math::prelude::IRect as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_math::IRect as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -1709,12 +2125,29 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "center", + |_self: Ref<::bevy_math::IRect>| { + let output: Val<::bevy_math::IVec2> = { + { + let output: Val<::bevy_math::IVec2> = ::bevy_math::IRect::center( + &_self, + ) + .into(); + output + } + }; + output + }, + " The center point of the rectangle.\n # Rounding Behavior\n If the (min + max) contains odd numbers they will be rounded down to the nearest whole number when calculating the center.\n # Examples\n ```\n # use bevy_math::{IRect, IVec2};\n let r = IRect::new(0, 0, 5, 2); // w=5 h=2\n assert_eq!(r.center(), IVec2::new(2, 1));\n ```", + &["_self"], + ) .register_documented( "clone", - |_self: Ref<::bevy_math::prelude::IRect>| { - let output: Val<::bevy_math::prelude::IRect> = { + |_self: Ref<::bevy_math::IRect>| { + let output: Val<::bevy_math::IRect> = { { - let output: Val<::bevy_math::prelude::IRect> = <::bevy_math::prelude::IRect as ::core::clone::Clone>::clone( + let output: Val<::bevy_math::IRect> = <::bevy_math::IRect as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -1726,16 +2159,31 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "contains", + |_self: Ref<::bevy_math::IRect>, point: Val<::bevy_math::IVec2>| { + let output: bool = { + { + let output: bool = ::bevy_math::IRect::contains( + &_self, + point.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Check if a point lies within this rectangle, inclusive of its edges.\n # Examples\n ```\n # use bevy_math::IRect;\n let r = IRect::new(0, 0, 5, 1); // w=5 h=1\n assert!(r.contains(r.center()));\n assert!(r.contains(r.min));\n assert!(r.contains(r.max));\n ```", + &["_self", "point"], + ) .register_documented( "eq", - | - _self: Ref<::bevy_math::prelude::IRect>, - other: Ref<::bevy_math::prelude::IRect>| - { + |_self: Ref<::bevy_math::IRect>, other: Ref<::bevy_math::IRect>| { let output: bool = { { - let output: bool = <::bevy_math::prelude::IRect as ::core::cmp::PartialEq< - ::bevy_math::prelude::IRect, + let output: bool = <::bevy_math::IRect as ::core::cmp::PartialEq< + ::bevy_math::IRect, >>::eq(&_self, &other) .into(); output @@ -1746,13 +2194,83 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { "", &["_self", "other"], ) + .register_documented( + "from_center_half_size", + |origin: Val<::bevy_math::IVec2>, half_size: Val<::bevy_math::IVec2>| { + let output: Val<::bevy_math::IRect> = { + { + let output: Val<::bevy_math::IRect> = ::bevy_math::IRect::from_center_half_size( + origin.into_inner(), + half_size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new rectangle from its center and half-size.\n # Panics\n This method panics if any of the components of the half-size is negative.\n # Examples\n ```\n # use bevy_math::{IRect, IVec2};\n let r = IRect::from_center_half_size(IVec2::ZERO, IVec2::ONE); // w=2 h=2\n assert_eq!(r.min, IVec2::splat(-1));\n assert_eq!(r.max, IVec2::splat(1));\n ```", + &["origin", "half_size"], + ) + .register_documented( + "from_center_size", + |origin: Val<::bevy_math::IVec2>, size: Val<::bevy_math::IVec2>| { + let output: Val<::bevy_math::IRect> = { + { + let output: Val<::bevy_math::IRect> = ::bevy_math::IRect::from_center_size( + origin.into_inner(), + size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new rectangle from its center and size.\n # Rounding Behavior\n If the size contains odd numbers they will be rounded down to the nearest whole number.\n # Panics\n This method panics if any of the components of the size is negative.\n # Examples\n ```\n # use bevy_math::{IRect, IVec2};\n let r = IRect::from_center_size(IVec2::ZERO, IVec2::new(3, 2)); // w=2 h=2\n assert_eq!(r.min, IVec2::splat(-1));\n assert_eq!(r.max, IVec2::splat(1));\n ```", + &["origin", "size"], + ) + .register_documented( + "from_corners", + |p0: Val<::bevy_math::IVec2>, p1: Val<::bevy_math::IVec2>| { + let output: Val<::bevy_math::IRect> = { + { + let output: Val<::bevy_math::IRect> = ::bevy_math::IRect::from_corners( + p0.into_inner(), + p1.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new rectangle from two corner points.\n The two points do not need to be the minimum and/or maximum corners.\n They only need to be two opposite corners.\n # Examples\n ```\n # use bevy_math::{IRect, IVec2};\n // Unit rect from [0,0] to [1,1]\n let r = IRect::from_corners(IVec2::ZERO, IVec2::ONE); // w=1 h=1\n // Same; the points do not need to be ordered\n let r = IRect::from_corners(IVec2::ONE, IVec2::ZERO); // w=1 h=1\n ```", + &["p0", "p1"], + ) + .register_documented( + "half_size", + |_self: Ref<::bevy_math::IRect>| { + let output: Val<::bevy_math::IVec2> = { + { + let output: Val<::bevy_math::IVec2> = ::bevy_math::IRect::half_size( + &_self, + ) + .into(); + output + } + }; + output + }, + " Rectangle half-size.\n # Rounding Behavior\n If the full size contains odd numbers they will be rounded down to the nearest whole number when calculating the half size.\n # Examples\n ```\n # use bevy_math::{IRect, IVec2};\n let r = IRect::new(0, 0, 4, 3); // w=4 h=3\n assert_eq!(r.half_size(), IVec2::new(2, 1));\n ```", + &["_self"], + ) .register_documented( "height", - |_self: Ref<::bevy_math::prelude::IRect>| { + |_self: Ref<::bevy_math::IRect>| { let output: i32 = { { - let output: i32 = ::bevy_math::prelude::IRect::height(&_self) - .into(); + let output: i32 = ::bevy_math::IRect::height(&_self).into(); output } }; @@ -1763,10 +2281,10 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { ) .register_documented( "inflate", - |_self: Ref<::bevy_math::prelude::IRect>, expansion: i32| { - let output: Val<::bevy_math::prelude::IRect> = { + |_self: Ref<::bevy_math::IRect>, expansion: i32| { + let output: Val<::bevy_math::IRect> = { { - let output: Val<::bevy_math::prelude::IRect> = ::bevy_math::prelude::IRect::inflate( + let output: Val<::bevy_math::IRect> = ::bevy_math::IRect::inflate( &_self, expansion, ) @@ -1781,13 +2299,10 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { ) .register_documented( "intersect", - | - _self: Ref<::bevy_math::prelude::IRect>, - other: Val<::bevy_math::prelude::IRect>| - { - let output: Val<::bevy_math::prelude::IRect> = { + |_self: Ref<::bevy_math::IRect>, other: Val<::bevy_math::IRect>| { + let output: Val<::bevy_math::IRect> = { { - let output: Val<::bevy_math::prelude::IRect> = ::bevy_math::prelude::IRect::intersect( + let output: Val<::bevy_math::IRect> = ::bevy_math::IRect::intersect( &_self, other.into_inner(), ) @@ -1802,11 +2317,10 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { ) .register_documented( "is_empty", - |_self: Ref<::bevy_math::prelude::IRect>| { + |_self: Ref<::bevy_math::IRect>| { let output: bool = { { - let output: bool = ::bevy_math::prelude::IRect::is_empty(&_self) - .into(); + let output: bool = ::bevy_math::IRect::is_empty(&_self).into(); output } }; @@ -1818,9 +2332,9 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { .register_documented( "new", |x0: i32, y0: i32, x1: i32, y1: i32| { - let output: Val<::bevy_math::prelude::IRect> = { + let output: Val<::bevy_math::IRect> = { { - let output: Val<::bevy_math::prelude::IRect> = ::bevy_math::prelude::IRect::new( + let output: Val<::bevy_math::IRect> = ::bevy_math::IRect::new( x0, y0, x1, @@ -1835,15 +2349,29 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { " Create a new rectangle from two corner points.\n The two points do not need to be the minimum and/or maximum corners.\n They only need to be two opposite corners.\n # Examples\n ```\n # use bevy_math::IRect;\n let r = IRect::new(0, 4, 10, 6); // w=10 h=2\n let r = IRect::new(2, 3, 5, -1); // w=3 h=4\n ```", &["x0", "y0", "x1", "y1"], ) + .register_documented( + "size", + |_self: Ref<::bevy_math::IRect>| { + let output: Val<::bevy_math::IVec2> = { + { + let output: Val<::bevy_math::IVec2> = ::bevy_math::IRect::size( + &_self, + ) + .into(); + output + } + }; + output + }, + " Rectangle size.\n # Examples\n ```\n # use bevy_math::{IRect, IVec2};\n let r = IRect::new(0, 0, 5, 1); // w=5 h=1\n assert_eq!(r.size(), IVec2::new(5, 1));\n ```", + &["_self"], + ) .register_documented( "union", - | - _self: Ref<::bevy_math::prelude::IRect>, - other: Val<::bevy_math::prelude::IRect>| - { - let output: Val<::bevy_math::prelude::IRect> = { + |_self: Ref<::bevy_math::IRect>, other: Val<::bevy_math::IRect>| { + let output: Val<::bevy_math::IRect> = { { - let output: Val<::bevy_math::prelude::IRect> = ::bevy_math::prelude::IRect::union( + let output: Val<::bevy_math::IRect> = ::bevy_math::IRect::union( &_self, other.into_inner(), ) @@ -1856,13 +2384,30 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { " Build a new rectangle formed of the union of this rectangle and another rectangle.\n The union is the smallest rectangle enclosing both rectangles.\n # Examples\n ```\n # use bevy_math::{IRect, IVec2};\n let r1 = IRect::new(0, 0, 5, 1); // w=5 h=1\n let r2 = IRect::new(1, -1, 3, 3); // w=2 h=4\n let r = r1.union(r2);\n assert_eq!(r.min, IVec2::new(0, -1));\n assert_eq!(r.max, IVec2::new(5, 3));\n ```", &["_self", "other"], ) + .register_documented( + "union_point", + |_self: Ref<::bevy_math::IRect>, other: Val<::bevy_math::IVec2>| { + let output: Val<::bevy_math::IRect> = { + { + let output: Val<::bevy_math::IRect> = ::bevy_math::IRect::union_point( + &_self, + other.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Build a new rectangle formed of the union of this rectangle and a point.\n The union is the smallest rectangle enclosing both the rectangle and the point. If the\n point is already inside the rectangle, this method returns a copy of the rectangle.\n # Examples\n ```\n # use bevy_math::{IRect, IVec2};\n let r = IRect::new(0, 0, 5, 1); // w=5 h=1\n let u = r.union_point(IVec2::new(3, 6));\n assert_eq!(u.min, IVec2::ZERO);\n assert_eq!(u.max, IVec2::new(5, 6));\n ```", + &["_self", "other"], + ) .register_documented( "width", - |_self: Ref<::bevy_math::prelude::IRect>| { + |_self: Ref<::bevy_math::IRect>| { let output: i32 = { { - let output: i32 = ::bevy_math::prelude::IRect::width(&_self) - .into(); + let output: i32 = ::bevy_math::IRect::width(&_self).into(); output } }; @@ -1875,20 +2420,20 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::prelude::IRect, + ::bevy_math::IRect, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_rect_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::prelude::Rect, + ::bevy_math::Rect, >::new(world) .register_documented( "as_irect", - |_self: Ref<::bevy_math::prelude::Rect>| { - let output: Val<::bevy_math::prelude::IRect> = { + |_self: Ref<::bevy_math::Rect>| { + let output: Val<::bevy_math::IRect> = { { - let output: Val<::bevy_math::prelude::IRect> = ::bevy_math::prelude::Rect::as_irect( + let output: Val<::bevy_math::IRect> = ::bevy_math::Rect::as_irect( &_self, ) .into(); @@ -1902,10 +2447,10 @@ pub(crate) fn register_rect_functions(world: &mut World) { ) .register_documented( "as_urect", - |_self: Ref<::bevy_math::prelude::Rect>| { - let output: Val<::bevy_math::prelude::URect> = { + |_self: Ref<::bevy_math::Rect>| { + let output: Val<::bevy_math::URect> = { { - let output: Val<::bevy_math::prelude::URect> = ::bevy_math::prelude::Rect::as_urect( + let output: Val<::bevy_math::URect> = ::bevy_math::Rect::as_urect( &_self, ) .into(); @@ -1918,11 +2463,11 @@ pub(crate) fn register_rect_functions(world: &mut World) { &["_self"], ) .register_documented( - "clone", - |_self: Ref<::bevy_math::prelude::Rect>| { - let output: Val<::bevy_math::prelude::Rect> = { + "center", + |_self: Ref<::bevy_math::Rect>| { + let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::prelude::Rect> = <::bevy_math::prelude::Rect as ::core::clone::Clone>::clone( + let output: Val<::bevy_math::Vec2> = ::bevy_math::Rect::center( &_self, ) .into(); @@ -1931,20 +2476,17 @@ pub(crate) fn register_rect_functions(world: &mut World) { }; output }, - "", + " The center point of the rectangle.\n # Examples\n ```\n # use bevy_math::{Rect, Vec2};\n let r = Rect::new(0., 0., 5., 1.); // w=5 h=1\n assert!(r.center().abs_diff_eq(Vec2::new(2.5, 0.5), 1e-5));\n ```", &["_self"], ) .register_documented( - "eq", - | - _self: Ref<::bevy_math::prelude::Rect>, - other: Ref<::bevy_math::prelude::Rect>| - { - let output: bool = { + "clone", + |_self: Ref<::bevy_math::Rect>| { + let output: Val<::bevy_math::Rect> = { { - let output: bool = <::bevy_math::prelude::Rect as ::core::cmp::PartialEq< - ::bevy_math::prelude::Rect, - >>::eq(&_self, &other) + let output: Val<::bevy_math::Rect> = <::bevy_math::Rect as ::core::clone::Clone>::clone( + &_self, + ) .into(); output } @@ -1952,15 +2494,120 @@ pub(crate) fn register_rect_functions(world: &mut World) { output }, "", - &["_self", "other"], + &["_self"], + ) + .register_documented( + "contains", + |_self: Ref<::bevy_math::Rect>, point: Val<::bevy_math::Vec2>| { + let output: bool = { + { + let output: bool = ::bevy_math::Rect::contains( + &_self, + point.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Check if a point lies within this rectangle, inclusive of its edges.\n # Examples\n ```\n # use bevy_math::Rect;\n let r = Rect::new(0., 0., 5., 1.); // w=5 h=1\n assert!(r.contains(r.center()));\n assert!(r.contains(r.min));\n assert!(r.contains(r.max));\n ```", + &["_self", "point"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_math::Rect>, other: Ref<::bevy_math::Rect>| { + let output: bool = { + { + let output: bool = <::bevy_math::Rect as ::core::cmp::PartialEq< + ::bevy_math::Rect, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "from_center_half_size", + |origin: Val<::bevy_math::Vec2>, half_size: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_math::Rect> = { + { + let output: Val<::bevy_math::Rect> = ::bevy_math::Rect::from_center_half_size( + origin.into_inner(), + half_size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new rectangle from its center and half-size.\n # Panics\n This method panics if any of the components of the half-size is negative.\n # Examples\n ```\n # use bevy_math::{Rect, Vec2};\n let r = Rect::from_center_half_size(Vec2::ZERO, Vec2::ONE); // w=2 h=2\n assert!(r.min.abs_diff_eq(Vec2::splat(-1.), 1e-5));\n assert!(r.max.abs_diff_eq(Vec2::splat(1.), 1e-5));\n ```", + &["origin", "half_size"], + ) + .register_documented( + "from_center_size", + |origin: Val<::bevy_math::Vec2>, size: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_math::Rect> = { + { + let output: Val<::bevy_math::Rect> = ::bevy_math::Rect::from_center_size( + origin.into_inner(), + size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new rectangle from its center and size.\n # Panics\n This method panics if any of the components of the size is negative.\n # Examples\n ```\n # use bevy_math::{Rect, Vec2};\n let r = Rect::from_center_size(Vec2::ZERO, Vec2::ONE); // w=1 h=1\n assert!(r.min.abs_diff_eq(Vec2::splat(-0.5), 1e-5));\n assert!(r.max.abs_diff_eq(Vec2::splat(0.5), 1e-5));\n ```", + &["origin", "size"], + ) + .register_documented( + "from_corners", + |p0: Val<::bevy_math::Vec2>, p1: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_math::Rect> = { + { + let output: Val<::bevy_math::Rect> = ::bevy_math::Rect::from_corners( + p0.into_inner(), + p1.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new rectangle from two corner points.\n The two points do not need to be the minimum and/or maximum corners.\n They only need to be two opposite corners.\n # Examples\n ```\n # use bevy_math::{Rect, Vec2};\n // Unit rect from [0,0] to [1,1]\n let r = Rect::from_corners(Vec2::ZERO, Vec2::ONE); // w=1 h=1\n // Same; the points do not need to be ordered\n let r = Rect::from_corners(Vec2::ONE, Vec2::ZERO); // w=1 h=1\n ```", + &["p0", "p1"], + ) + .register_documented( + "half_size", + |_self: Ref<::bevy_math::Rect>| { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = ::bevy_math::Rect::half_size( + &_self, + ) + .into(); + output + } + }; + output + }, + " Rectangle half-size.\n # Examples\n ```\n # use bevy_math::{Rect, Vec2};\n let r = Rect::new(0., 0., 5., 1.); // w=5 h=1\n assert!(r.half_size().abs_diff_eq(Vec2::new(2.5, 0.5), 1e-5));\n ```", + &["_self"], ) .register_documented( "height", - |_self: Ref<::bevy_math::prelude::Rect>| { + |_self: Ref<::bevy_math::Rect>| { let output: f32 = { { - let output: f32 = ::bevy_math::prelude::Rect::height(&_self) - .into(); + let output: f32 = ::bevy_math::Rect::height(&_self).into(); output } }; @@ -1971,10 +2618,10 @@ pub(crate) fn register_rect_functions(world: &mut World) { ) .register_documented( "inflate", - |_self: Ref<::bevy_math::prelude::Rect>, expansion: f32| { - let output: Val<::bevy_math::prelude::Rect> = { + |_self: Ref<::bevy_math::Rect>, expansion: f32| { + let output: Val<::bevy_math::Rect> = { { - let output: Val<::bevy_math::prelude::Rect> = ::bevy_math::prelude::Rect::inflate( + let output: Val<::bevy_math::Rect> = ::bevy_math::Rect::inflate( &_self, expansion, ) @@ -1989,13 +2636,10 @@ pub(crate) fn register_rect_functions(world: &mut World) { ) .register_documented( "intersect", - | - _self: Ref<::bevy_math::prelude::Rect>, - other: Val<::bevy_math::prelude::Rect>| - { - let output: Val<::bevy_math::prelude::Rect> = { + |_self: Ref<::bevy_math::Rect>, other: Val<::bevy_math::Rect>| { + let output: Val<::bevy_math::Rect> = { { - let output: Val<::bevy_math::prelude::Rect> = ::bevy_math::prelude::Rect::intersect( + let output: Val<::bevy_math::Rect> = ::bevy_math::Rect::intersect( &_self, other.into_inner(), ) @@ -2010,11 +2654,10 @@ pub(crate) fn register_rect_functions(world: &mut World) { ) .register_documented( "is_empty", - |_self: Ref<::bevy_math::prelude::Rect>| { + |_self: Ref<::bevy_math::Rect>| { let output: bool = { { - let output: bool = ::bevy_math::prelude::Rect::is_empty(&_self) - .into(); + let output: bool = ::bevy_math::Rect::is_empty(&_self).into(); output } }; @@ -2026,9 +2669,9 @@ pub(crate) fn register_rect_functions(world: &mut World) { .register_documented( "new", |x0: f32, y0: f32, x1: f32, y1: f32| { - let output: Val<::bevy_math::prelude::Rect> = { + let output: Val<::bevy_math::Rect> = { { - let output: Val<::bevy_math::prelude::Rect> = ::bevy_math::prelude::Rect::new( + let output: Val<::bevy_math::Rect> = ::bevy_math::Rect::new( x0, y0, x1, @@ -2045,13 +2688,10 @@ pub(crate) fn register_rect_functions(world: &mut World) { ) .register_documented( "normalize", - | - _self: Ref<::bevy_math::prelude::Rect>, - other: Val<::bevy_math::prelude::Rect>| - { - let output: Val<::bevy_math::prelude::Rect> = { + |_self: Ref<::bevy_math::Rect>, other: Val<::bevy_math::Rect>| { + let output: Val<::bevy_math::Rect> = { { - let output: Val<::bevy_math::prelude::Rect> = ::bevy_math::prelude::Rect::normalize( + let output: Val<::bevy_math::Rect> = ::bevy_math::Rect::normalize( &_self, other.into_inner(), ) @@ -2064,15 +2704,29 @@ pub(crate) fn register_rect_functions(world: &mut World) { " Build a new rectangle from this one with its coordinates expressed\n relative to `other` in a normalized ([0..1] x [0..1]) coordinate system.\n # Examples\n ```\n # use bevy_math::{Rect, Vec2};\n let r = Rect::new(2., 3., 4., 6.);\n let s = Rect::new(0., 0., 10., 10.);\n let n = r.normalize(s);\n assert_eq!(n.min.x, 0.2);\n assert_eq!(n.min.y, 0.3);\n assert_eq!(n.max.x, 0.4);\n assert_eq!(n.max.y, 0.6);\n ```", &["_self", "other"], ) + .register_documented( + "size", + |_self: Ref<::bevy_math::Rect>| { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = ::bevy_math::Rect::size( + &_self, + ) + .into(); + output + } + }; + output + }, + " Rectangle size.\n # Examples\n ```\n # use bevy_math::{Rect, Vec2};\n let r = Rect::new(0., 0., 5., 1.); // w=5 h=1\n assert!(r.size().abs_diff_eq(Vec2::new(5., 1.), 1e-5));\n ```", + &["_self"], + ) .register_documented( "union", - | - _self: Ref<::bevy_math::prelude::Rect>, - other: Val<::bevy_math::prelude::Rect>| - { - let output: Val<::bevy_math::prelude::Rect> = { + |_self: Ref<::bevy_math::Rect>, other: Val<::bevy_math::Rect>| { + let output: Val<::bevy_math::Rect> = { { - let output: Val<::bevy_math::prelude::Rect> = ::bevy_math::prelude::Rect::union( + let output: Val<::bevy_math::Rect> = ::bevy_math::Rect::union( &_self, other.into_inner(), ) @@ -2085,13 +2739,30 @@ pub(crate) fn register_rect_functions(world: &mut World) { " Build a new rectangle formed of the union of this rectangle and another rectangle.\n The union is the smallest rectangle enclosing both rectangles.\n # Examples\n ```\n # use bevy_math::{Rect, Vec2};\n let r1 = Rect::new(0., 0., 5., 1.); // w=5 h=1\n let r2 = Rect::new(1., -1., 3., 3.); // w=2 h=4\n let r = r1.union(r2);\n assert!(r.min.abs_diff_eq(Vec2::new(0., -1.), 1e-5));\n assert!(r.max.abs_diff_eq(Vec2::new(5., 3.), 1e-5));\n ```", &["_self", "other"], ) + .register_documented( + "union_point", + |_self: Ref<::bevy_math::Rect>, other: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_math::Rect> = { + { + let output: Val<::bevy_math::Rect> = ::bevy_math::Rect::union_point( + &_self, + other.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Build a new rectangle formed of the union of this rectangle and a point.\n The union is the smallest rectangle enclosing both the rectangle and the point. If the\n point is already inside the rectangle, this method returns a copy of the rectangle.\n # Examples\n ```\n # use bevy_math::{Rect, Vec2};\n let r = Rect::new(0., 0., 5., 1.); // w=5 h=1\n let u = r.union_point(Vec2::new(3., 6.));\n assert!(u.min.abs_diff_eq(Vec2::ZERO, 1e-5));\n assert!(u.max.abs_diff_eq(Vec2::new(5., 6.), 1e-5));\n ```", + &["_self", "other"], + ) .register_documented( "width", - |_self: Ref<::bevy_math::prelude::Rect>| { + |_self: Ref<::bevy_math::Rect>| { let output: f32 = { { - let output: f32 = ::bevy_math::prelude::Rect::width(&_self) - .into(); + let output: f32 = ::bevy_math::Rect::width(&_self).into(); output } }; @@ -2104,20 +2775,20 @@ pub(crate) fn register_rect_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::prelude::Rect, + ::bevy_math::Rect, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_u_rect_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::prelude::URect, + ::bevy_math::URect, >::new(world) .register_documented( "as_irect", - |_self: Ref<::bevy_math::prelude::URect>| { - let output: Val<::bevy_math::prelude::IRect> = { + |_self: Ref<::bevy_math::URect>| { + let output: Val<::bevy_math::IRect> = { { - let output: Val<::bevy_math::prelude::IRect> = ::bevy_math::prelude::URect::as_irect( + let output: Val<::bevy_math::IRect> = ::bevy_math::URect::as_irect( &_self, ) .into(); @@ -2131,10 +2802,10 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { ) .register_documented( "as_rect", - |_self: Ref<::bevy_math::prelude::URect>| { - let output: Val<::bevy_math::prelude::Rect> = { + |_self: Ref<::bevy_math::URect>| { + let output: Val<::bevy_math::Rect> = { { - let output: Val<::bevy_math::prelude::Rect> = ::bevy_math::prelude::URect::as_rect( + let output: Val<::bevy_math::Rect> = ::bevy_math::URect::as_rect( &_self, ) .into(); @@ -2148,10 +2819,10 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { ) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_math::prelude::URect>| { + |_self: Ref<::bevy_math::URect>| { let output: () = { { - let output: () = <::bevy_math::prelude::URect as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_math::URect as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -2163,12 +2834,29 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "center", + |_self: Ref<::bevy_math::URect>| { + let output: Val<::bevy_math::UVec2> = { + { + let output: Val<::bevy_math::UVec2> = ::bevy_math::URect::center( + &_self, + ) + .into(); + output + } + }; + output + }, + " The center point of the rectangle.\n # Rounding Behavior\n If the (min + max) contains odd numbers they will be rounded down to the nearest whole number when calculating the center.\n # Examples\n ```\n # use bevy_math::{URect, UVec2};\n let r = URect::new(0, 0, 4, 2); // w=4 h=2\n assert_eq!(r.center(), UVec2::new(2, 1));\n ```", + &["_self"], + ) .register_documented( "clone", - |_self: Ref<::bevy_math::prelude::URect>| { - let output: Val<::bevy_math::prelude::URect> = { + |_self: Ref<::bevy_math::URect>| { + let output: Val<::bevy_math::URect> = { { - let output: Val<::bevy_math::prelude::URect> = <::bevy_math::prelude::URect as ::core::clone::Clone>::clone( + let output: Val<::bevy_math::URect> = <::bevy_math::URect as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -2180,16 +2868,31 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "contains", + |_self: Ref<::bevy_math::URect>, point: Val<::bevy_math::UVec2>| { + let output: bool = { + { + let output: bool = ::bevy_math::URect::contains( + &_self, + point.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Check if a point lies within this rectangle, inclusive of its edges.\n # Examples\n ```\n # use bevy_math::URect;\n let r = URect::new(0, 0, 5, 1); // w=5 h=1\n assert!(r.contains(r.center()));\n assert!(r.contains(r.min));\n assert!(r.contains(r.max));\n ```", + &["_self", "point"], + ) .register_documented( "eq", - | - _self: Ref<::bevy_math::prelude::URect>, - other: Ref<::bevy_math::prelude::URect>| - { + |_self: Ref<::bevy_math::URect>, other: Ref<::bevy_math::URect>| { let output: bool = { { - let output: bool = <::bevy_math::prelude::URect as ::core::cmp::PartialEq< - ::bevy_math::prelude::URect, + let output: bool = <::bevy_math::URect as ::core::cmp::PartialEq< + ::bevy_math::URect, >>::eq(&_self, &other) .into(); output @@ -2200,13 +2903,83 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { "", &["_self", "other"], ) + .register_documented( + "from_center_half_size", + |origin: Val<::bevy_math::UVec2>, half_size: Val<::bevy_math::UVec2>| { + let output: Val<::bevy_math::URect> = { + { + let output: Val<::bevy_math::URect> = ::bevy_math::URect::from_center_half_size( + origin.into_inner(), + half_size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new rectangle from its center and half-size.\n # Panics\n This method panics if any of the components of the half-size is negative or if `origin - half_size` results in any negatives.\n # Examples\n ```\n # use bevy_math::{URect, UVec2};\n let r = URect::from_center_half_size(UVec2::ONE, UVec2::ONE); // w=2 h=2\n assert_eq!(r.min, UVec2::splat(0));\n assert_eq!(r.max, UVec2::splat(2));\n ```", + &["origin", "half_size"], + ) + .register_documented( + "from_center_size", + |origin: Val<::bevy_math::UVec2>, size: Val<::bevy_math::UVec2>| { + let output: Val<::bevy_math::URect> = { + { + let output: Val<::bevy_math::URect> = ::bevy_math::URect::from_center_size( + origin.into_inner(), + size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new rectangle from its center and size.\n # Rounding Behavior\n If the size contains odd numbers they will be rounded down to the nearest whole number.\n # Panics\n This method panics if any of the components of the size is negative or if `origin - (size / 2)` results in any negatives.\n # Examples\n ```\n # use bevy_math::{URect, UVec2};\n let r = URect::from_center_size(UVec2::ONE, UVec2::splat(2)); // w=2 h=2\n assert_eq!(r.min, UVec2::splat(0));\n assert_eq!(r.max, UVec2::splat(2));\n ```", + &["origin", "size"], + ) + .register_documented( + "from_corners", + |p0: Val<::bevy_math::UVec2>, p1: Val<::bevy_math::UVec2>| { + let output: Val<::bevy_math::URect> = { + { + let output: Val<::bevy_math::URect> = ::bevy_math::URect::from_corners( + p0.into_inner(), + p1.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new rectangle from two corner points.\n The two points do not need to be the minimum and/or maximum corners.\n They only need to be two opposite corners.\n # Examples\n ```\n # use bevy_math::{URect, UVec2};\n // Unit rect from [0,0] to [1,1]\n let r = URect::from_corners(UVec2::ZERO, UVec2::ONE); // w=1 h=1\n // Same; the points do not need to be ordered\n let r = URect::from_corners(UVec2::ONE, UVec2::ZERO); // w=1 h=1\n ```", + &["p0", "p1"], + ) + .register_documented( + "half_size", + |_self: Ref<::bevy_math::URect>| { + let output: Val<::bevy_math::UVec2> = { + { + let output: Val<::bevy_math::UVec2> = ::bevy_math::URect::half_size( + &_self, + ) + .into(); + output + } + }; + output + }, + " Rectangle half-size.\n # Rounding Behavior\n If the full size contains odd numbers they will be rounded down to the nearest whole number when calculating the half size.\n # Examples\n ```\n # use bevy_math::{URect, UVec2};\n let r = URect::new(0, 0, 4, 2); // w=4 h=2\n assert_eq!(r.half_size(), UVec2::new(2, 1));\n ```", + &["_self"], + ) .register_documented( "height", - |_self: Ref<::bevy_math::prelude::URect>| { + |_self: Ref<::bevy_math::URect>| { let output: u32 = { { - let output: u32 = ::bevy_math::prelude::URect::height(&_self) - .into(); + let output: u32 = ::bevy_math::URect::height(&_self).into(); output } }; @@ -2217,10 +2990,10 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { ) .register_documented( "inflate", - |_self: Ref<::bevy_math::prelude::URect>, expansion: i32| { - let output: Val<::bevy_math::prelude::URect> = { + |_self: Ref<::bevy_math::URect>, expansion: i32| { + let output: Val<::bevy_math::URect> = { { - let output: Val<::bevy_math::prelude::URect> = ::bevy_math::prelude::URect::inflate( + let output: Val<::bevy_math::URect> = ::bevy_math::URect::inflate( &_self, expansion, ) @@ -2235,13 +3008,10 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { ) .register_documented( "intersect", - | - _self: Ref<::bevy_math::prelude::URect>, - other: Val<::bevy_math::prelude::URect>| - { - let output: Val<::bevy_math::prelude::URect> = { + |_self: Ref<::bevy_math::URect>, other: Val<::bevy_math::URect>| { + let output: Val<::bevy_math::URect> = { { - let output: Val<::bevy_math::prelude::URect> = ::bevy_math::prelude::URect::intersect( + let output: Val<::bevy_math::URect> = ::bevy_math::URect::intersect( &_self, other.into_inner(), ) @@ -2256,11 +3026,10 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { ) .register_documented( "is_empty", - |_self: Ref<::bevy_math::prelude::URect>| { + |_self: Ref<::bevy_math::URect>| { let output: bool = { { - let output: bool = ::bevy_math::prelude::URect::is_empty(&_self) - .into(); + let output: bool = ::bevy_math::URect::is_empty(&_self).into(); output } }; @@ -2272,9 +3041,9 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { .register_documented( "new", |x0: u32, y0: u32, x1: u32, y1: u32| { - let output: Val<::bevy_math::prelude::URect> = { + let output: Val<::bevy_math::URect> = { { - let output: Val<::bevy_math::prelude::URect> = ::bevy_math::prelude::URect::new( + let output: Val<::bevy_math::URect> = ::bevy_math::URect::new( x0, y0, x1, @@ -2289,15 +3058,29 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { " Create a new rectangle from two corner points.\n The two points do not need to be the minimum and/or maximum corners.\n They only need to be two opposite corners.\n # Examples\n ```\n # use bevy_math::URect;\n let r = URect::new(0, 4, 10, 6); // w=10 h=2\n let r = URect::new(2, 4, 5, 0); // w=3 h=4\n ```", &["x0", "y0", "x1", "y1"], ) + .register_documented( + "size", + |_self: Ref<::bevy_math::URect>| { + let output: Val<::bevy_math::UVec2> = { + { + let output: Val<::bevy_math::UVec2> = ::bevy_math::URect::size( + &_self, + ) + .into(); + output + } + }; + output + }, + " Rectangle size.\n # Examples\n ```\n # use bevy_math::{URect, UVec2};\n let r = URect::new(0, 0, 5, 1); // w=5 h=1\n assert_eq!(r.size(), UVec2::new(5, 1));\n ```", + &["_self"], + ) .register_documented( "union", - | - _self: Ref<::bevy_math::prelude::URect>, - other: Val<::bevy_math::prelude::URect>| - { - let output: Val<::bevy_math::prelude::URect> = { + |_self: Ref<::bevy_math::URect>, other: Val<::bevy_math::URect>| { + let output: Val<::bevy_math::URect> = { { - let output: Val<::bevy_math::prelude::URect> = ::bevy_math::prelude::URect::union( + let output: Val<::bevy_math::URect> = ::bevy_math::URect::union( &_self, other.into_inner(), ) @@ -2310,13 +3093,30 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { " Build a new rectangle formed of the union of this rectangle and another rectangle.\n The union is the smallest rectangle enclosing both rectangles.\n # Examples\n ```\n # use bevy_math::{URect, UVec2};\n let r1 = URect::new(0, 0, 5, 1); // w=5 h=1\n let r2 = URect::new(1, 0, 3, 8); // w=2 h=4\n let r = r1.union(r2);\n assert_eq!(r.min, UVec2::new(0, 0));\n assert_eq!(r.max, UVec2::new(5, 8));\n ```", &["_self", "other"], ) + .register_documented( + "union_point", + |_self: Ref<::bevy_math::URect>, other: Val<::bevy_math::UVec2>| { + let output: Val<::bevy_math::URect> = { + { + let output: Val<::bevy_math::URect> = ::bevy_math::URect::union_point( + &_self, + other.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Build a new rectangle formed of the union of this rectangle and a point.\n The union is the smallest rectangle enclosing both the rectangle and the point. If the\n point is already inside the rectangle, this method returns a copy of the rectangle.\n # Examples\n ```\n # use bevy_math::{URect, UVec2};\n let r = URect::new(0, 0, 5, 1); // w=5 h=1\n let u = r.union_point(UVec2::new(3, 6));\n assert_eq!(u.min, UVec2::ZERO);\n assert_eq!(u.max, UVec2::new(5, 6));\n ```", + &["_self", "other"], + ) .register_documented( "width", - |_self: Ref<::bevy_math::prelude::URect>| { + |_self: Ref<::bevy_math::URect>| { let output: u32 = { { - let output: u32 = ::bevy_math::prelude::URect::width(&_self) - .into(); + let output: u32 = ::bevy_math::URect::width(&_self).into(); output } }; @@ -2329,363 +3129,49 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::prelude::URect, + ::bevy_math::URect, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_affine_3_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<::bevy_math::Affine3>::new( - world, - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::<::bevy_math::Affine3, bevy_mod_scripting_bindings::MarkAsGenerated>(); -} -pub(crate) fn register_aabb_2_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::bounding::Aabb2d, - >::new(world) - .register_documented( - "bounding_circle", - |_self: Ref<::bevy_math::bounding::Aabb2d>| { - let output: Val<::bevy_math::bounding::BoundingCircle> = { - { - let output: Val<::bevy_math::bounding::BoundingCircle> = - ::bevy_math::bounding::Aabb2d::bounding_circle(&_self).into(); - output - } - }; - output - }, - " Computes the smallest [`BoundingCircle`] containing this [`Aabb2d`].", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_math::bounding::Aabb2d>| { - let output: Val<::bevy_math::bounding::Aabb2d> = { - { - let output: Val<::bevy_math::bounding::Aabb2d> = - <::bevy_math::bounding::Aabb2d as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::bounding::Aabb2d>, other: Ref<::bevy_math::bounding::Aabb2d>| { - let output: bool = { - { - let output: bool = <::bevy_math::bounding::Aabb2d as ::core::cmp::PartialEq< - ::bevy_math::bounding::Aabb2d, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::bounding::Aabb2d, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_bounding_circle_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::bounding::BoundingCircle, - >::new(world) - .register_documented( - "aabb_2d", - |_self: Ref<::bevy_math::bounding::BoundingCircle>| { - let output: Val<::bevy_math::bounding::Aabb2d> = { - { - let output: Val<::bevy_math::bounding::Aabb2d> = - ::bevy_math::bounding::BoundingCircle::aabb_2d(&_self).into(); - output - } - }; - output - }, - " Computes the smallest [`Aabb2d`] containing this [`BoundingCircle`].", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_math::bounding::BoundingCircle>| { - let output: Val<::bevy_math::bounding::BoundingCircle> = { - { - let output: Val<::bevy_math::bounding::BoundingCircle> = - <::bevy_math::bounding::BoundingCircle as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::bounding::BoundingCircle>, - other: Ref<::bevy_math::bounding::BoundingCircle>| { - let output: bool = { - { - let output: bool = - <::bevy_math::bounding::BoundingCircle as ::core::cmp::PartialEq< - ::bevy_math::bounding::BoundingCircle, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "radius", - |_self: Ref<::bevy_math::bounding::BoundingCircle>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::bounding::BoundingCircle::radius(&_self).into(); - output - } - }; - output - }, - " Get the radius of the bounding circle", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::bounding::BoundingCircle, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_circle_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Circle, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Circle>| { - let output: Val<::bevy_math::primitives::Circle> = { - { - let output: Val<::bevy_math::primitives::Circle> = - <::bevy_math::primitives::Circle as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "diameter", - |_self: Ref<::bevy_math::primitives::Circle>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::Circle::diameter(&_self).into(); - output - } - }; - output - }, - " Get the diameter of the circle", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::primitives::Circle>, - other: Ref<::bevy_math::primitives::Circle>| { - let output: bool = { - { - let output: bool = - <::bevy_math::primitives::Circle as ::core::cmp::PartialEq< - ::bevy_math::primitives::Circle, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "new", - |radius: f32| { - let output: Val<::bevy_math::primitives::Circle> = { - { - let output: Val<::bevy_math::primitives::Circle> = - ::bevy_math::primitives::Circle::new(radius).into(); - output - } - }; - output - }, - " Create a new [`Circle`] from a `radius`", - &["radius"], - ); + ::bevy_math::Affine3, + >::new(world); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::primitives::Circle, + ::bevy_math::Affine3, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_annulus_functions(world: &mut World) { +pub(crate) fn register_aabb_2_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Annulus, + ::bevy_math::bounding::Aabb2d, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Annulus>| { - let output: Val<::bevy_math::primitives::Annulus> = { - { - let output: Val<::bevy_math::primitives::Annulus> = - <::bevy_math::primitives::Annulus as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "diameter", - |_self: Ref<::bevy_math::primitives::Annulus>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::Annulus::diameter(&_self).into(); - output - } - }; - output - }, - " Get the diameter of the annulus", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::primitives::Annulus>, - other: Ref<::bevy_math::primitives::Annulus>| { - let output: bool = { - { - let output: bool = - <::bevy_math::primitives::Annulus as ::core::cmp::PartialEq< - ::bevy_math::primitives::Annulus, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "new", - |inner_radius: f32, outer_radius: f32| { - let output: Val<::bevy_math::primitives::Annulus> = { - { - let output: Val<::bevy_math::primitives::Annulus> = - ::bevy_math::primitives::Annulus::new(inner_radius, outer_radius).into(); - output - } - }; - output - }, - " Create a new [`Annulus`] from the radii of the inner and outer circle", - &["inner_radius", "outer_radius"], - ) - .register_documented( - "thickness", - |_self: Ref<::bevy_math::primitives::Annulus>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::Annulus::thickness(&_self).into(); - output - } - }; - output - }, - " Get the thickness of the annulus", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::primitives::Annulus, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_arc_2_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Arc2d, - >::new(world) - .register_documented( - "angle", - |_self: Ref<::bevy_math::primitives::Arc2d>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::Arc2d::angle(&_self) - .into(); - output - } - }; - output - }, - " Get the angle of the arc", - &["_self"], - ) .register_documented( - "apothem", - |_self: Ref<::bevy_math::primitives::Arc2d>| { - let output: f32 = { + "bounding_circle", + |_self: Ref<::bevy_math::bounding::Aabb2d>| { + let output: Val<::bevy_math::bounding::BoundingCircle> = { { - let output: f32 = ::bevy_math::primitives::Arc2d::apothem(&_self) + let output: Val<::bevy_math::bounding::BoundingCircle> = ::bevy_math::bounding::Aabb2d::bounding_circle( + &_self, + ) .into(); output } }; output }, - " Get the length of the apothem of this arc, that is,\n the distance from the center of the circle to the midpoint of the chord, in the direction of the midpoint of the arc.\n Equivalently, the [`radius`](Self::radius) minus the [`sagitta`](Self::sagitta).\n Note that for a [`major`](Self::is_major) arc, the apothem will be negative.", + " Computes the smallest [`BoundingCircle`] containing this [`Aabb2d`].", &["_self"], ) .register_documented( - "chord_length", - |_self: Ref<::bevy_math::primitives::Arc2d>| { - let output: f32 = { + "clone", + |_self: Ref<::bevy_math::bounding::Aabb2d>| { + let output: Val<::bevy_math::bounding::Aabb2d> = { { - let output: f32 = ::bevy_math::primitives::Arc2d::chord_length( + let output: Val<::bevy_math::bounding::Aabb2d> = <::bevy_math::bounding::Aabb2d as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -2694,16 +3180,17 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { }; output }, - " Get the distance between the endpoints (the length of the chord)", + "", &["_self"], ) .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Arc2d>| { - let output: Val<::bevy_math::primitives::Arc2d> = { + "closest_point", + |_self: Ref<::bevy_math::bounding::Aabb2d>, point: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::primitives::Arc2d> = <::bevy_math::primitives::Arc2d as ::core::clone::Clone>::clone( + let output: Val<::bevy_math::Vec2> = ::bevy_math::bounding::Aabb2d::closest_point( &_self, + point.into_inner(), ) .into(); output @@ -2711,19 +3198,19 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { }; output }, - "", - &["_self"], + " Finds the point on the AABB that is closest to the given `point`.\n If the point is outside the AABB, the returned point will be on the perimeter of the AABB.\n Otherwise, it will be inside the AABB and returned as is.", + &["_self", "point"], ) .register_documented( "eq", | - _self: Ref<::bevy_math::primitives::Arc2d>, - other: Ref<::bevy_math::primitives::Arc2d>| + _self: Ref<::bevy_math::bounding::Aabb2d>, + other: Ref<::bevy_math::bounding::Aabb2d>| { let output: bool = { { - let output: bool = <::bevy_math::primitives::Arc2d as ::core::cmp::PartialEq< - ::bevy_math::primitives::Arc2d, + let output: bool = <::bevy_math::bounding::Aabb2d as ::core::cmp::PartialEq< + ::bevy_math::bounding::Aabb2d, >>::eq(&_self, &other) .into(); output @@ -2735,49 +3222,13 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { &["_self", "other"], ) .register_documented( - "from_degrees", - |radius: f32, angle: f32| { - let output: Val<::bevy_math::primitives::Arc2d> = { - { - let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::from_degrees( - radius, - angle, - ) - .into(); - output - } - }; - output - }, - " Create a new [`Arc2d`] from a `radius` and an `angle` in degrees.", - &["radius", "angle"], - ) - .register_documented( - "from_radians", - |radius: f32, angle: f32| { - let output: Val<::bevy_math::primitives::Arc2d> = { - { - let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::from_radians( - radius, - angle, - ) - .into(); - output - } - }; - output - }, - " Create a new [`Arc2d`] from a `radius` and an `angle` in radians", - &["radius", "angle"], - ) - .register_documented( - "from_turns", - |radius: f32, fraction: f32| { - let output: Val<::bevy_math::primitives::Arc2d> = { + "new", + |center: Val<::bevy_math::Vec2>, half_size: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_math::bounding::Aabb2d> = { { - let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::from_turns( - radius, - fraction, + let output: Val<::bevy_math::bounding::Aabb2d> = ::bevy_math::bounding::Aabb2d::new( + center.into_inner(), + half_size.into_inner(), ) .into(); output @@ -2785,15 +3236,27 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { }; output }, - " Create a new [`Arc2d`] from a `radius` and a `fraction` of a single turn.\n For instance, `0.5` turns is a semicircle.", - &["radius", "fraction"], - ) + " Constructs an AABB from its center and half-size.", + &["center", "half_size"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::bounding::Aabb2d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_bounding_circle_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::bounding::BoundingCircle, + >::new(world) .register_documented( - "half_chord_length", - |_self: Ref<::bevy_math::primitives::Arc2d>| { - let output: f32 = { + "aabb_2d", + |_self: Ref<::bevy_math::bounding::BoundingCircle>| { + let output: Val<::bevy_math::bounding::Aabb2d> = { { - let output: f32 = ::bevy_math::primitives::Arc2d::half_chord_length( + let output: Val<::bevy_math::bounding::Aabb2d> = ::bevy_math::bounding::BoundingCircle::aabb_2d( &_self, ) .into(); @@ -2802,15 +3265,15 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { }; output }, - " Get half the distance between the endpoints (half the length of the chord)", + " Computes the smallest [`Aabb2d`] containing this [`BoundingCircle`].", &["_self"], ) .register_documented( - "is_major", - |_self: Ref<::bevy_math::primitives::Arc2d>| { - let output: bool = { + "clone", + |_self: Ref<::bevy_math::bounding::BoundingCircle>| { + let output: Val<::bevy_math::bounding::BoundingCircle> = { { - let output: bool = ::bevy_math::primitives::Arc2d::is_major( + let output: Val<::bevy_math::bounding::BoundingCircle> = <::bevy_math::bounding::BoundingCircle as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -2819,16 +3282,20 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { }; output }, - " Produces true if the arc is at least half a circle.\n **Note:** This is not the negation of [`is_minor`](Self::is_minor): an exact semicircle is both major and minor.", + "", &["_self"], ) .register_documented( - "is_minor", - |_self: Ref<::bevy_math::primitives::Arc2d>| { - let output: bool = { + "closest_point", + | + _self: Ref<::bevy_math::bounding::BoundingCircle>, + point: Val<::bevy_math::Vec2>| + { + let output: Val<::bevy_math::Vec2> = { { - let output: bool = ::bevy_math::primitives::Arc2d::is_minor( + let output: Val<::bevy_math::Vec2> = ::bevy_math::bounding::BoundingCircle::closest_point( &_self, + point.into_inner(), ) .into(); output @@ -2836,32 +3303,37 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { }; output }, - " Produces true if the arc is at most half a circle.\n **Note:** This is not the negation of [`is_major`](Self::is_major): an exact semicircle is both major and minor.", - &["_self"], + " Finds the point on the bounding circle that is closest to the given `point`.\n If the point is outside the circle, the returned point will be on the perimeter of the circle.\n Otherwise, it will be inside the circle and returned as is.", + &["_self", "point"], ) .register_documented( - "length", - |_self: Ref<::bevy_math::primitives::Arc2d>| { - let output: f32 = { + "eq", + | + _self: Ref<::bevy_math::bounding::BoundingCircle>, + other: Ref<::bevy_math::bounding::BoundingCircle>| + { + let output: bool = { { - let output: f32 = ::bevy_math::primitives::Arc2d::length(&_self) + let output: bool = <::bevy_math::bounding::BoundingCircle as ::core::cmp::PartialEq< + ::bevy_math::bounding::BoundingCircle, + >>::eq(&_self, &other) .into(); output } }; output }, - " Get the length of the arc", - &["_self"], + "", + &["_self", "other"], ) .register_documented( "new", - |radius: f32, half_angle: f32| { - let output: Val<::bevy_math::primitives::Arc2d> = { + |center: Val<::bevy_math::Vec2>, radius: f32| { + let output: Val<::bevy_math::bounding::BoundingCircle> = { { - let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::new( + let output: Val<::bevy_math::bounding::BoundingCircle> = ::bevy_math::bounding::BoundingCircle::new( + center.into_inner(), radius, - half_angle, ) .into(); output @@ -2869,119 +3341,44 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { }; output }, - " Create a new [`Arc2d`] from a `radius` and a `half_angle`", - &["radius", "half_angle"], + " Constructs a bounding circle from its center and radius.", + &["center", "radius"], ) .register_documented( - "sagitta", - |_self: Ref<::bevy_math::primitives::Arc2d>| { + "radius", + |_self: Ref<::bevy_math::bounding::BoundingCircle>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::Arc2d::sagitta(&_self) + let output: f32 = ::bevy_math::bounding::BoundingCircle::radius( + &_self, + ) .into(); output } }; output }, - " Get the length of the sagitta of this arc, that is,\n the length of the line between the midpoints of the arc and its chord.\n Equivalently, the height of the triangle whose base is the chord and whose apex is the midpoint of the arc.\n The sagitta is also the sum of the [`radius`](Self::radius) and the [`apothem`](Self::apothem).", + " Get the radius of the bounding circle", &["_self"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::primitives::Arc2d, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_capsule_2_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Capsule2d, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Capsule2d>| { - let output: Val<::bevy_math::primitives::Capsule2d> = { - { - let output: Val<::bevy_math::primitives::Capsule2d> = - <::bevy_math::primitives::Capsule2d as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::primitives::Capsule2d>, - other: Ref<::bevy_math::primitives::Capsule2d>| { - let output: bool = { - { - let output: bool = - <::bevy_math::primitives::Capsule2d as ::core::cmp::PartialEq< - ::bevy_math::primitives::Capsule2d, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "new", - |radius: f32, length: f32| { - let output: Val<::bevy_math::primitives::Capsule2d> = { - { - let output: Val<::bevy_math::primitives::Capsule2d> = - ::bevy_math::primitives::Capsule2d::new(radius, length).into(); - output - } - }; - output - }, - " Create a new `Capsule2d` from a radius and length", - &["radius", "length"], - ) - .register_documented( - "to_inner_rectangle", - |_self: Ref<::bevy_math::primitives::Capsule2d>| { - let output: Val<::bevy_math::primitives::Rectangle> = { - { - let output: Val<::bevy_math::primitives::Rectangle> = - ::bevy_math::primitives::Capsule2d::to_inner_rectangle(&_self).into(); - output - } - }; - output - }, - " Get the part connecting the semicircular ends of the capsule as a [`Rectangle`]", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::primitives::Capsule2d, + ::bevy_math::bounding::BoundingCircle, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_circular_sector_functions(world: &mut World) { +pub(crate) fn register_circle_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::CircularSector, + ::bevy_math::primitives::Circle, >::new(world) .register_documented( - "angle", - |_self: Ref<::bevy_math::primitives::CircularSector>| { - let output: f32 = { + "clone", + |_self: Ref<::bevy_math::primitives::Circle>| { + let output: Val<::bevy_math::primitives::Circle> = { { - let output: f32 = ::bevy_math::primitives::CircularSector::angle( + let output: Val<::bevy_math::primitives::Circle> = <::bevy_math::primitives::Circle as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -2990,16 +3387,17 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { }; output }, - " Get the angle of the sector", + "", &["_self"], ) .register_documented( - "apothem", - |_self: Ref<::bevy_math::primitives::CircularSector>| { - let output: f32 = { + "closest_point", + |_self: Ref<::bevy_math::primitives::Circle>, point: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_math::Vec2> = { { - let output: f32 = ::bevy_math::primitives::CircularSector::apothem( + let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Circle::closest_point( &_self, + point.into_inner(), ) .into(); output @@ -3007,15 +3405,15 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { }; output }, - " Get the length of the apothem of this sector\n See [`Arc2d::apothem`]", - &["_self"], + " Finds the point on the circle that is closest to the given `point`.\n If the point is outside the circle, the returned point will be on the perimeter of the circle.\n Otherwise, it will be inside the circle and returned as is.", + &["_self", "point"], ) .register_documented( - "arc_length", - |_self: Ref<::bevy_math::primitives::CircularSector>| { + "diameter", + |_self: Ref<::bevy_math::primitives::Circle>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::CircularSector::arc_length( + let output: f32 = ::bevy_math::primitives::Circle::diameter( &_self, ) .into(); @@ -3024,32 +3422,64 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { }; output }, - " Get the length of the arc defining the sector", + " Get the diameter of the circle", &["_self"], ) .register_documented( - "chord_length", - |_self: Ref<::bevy_math::primitives::CircularSector>| { - let output: f32 = { + "eq", + | + _self: Ref<::bevy_math::primitives::Circle>, + other: Ref<::bevy_math::primitives::Circle>| + { + let output: bool = { { - let output: f32 = ::bevy_math::primitives::CircularSector::chord_length( - &_self, - ) + let output: bool = <::bevy_math::primitives::Circle as ::core::cmp::PartialEq< + ::bevy_math::primitives::Circle, + >>::eq(&_self, &other) .into(); output } }; output }, - " Get the length of the chord defined by the sector\n See [`Arc2d::chord_length`]", - &["_self"], + "", + &["_self", "other"], ) + .register_documented( + "new", + |radius: f32| { + let output: Val<::bevy_math::primitives::Circle> = { + { + let output: Val<::bevy_math::primitives::Circle> = ::bevy_math::primitives::Circle::new( + radius, + ) + .into(); + output + } + }; + output + }, + " Create a new [`Circle`] from a `radius`", + &["radius"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::Circle, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_annulus_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Annulus, + >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_math::primitives::CircularSector>| { - let output: Val<::bevy_math::primitives::CircularSector> = { + |_self: Ref<::bevy_math::primitives::Annulus>| { + let output: Val<::bevy_math::primitives::Annulus> = { { - let output: Val<::bevy_math::primitives::CircularSector> = <::bevy_math::primitives::CircularSector as ::core::clone::Clone>::clone( + let output: Val<::bevy_math::primitives::Annulus> = <::bevy_math::primitives::Annulus as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -3062,33 +3492,33 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { &["_self"], ) .register_documented( - "eq", + "closest_point", | - _self: Ref<::bevy_math::primitives::CircularSector>, - other: Ref<::bevy_math::primitives::CircularSector>| + _self: Ref<::bevy_math::primitives::Annulus>, + point: Val<::bevy_math::Vec2>| { - let output: bool = { + let output: Val<::bevy_math::Vec2> = { { - let output: bool = <::bevy_math::primitives::CircularSector as ::core::cmp::PartialEq< - ::bevy_math::primitives::CircularSector, - >>::eq(&_self, &other) + let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Annulus::closest_point( + &_self, + point.into_inner(), + ) .into(); output } }; output }, - "", - &["_self", "other"], + " Finds the point on the annulus that is closest to the given `point`:\n - If the point is outside of the annulus completely, the returned point will be on the outer perimeter.\n - If the point is inside of the inner circle (hole) of the annulus, the returned point will be on the inner perimeter.\n - Otherwise, the returned point is overlapping the annulus and returned as is.", + &["_self", "point"], ) .register_documented( - "from_degrees", - |radius: f32, angle: f32| { - let output: Val<::bevy_math::primitives::CircularSector> = { + "diameter", + |_self: Ref<::bevy_math::primitives::Annulus>| { + let output: f32 = { { - let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::from_degrees( - radius, - angle, + let output: f32 = ::bevy_math::primitives::Annulus::diameter( + &_self, ) .into(); output @@ -3096,104 +3526,37 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { }; output }, - " Create a new [`CircularSector`] from a `radius` and an `angle` in degrees.", - &["radius", "angle"], + " Get the diameter of the annulus", + &["_self"], ) .register_documented( - "from_radians", - |radius: f32, angle: f32| { - let output: Val<::bevy_math::primitives::CircularSector> = { - { - let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::from_radians( - radius, - angle, - ) - .into(); - output - } - }; - output - }, - " Create a new [`CircularSector`] from a `radius` and an `angle` in radians.", - &["radius", "angle"], - ) - .register_documented( - "from_turns", - |radius: f32, fraction: f32| { - let output: Val<::bevy_math::primitives::CircularSector> = { - { - let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::from_turns( - radius, - fraction, - ) - .into(); - output - } - }; - output - }, - " Create a new [`CircularSector`] from a `radius` and a number of `turns` of a circle.\n For instance, `0.5` turns is a semicircle.", - &["radius", "fraction"], - ) - .register_documented( - "half_angle", - |_self: Ref<::bevy_math::primitives::CircularSector>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::CircularSector::half_angle( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get half the angle of the sector", - &["_self"], - ) - .register_documented( - "half_chord_length", - |_self: Ref<::bevy_math::primitives::CircularSector>| { - let output: f32 = { + "eq", + | + _self: Ref<::bevy_math::primitives::Annulus>, + other: Ref<::bevy_math::primitives::Annulus>| + { + let output: bool = { { - let output: f32 = ::bevy_math::primitives::CircularSector::half_chord_length( - &_self, - ) + let output: bool = <::bevy_math::primitives::Annulus as ::core::cmp::PartialEq< + ::bevy_math::primitives::Annulus, + >>::eq(&_self, &other) .into(); output } }; output }, - " Get half the length of the chord defined by the sector\n See [`Arc2d::half_chord_length`]", - &["_self"], + "", + &["_self", "other"], ) .register_documented( "new", - |radius: f32, angle: f32| { - let output: Val<::bevy_math::primitives::CircularSector> = { - { - let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::new( - radius, - angle, - ) - .into(); - output - } - }; - output - }, - " Create a new [`CircularSector`] from a `radius` and an `angle`", - &["radius", "angle"], - ) - .register_documented( - "radius", - |_self: Ref<::bevy_math::primitives::CircularSector>| { - let output: f32 = { + |inner_radius: f32, outer_radius: f32| { + let output: Val<::bevy_math::primitives::Annulus> = { { - let output: f32 = ::bevy_math::primitives::CircularSector::radius( - &_self, + let output: Val<::bevy_math::primitives::Annulus> = ::bevy_math::primitives::Annulus::new( + inner_radius, + outer_radius, ) .into(); output @@ -3201,15 +3564,15 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { }; output }, - " Get the radius of the sector", - &["_self"], + " Create a new [`Annulus`] from the radii of the inner and outer circle", + &["inner_radius", "outer_radius"], ) .register_documented( - "sagitta", - |_self: Ref<::bevy_math::primitives::CircularSector>| { + "thickness", + |_self: Ref<::bevy_math::primitives::Annulus>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::CircularSector::sagitta( + let output: f32 = ::bevy_math::primitives::Annulus::thickness( &_self, ) .into(); @@ -3218,61 +3581,57 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { }; output }, - " Get the length of the sagitta of this sector\n See [`Arc2d::sagitta`]", + " Get the thickness of the annulus", &["_self"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::primitives::CircularSector, + ::bevy_math::primitives::Annulus, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_circular_segment_functions(world: &mut World) { +pub(crate) fn register_arc_2_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::CircularSegment, + ::bevy_math::primitives::Arc2d, >::new(world) .register_documented( "angle", - |_self: Ref<::bevy_math::primitives::CircularSegment>| { + |_self: Ref<::bevy_math::primitives::Arc2d>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::CircularSegment::angle( - &_self, - ) + let output: f32 = ::bevy_math::primitives::Arc2d::angle(&_self) .into(); output } }; output }, - " Get the angle of the segment", + " Get the angle of the arc", &["_self"], ) .register_documented( "apothem", - |_self: Ref<::bevy_math::primitives::CircularSegment>| { + |_self: Ref<::bevy_math::primitives::Arc2d>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::CircularSegment::apothem( - &_self, - ) + let output: f32 = ::bevy_math::primitives::Arc2d::apothem(&_self) .into(); output } }; output }, - " Get the length of the apothem of this segment,\n which is the signed distance between the segment and the center of its circle\n See [`Arc2d::apothem`]", + " Get the length of the apothem of this arc, that is,\n the distance from the center of the circle to the midpoint of the chord, in the direction of the midpoint of the arc.\n Equivalently, the [`radius`](Self::radius) minus the [`sagitta`](Self::sagitta).\n Note that for a [`major`](Self::is_major) arc, the apothem will be negative.", &["_self"], ) .register_documented( - "arc_length", - |_self: Ref<::bevy_math::primitives::CircularSegment>| { + "chord_length", + |_self: Ref<::bevy_math::primitives::Arc2d>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::CircularSegment::arc_length( + let output: f32 = ::bevy_math::primitives::Arc2d::chord_length( &_self, ) .into(); @@ -3281,15 +3640,15 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { }; output }, - " Get the length of the arc defining the segment", + " Get the distance between the endpoints (the length of the chord)", &["_self"], ) .register_documented( - "chord_length", - |_self: Ref<::bevy_math::primitives::CircularSegment>| { - let output: f32 = { + "chord_midpoint", + |_self: Ref<::bevy_math::primitives::Arc2d>| { + let output: Val<::bevy_math::Vec2> = { { - let output: f32 = ::bevy_math::primitives::CircularSegment::chord_length( + let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Arc2d::chord_midpoint( &_self, ) .into(); @@ -3298,15 +3657,15 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { }; output }, - " Get the length of the segment's base, also known as its chord", + " Get the midpoint of the two endpoints (the midpoint of the chord)", &["_self"], ) .register_documented( "clone", - |_self: Ref<::bevy_math::primitives::CircularSegment>| { - let output: Val<::bevy_math::primitives::CircularSegment> = { + |_self: Ref<::bevy_math::primitives::Arc2d>| { + let output: Val<::bevy_math::primitives::Arc2d> = { { - let output: Val<::bevy_math::primitives::CircularSegment> = <::bevy_math::primitives::CircularSegment as ::core::clone::Clone>::clone( + let output: Val<::bevy_math::primitives::Arc2d> = <::bevy_math::primitives::Arc2d as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -3321,13 +3680,13 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_math::primitives::CircularSegment>, - other: Ref<::bevy_math::primitives::CircularSegment>| + _self: Ref<::bevy_math::primitives::Arc2d>, + other: Ref<::bevy_math::primitives::Arc2d>| { let output: bool = { { - let output: bool = <::bevy_math::primitives::CircularSegment as ::core::cmp::PartialEq< - ::bevy_math::primitives::CircularSegment, + let output: bool = <::bevy_math::primitives::Arc2d as ::core::cmp::PartialEq< + ::bevy_math::primitives::Arc2d, >>::eq(&_self, &other) .into(); output @@ -3341,9 +3700,9 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { .register_documented( "from_degrees", |radius: f32, angle: f32| { - let output: Val<::bevy_math::primitives::CircularSegment> = { + let output: Val<::bevy_math::primitives::Arc2d> = { { - let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::from_degrees( + let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::from_degrees( radius, angle, ) @@ -3353,15 +3712,15 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { }; output }, - " Create a new [`CircularSegment`] from a `radius` and an `angle` in degrees.", + " Create a new [`Arc2d`] from a `radius` and an `angle` in degrees.", &["radius", "angle"], ) .register_documented( "from_radians", |radius: f32, angle: f32| { - let output: Val<::bevy_math::primitives::CircularSegment> = { + let output: Val<::bevy_math::primitives::Arc2d> = { { - let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::from_radians( + let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::from_radians( radius, angle, ) @@ -3371,15 +3730,15 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { }; output }, - " Create a new [`CircularSegment`] from a `radius` and an `angle` in radians.", + " Create a new [`Arc2d`] from a `radius` and an `angle` in radians", &["radius", "angle"], ) .register_documented( "from_turns", |radius: f32, fraction: f32| { - let output: Val<::bevy_math::primitives::CircularSegment> = { + let output: Val<::bevy_math::primitives::Arc2d> = { { - let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::from_turns( + let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::from_turns( radius, fraction, ) @@ -3389,15 +3748,15 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { }; output }, - " Create a new [`CircularSegment`] from a `radius` and a number of `turns` of a circle.\n For instance, `0.5` turns is a semicircle.", + " Create a new [`Arc2d`] from a `radius` and a `fraction` of a single turn.\n For instance, `0.5` turns is a semicircle.", &["radius", "fraction"], ) .register_documented( - "half_angle", - |_self: Ref<::bevy_math::primitives::CircularSegment>| { + "half_chord_length", + |_self: Ref<::bevy_math::primitives::Arc2d>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::CircularSegment::half_angle( + let output: f32 = ::bevy_math::primitives::Arc2d::half_chord_length( &_self, ) .into(); @@ -3406,15 +3765,15 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { }; output }, - " Get the half-angle of the segment", + " Get half the distance between the endpoints (half the length of the chord)", &["_self"], ) .register_documented( - "half_chord_length", - |_self: Ref<::bevy_math::primitives::CircularSegment>| { - let output: f32 = { + "is_major", + |_self: Ref<::bevy_math::primitives::Arc2d>| { + let output: bool = { { - let output: f32 = ::bevy_math::primitives::CircularSegment::half_chord_length( + let output: bool = ::bevy_math::primitives::Arc2d::is_major( &_self, ) .into(); @@ -3423,17 +3782,16 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { }; output }, - " Get half the length of the segment's base, also known as its chord", + " Produces true if the arc is at least half a circle.\n **Note:** This is not the negation of [`is_minor`](Self::is_minor): an exact semicircle is both major and minor.", &["_self"], ) .register_documented( - "new", - |radius: f32, angle: f32| { - let output: Val<::bevy_math::primitives::CircularSegment> = { + "is_minor", + |_self: Ref<::bevy_math::primitives::Arc2d>| { + let output: bool = { { - let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::new( - radius, - angle, + let output: bool = ::bevy_math::primitives::Arc2d::is_minor( + &_self, ) .into(); output @@ -3441,15 +3799,15 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { }; output }, - " Create a new [`CircularSegment`] from a `radius`, and an `angle`", - &["radius", "angle"], + " Produces true if the arc is at most half a circle.\n **Note:** This is not the negation of [`is_major`](Self::is_major): an exact semicircle is both major and minor.", + &["_self"], ) .register_documented( - "radius", - |_self: Ref<::bevy_math::primitives::CircularSegment>| { - let output: f32 = { + "left_endpoint", + |_self: Ref<::bevy_math::primitives::Arc2d>| { + let output: Val<::bevy_math::Vec2> = { { - let output: f32 = ::bevy_math::primitives::CircularSegment::radius( + let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Arc2d::left_endpoint( &_self, ) .into(); @@ -3458,44 +3816,30 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { }; output }, - " Get the radius of the segment", + " Get the left-hand end point of the arc", &["_self"], ) .register_documented( - "sagitta", - |_self: Ref<::bevy_math::primitives::CircularSegment>| { + "length", + |_self: Ref<::bevy_math::primitives::Arc2d>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::CircularSegment::sagitta( - &_self, - ) + let output: f32 = ::bevy_math::primitives::Arc2d::length(&_self) .into(); output } }; output }, - " Get the length of the sagitta of this segment, also known as its height\n See [`Arc2d::sagitta`]", + " Get the length of the arc", &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::primitives::CircularSegment, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_ellipse_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Ellipse, - >::new(world) + ) .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Ellipse>| { - let output: Val<::bevy_math::primitives::Ellipse> = { + "midpoint", + |_self: Ref<::bevy_math::primitives::Arc2d>| { + let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::primitives::Ellipse> = <::bevy_math::primitives::Ellipse as ::core::clone::Clone>::clone( + let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Arc2d::midpoint( &_self, ) .into(); @@ -3504,16 +3848,17 @@ pub(crate) fn register_ellipse_functions(world: &mut World) { }; output }, - "", + " Get the midpoint of the arc", &["_self"], ) .register_documented( - "eccentricity", - |_self: Ref<::bevy_math::primitives::Ellipse>| { - let output: f32 = { + "new", + |radius: f32, half_angle: f32| { + let output: Val<::bevy_math::primitives::Arc2d> = { { - let output: f32 = ::bevy_math::primitives::Ellipse::eccentricity( - &_self, + let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::new( + radius, + half_angle, ) .into(); output @@ -3521,70 +3866,15 @@ pub(crate) fn register_ellipse_functions(world: &mut World) { }; output }, - " Returns the [eccentricity](https://en.wikipedia.org/wiki/Eccentricity_(mathematics)) of the ellipse.\n It can be thought of as a measure of how \"stretched\" or elongated the ellipse is.\n The value should be in the range [0, 1), where 0 represents a circle, and 1 represents a parabola.", - &["_self"], + " Create a new [`Arc2d`] from a `radius` and a `half_angle`", + &["radius", "half_angle"], ) .register_documented( - "eq", - | - _self: Ref<::bevy_math::primitives::Ellipse>, - other: Ref<::bevy_math::primitives::Ellipse>| - { - let output: bool = { + "right_endpoint", + |_self: Ref<::bevy_math::primitives::Arc2d>| { + let output: Val<::bevy_math::Vec2> = { { - let output: bool = <::bevy_math::primitives::Ellipse as ::core::cmp::PartialEq< - ::bevy_math::primitives::Ellipse, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "focal_length", - |_self: Ref<::bevy_math::primitives::Ellipse>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::Ellipse::focal_length( - &_self, - ) - .into(); - output - } - }; - output - }, - " Get the focal length of the ellipse. This corresponds to the distance between one of the foci and the center of the ellipse.\n The focal length of an ellipse is related to its eccentricity by `eccentricity = focal_length / semi_major`", - &["_self"], - ) - .register_documented( - "new", - |half_width: f32, half_height: f32| { - let output: Val<::bevy_math::primitives::Ellipse> = { - { - let output: Val<::bevy_math::primitives::Ellipse> = ::bevy_math::primitives::Ellipse::new( - half_width, - half_height, - ) - .into(); - output - } - }; - output - }, - " Create a new `Ellipse` from half of its width and height.\n This corresponds to the two perpendicular radii defining the ellipse.", - &["half_width", "half_height"], - ) - .register_documented( - "semi_major", - |_self: Ref<::bevy_math::primitives::Ellipse>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::Ellipse::semi_major( + let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Arc2d::right_endpoint( &_self, ) .into(); @@ -3593,138 +3883,42 @@ pub(crate) fn register_ellipse_functions(world: &mut World) { }; output }, - " Returns the length of the semi-major axis. This corresponds to the longest radius of the ellipse.", + " Get the right-hand end point of the arc", &["_self"], ) .register_documented( - "semi_minor", - |_self: Ref<::bevy_math::primitives::Ellipse>| { + "sagitta", + |_self: Ref<::bevy_math::primitives::Arc2d>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::Ellipse::semi_minor( - &_self, - ) + let output: f32 = ::bevy_math::primitives::Arc2d::sagitta(&_self) .into(); output } }; output }, - " Returns the length of the semi-minor axis. This corresponds to the shortest radius of the ellipse.", + " Get the length of the sagitta of this arc, that is,\n the length of the line between the midpoints of the arc and its chord.\n Equivalently, the height of the triangle whose base is the chord and whose apex is the midpoint of the arc.\n The sagitta is also the sum of the [`radius`](Self::radius) and the [`apothem`](Self::apothem).", &["_self"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::primitives::Ellipse, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_line_2_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Line2d, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Line2d>| { - let output: Val<::bevy_math::primitives::Line2d> = { - { - let output: Val<::bevy_math::primitives::Line2d> = - <::bevy_math::primitives::Line2d as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::primitives::Line2d>, - other: Ref<::bevy_math::primitives::Line2d>| { - let output: bool = { - { - let output: bool = - <::bevy_math::primitives::Line2d as ::core::cmp::PartialEq< - ::bevy_math::primitives::Line2d, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::primitives::Line2d, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_plane_2_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Plane2d, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Plane2d>| { - let output: Val<::bevy_math::primitives::Plane2d> = { - { - let output: Val<::bevy_math::primitives::Plane2d> = - <::bevy_math::primitives::Plane2d as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::primitives::Plane2d>, - other: Ref<::bevy_math::primitives::Plane2d>| { - let output: bool = { - { - let output: bool = - <::bevy_math::primitives::Plane2d as ::core::cmp::PartialEq< - ::bevy_math::primitives::Plane2d, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::primitives::Plane2d, + ::bevy_math::primitives::Arc2d, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_rectangle_functions(world: &mut World) { +pub(crate) fn register_capsule_2_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Rectangle, + ::bevy_math::primitives::Capsule2d, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_math::primitives::Rectangle>| { - let output: Val<::bevy_math::primitives::Rectangle> = { + |_self: Ref<::bevy_math::primitives::Capsule2d>| { + let output: Val<::bevy_math::primitives::Capsule2d> = { { - let output: Val<::bevy_math::primitives::Rectangle> = <::bevy_math::primitives::Rectangle as ::core::clone::Clone>::clone( + let output: Val<::bevy_math::primitives::Capsule2d> = <::bevy_math::primitives::Capsule2d as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -3739,13 +3933,13 @@ pub(crate) fn register_rectangle_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_math::primitives::Rectangle>, - other: Ref<::bevy_math::primitives::Rectangle>| + _self: Ref<::bevy_math::primitives::Capsule2d>, + other: Ref<::bevy_math::primitives::Capsule2d>| { let output: bool = { { - let output: bool = <::bevy_math::primitives::Rectangle as ::core::cmp::PartialEq< - ::bevy_math::primitives::Rectangle, + let output: bool = <::bevy_math::primitives::Capsule2d as ::core::cmp::PartialEq< + ::bevy_math::primitives::Capsule2d, >>::eq(&_self, &other) .into(); output @@ -3757,11 +3951,12 @@ pub(crate) fn register_rectangle_functions(world: &mut World) { &["_self", "other"], ) .register_documented( - "from_length", - |length: f32| { - let output: Val<::bevy_math::primitives::Rectangle> = { + "new", + |radius: f32, length: f32| { + let output: Val<::bevy_math::primitives::Capsule2d> = { { - let output: Val<::bevy_math::primitives::Rectangle> = ::bevy_math::primitives::Rectangle::from_length( + let output: Val<::bevy_math::primitives::Capsule2d> = ::bevy_math::primitives::Capsule2d::new( + radius, length, ) .into(); @@ -3770,17 +3965,16 @@ pub(crate) fn register_rectangle_functions(world: &mut World) { }; output }, - " Create a `Rectangle` from a single length.\n The resulting `Rectangle` will be the same size in every direction.", - &["length"], + " Create a new `Capsule2d` from a radius and length", + &["radius", "length"], ) .register_documented( - "new", - |width: f32, height: f32| { + "to_inner_rectangle", + |_self: Ref<::bevy_math::primitives::Capsule2d>| { let output: Val<::bevy_math::primitives::Rectangle> = { { - let output: Val<::bevy_math::primitives::Rectangle> = ::bevy_math::primitives::Rectangle::new( - width, - height, + let output: Val<::bevy_math::primitives::Rectangle> = ::bevy_math::primitives::Capsule2d::to_inner_rectangle( + &_self, ) .into(); output @@ -3788,27 +3982,27 @@ pub(crate) fn register_rectangle_functions(world: &mut World) { }; output }, - " Create a new `Rectangle` from a full width and height", - &["width", "height"], + " Get the part connecting the semicircular ends of the capsule as a [`Rectangle`]", + &["_self"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::primitives::Rectangle, + ::bevy_math::primitives::Capsule2d, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_regular_polygon_functions(world: &mut World) { +pub(crate) fn register_circular_sector_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::RegularPolygon, + ::bevy_math::primitives::CircularSector, >::new(world) .register_documented( - "circumradius", - |_self: Ref<::bevy_math::primitives::RegularPolygon>| { + "angle", + |_self: Ref<::bevy_math::primitives::CircularSector>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::RegularPolygon::circumradius( + let output: f32 = ::bevy_math::primitives::CircularSector::angle( &_self, ) .into(); @@ -3817,15 +4011,15 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { }; output }, - " Get the radius of the circumcircle on which all vertices\n of the regular polygon lie", + " Get the angle of the sector", &["_self"], ) .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::RegularPolygon>| { - let output: Val<::bevy_math::primitives::RegularPolygon> = { + "apothem", + |_self: Ref<::bevy_math::primitives::CircularSector>| { + let output: f32 = { { - let output: Val<::bevy_math::primitives::RegularPolygon> = <::bevy_math::primitives::RegularPolygon as ::core::clone::Clone>::clone( + let output: f32 = ::bevy_math::primitives::CircularSector::apothem( &_self, ) .into(); @@ -3834,35 +4028,32 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { }; output }, - "", + " Get the length of the apothem of this sector\n See [`Arc2d::apothem`]", &["_self"], ) .register_documented( - "eq", - | - _self: Ref<::bevy_math::primitives::RegularPolygon>, - other: Ref<::bevy_math::primitives::RegularPolygon>| - { - let output: bool = { + "arc_length", + |_self: Ref<::bevy_math::primitives::CircularSector>| { + let output: f32 = { { - let output: bool = <::bevy_math::primitives::RegularPolygon as ::core::cmp::PartialEq< - ::bevy_math::primitives::RegularPolygon, - >>::eq(&_self, &other) + let output: f32 = ::bevy_math::primitives::CircularSector::arc_length( + &_self, + ) .into(); output } }; output }, - "", - &["_self", "other"], + " Get the length of the arc defining the sector", + &["_self"], ) .register_documented( - "external_angle_degrees", - |_self: Ref<::bevy_math::primitives::RegularPolygon>| { + "chord_length", + |_self: Ref<::bevy_math::primitives::CircularSector>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::RegularPolygon::external_angle_degrees( + let output: f32 = ::bevy_math::primitives::CircularSector::chord_length( &_self, ) .into(); @@ -3871,15 +4062,15 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { }; output }, - " Get the external angle of the regular polygon in degrees.\n This is the angle formed by two adjacent sides with points\n within the angle being in the exterior of the polygon", + " Get the length of the chord defined by the sector\n See [`Arc2d::chord_length`]", &["_self"], ) .register_documented( - "external_angle_radians", - |_self: Ref<::bevy_math::primitives::RegularPolygon>| { - let output: f32 = { + "chord_midpoint", + |_self: Ref<::bevy_math::primitives::CircularSector>| { + let output: Val<::bevy_math::Vec2> = { { - let output: f32 = ::bevy_math::primitives::RegularPolygon::external_angle_radians( + let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::CircularSector::chord_midpoint( &_self, ) .into(); @@ -3888,15 +4079,15 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { }; output }, - " Get the external angle of the regular polygon in radians.\n This is the angle formed by two adjacent sides with points\n within the angle being in the exterior of the polygon", + " Get the midpoint of the chord defined by the sector\n See [`Arc2d::chord_midpoint`]", &["_self"], ) .register_documented( - "inradius", - |_self: Ref<::bevy_math::primitives::RegularPolygon>| { - let output: f32 = { + "clone", + |_self: Ref<::bevy_math::primitives::CircularSector>| { + let output: Val<::bevy_math::primitives::CircularSector> = { { - let output: f32 = ::bevy_math::primitives::RegularPolygon::inradius( + let output: Val<::bevy_math::primitives::CircularSector> = <::bevy_math::primitives::CircularSector as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -3905,33 +4096,37 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { }; output }, - " Get the inradius or apothem of the regular polygon.\n This is the radius of the largest circle that can\n be drawn within the polygon", + "", &["_self"], ) .register_documented( - "internal_angle_degrees", - |_self: Ref<::bevy_math::primitives::RegularPolygon>| { - let output: f32 = { + "eq", + | + _self: Ref<::bevy_math::primitives::CircularSector>, + other: Ref<::bevy_math::primitives::CircularSector>| + { + let output: bool = { { - let output: f32 = ::bevy_math::primitives::RegularPolygon::internal_angle_degrees( - &_self, - ) + let output: bool = <::bevy_math::primitives::CircularSector as ::core::cmp::PartialEq< + ::bevy_math::primitives::CircularSector, + >>::eq(&_self, &other) .into(); output } }; output }, - " Get the internal angle of the regular polygon in degrees.\n This is the angle formed by two adjacent sides with points\n within the angle being in the interior of the polygon", - &["_self"], + "", + &["_self", "other"], ) .register_documented( - "internal_angle_radians", - |_self: Ref<::bevy_math::primitives::RegularPolygon>| { - let output: f32 = { + "from_degrees", + |radius: f32, angle: f32| { + let output: Val<::bevy_math::primitives::CircularSector> = { { - let output: f32 = ::bevy_math::primitives::RegularPolygon::internal_angle_radians( - &_self, + let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::from_degrees( + radius, + angle, ) .into(); output @@ -3939,17 +4134,17 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { }; output }, - " Get the internal angle of the regular polygon in radians.\n This is the angle formed by two adjacent sides with points\n within the angle being in the interior of the polygon", - &["_self"], + " Create a new [`CircularSector`] from a `radius` and an `angle` in degrees.", + &["radius", "angle"], ) .register_documented( - "new", - |circumradius: f32, sides: u32| { - let output: Val<::bevy_math::primitives::RegularPolygon> = { + "from_radians", + |radius: f32, angle: f32| { + let output: Val<::bevy_math::primitives::CircularSector> = { { - let output: Val<::bevy_math::primitives::RegularPolygon> = ::bevy_math::primitives::RegularPolygon::new( - circumradius, - sides, + let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::from_radians( + radius, + angle, ) .into(); output @@ -3957,16 +4152,17 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { }; output }, - " Create a new `RegularPolygon`\n from the radius of the circumcircle and a number of sides\n # Panics\n Panics if `circumradius` is negative", - &["circumradius", "sides"], + " Create a new [`CircularSector`] from a `radius` and an `angle` in radians.", + &["radius", "angle"], ) .register_documented( - "side_length", - |_self: Ref<::bevy_math::primitives::RegularPolygon>| { - let output: f32 = { + "from_turns", + |radius: f32, fraction: f32| { + let output: Val<::bevy_math::primitives::CircularSector> = { { - let output: f32 = ::bevy_math::primitives::RegularPolygon::side_length( - &_self, + let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::from_turns( + radius, + fraction, ) .into(); output @@ -3974,165 +4170,15 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { }; output }, - " Get the length of one side of the regular polygon", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::primitives::RegularPolygon, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_rhombus_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Rhombus, - >::new(world) - .register_documented( - "circumradius", - |_self: Ref<::bevy_math::primitives::Rhombus>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::Rhombus::circumradius(&_self).into(); - output - } - }; - output - }, - " Get the radius of the circumcircle on which all vertices\n of the rhombus lie", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Rhombus>| { - let output: Val<::bevy_math::primitives::Rhombus> = { - { - let output: Val<::bevy_math::primitives::Rhombus> = - <::bevy_math::primitives::Rhombus as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::primitives::Rhombus>, - other: Ref<::bevy_math::primitives::Rhombus>| { - let output: bool = { - { - let output: bool = - <::bevy_math::primitives::Rhombus as ::core::cmp::PartialEq< - ::bevy_math::primitives::Rhombus, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "from_inradius", - |inradius: f32| { - let output: Val<::bevy_math::primitives::Rhombus> = { - { - let output: Val<::bevy_math::primitives::Rhombus> = - ::bevy_math::primitives::Rhombus::from_inradius(inradius).into(); - output - } - }; - output - }, - " Create a new `Rhombus` from a given inradius with all inner angles equal.", - &["inradius"], - ) - .register_documented( - "from_side", - |side: f32| { - let output: Val<::bevy_math::primitives::Rhombus> = { - { - let output: Val<::bevy_math::primitives::Rhombus> = - ::bevy_math::primitives::Rhombus::from_side(side).into(); - output - } - }; - output - }, - " Create a new `Rhombus` from a side length with all inner angles equal.", - &["side"], - ) - .register_documented( - "inradius", - |_self: Ref<::bevy_math::primitives::Rhombus>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::Rhombus::inradius(&_self).into(); - output - } - }; - output - }, - " Get the radius of the largest circle that can\n be drawn within the rhombus", - &["_self"], - ) - .register_documented( - "new", - |horizontal_diagonal: f32, vertical_diagonal: f32| { - let output: Val<::bevy_math::primitives::Rhombus> = { - { - let output: Val<::bevy_math::primitives::Rhombus> = - ::bevy_math::primitives::Rhombus::new( - horizontal_diagonal, - vertical_diagonal, - ) - .into(); - output - } - }; - output - }, - " Create a new `Rhombus` from a vertical and horizontal diagonal sizes.", - &["horizontal_diagonal", "vertical_diagonal"], - ) - .register_documented( - "side", - |_self: Ref<::bevy_math::primitives::Rhombus>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::Rhombus::side(&_self).into(); - output - } - }; - output - }, - " Get the length of each side of the rhombus", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::primitives::Rhombus, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_segment_2_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Segment2d, - >::new(world) + " Create a new [`CircularSector`] from a `radius` and a number of `turns` of a circle.\n For instance, `0.5` turns is a semicircle.", + &["radius", "fraction"], + ) .register_documented( - "centered", - |_self: Ref<::bevy_math::primitives::Segment2d>| { - let output: Val<::bevy_math::primitives::Segment2d> = { + "half_angle", + |_self: Ref<::bevy_math::primitives::CircularSector>| { + let output: f32 = { { - let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::centered( + let output: f32 = ::bevy_math::primitives::CircularSector::half_angle( &_self, ) .into(); @@ -4141,15 +4187,15 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { }; output }, - " Compute the segment with its center at the origin, keeping the same direction and length.", + " Get half the angle of the sector", &["_self"], ) .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Segment2d>| { - let output: Val<::bevy_math::primitives::Segment2d> = { + "half_chord_length", + |_self: Ref<::bevy_math::primitives::CircularSector>| { + let output: f32 = { { - let output: Val<::bevy_math::primitives::Segment2d> = <::bevy_math::primitives::Segment2d as ::core::clone::Clone>::clone( + let output: f32 = ::bevy_math::primitives::CircularSector::half_chord_length( &_self, ) .into(); @@ -4158,16 +4204,17 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { }; output }, - "", + " Get half the length of the chord defined by the sector\n See [`Arc2d::half_chord_length`]", &["_self"], ) .register_documented( - "direction", - |_self: Ref<::bevy_math::primitives::Segment2d>| { - let output: Val<::bevy_math::prelude::Dir2> = { + "new", + |radius: f32, angle: f32| { + let output: Val<::bevy_math::primitives::CircularSector> = { { - let output: Val<::bevy_math::prelude::Dir2> = ::bevy_math::primitives::Segment2d::direction( - &_self, + let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::new( + radius, + angle, ) .into(); output @@ -4175,37 +4222,33 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { }; output }, - " Compute the normalized direction pointing from the first endpoint to the second endpoint.\n For the non-panicking version, see [`Segment2d::try_direction`].\n # Panics\n Panics if a valid direction could not be computed, for example when the endpoints are coincident, NaN, or infinite.", - &["_self"], + " Create a new [`CircularSector`] from a `radius` and an `angle`", + &["radius", "angle"], ) .register_documented( - "eq", - | - _self: Ref<::bevy_math::primitives::Segment2d>, - other: Ref<::bevy_math::primitives::Segment2d>| - { - let output: bool = { + "radius", + |_self: Ref<::bevy_math::primitives::CircularSector>| { + let output: f32 = { { - let output: bool = <::bevy_math::primitives::Segment2d as ::core::cmp::PartialEq< - ::bevy_math::primitives::Segment2d, - >>::eq(&_self, &other) + let output: f32 = ::bevy_math::primitives::CircularSector::radius( + &_self, + ) .into(); output } }; output }, - "", - &["_self", "other"], + " Get the radius of the sector", + &["_self"], ) .register_documented( - "from_direction_and_length", - |direction: Val<::bevy_math::prelude::Dir2>, length: f32| { - let output: Val<::bevy_math::primitives::Segment2d> = { + "sagitta", + |_self: Ref<::bevy_math::primitives::CircularSector>| { + let output: f32 = { { - let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::from_direction_and_length( - direction.into_inner(), - length, + let output: f32 = ::bevy_math::primitives::CircularSector::sagitta( + &_self, ) .into(); output @@ -4213,17 +4256,28 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { }; output }, - " Create a new `Segment2d` centered at the origin with the given direction and length.\n The endpoints will be at `-direction * length / 2.0` and `direction * length / 2.0`.", - &["direction", "length"], - ) + " Get the length of the sagitta of this sector\n See [`Arc2d::sagitta`]", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::CircularSector, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_circular_segment_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::CircularSegment, + >::new(world) .register_documented( - "from_ray_and_length", - |ray: Val<::bevy_math::Ray2d>, length: f32| { - let output: Val<::bevy_math::primitives::Segment2d> = { + "angle", + |_self: Ref<::bevy_math::primitives::CircularSegment>| { + let output: f32 = { { - let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::from_ray_and_length( - ray.into_inner(), - length, + let output: f32 = ::bevy_math::primitives::CircularSegment::angle( + &_self, ) .into(); output @@ -4231,15 +4285,15 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { }; output }, - " Create a new `Segment2d` starting from the origin of the given `ray`,\n going in the direction of the ray for the given `length`.\n The endpoints will be at `ray.origin` and `ray.origin + length * ray.direction`.", - &["ray", "length"], + " Get the angle of the segment", + &["_self"], ) .register_documented( - "left_normal", - |_self: Ref<::bevy_math::primitives::Segment2d>| { - let output: Val<::bevy_math::prelude::Dir2> = { + "apothem", + |_self: Ref<::bevy_math::primitives::CircularSegment>| { + let output: f32 = { { - let output: Val<::bevy_math::prelude::Dir2> = ::bevy_math::primitives::Segment2d::left_normal( + let output: f32 = ::bevy_math::primitives::CircularSegment::apothem( &_self, ) .into(); @@ -4248,15 +4302,15 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { }; output }, - " Compute the normalized counterclockwise normal on the left-hand side of the line segment.\n For the non-panicking version, see [`Segment2d::try_left_normal`].\n # Panics\n Panics if a valid normal could not be computed, for example when the endpoints are coincident, NaN, or infinite.", + " Get the length of the apothem of this segment,\n which is the signed distance between the segment and the center of its circle\n See [`Arc2d::apothem`]", &["_self"], ) .register_documented( - "length", - |_self: Ref<::bevy_math::primitives::Segment2d>| { + "arc_length", + |_self: Ref<::bevy_math::primitives::CircularSegment>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::Segment2d::length( + let output: f32 = ::bevy_math::primitives::CircularSegment::arc_length( &_self, ) .into(); @@ -4265,15 +4319,15 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { }; output }, - " Compute the length of the line segment.", + " Get the length of the arc defining the segment", &["_self"], ) .register_documented( - "length_squared", - |_self: Ref<::bevy_math::primitives::Segment2d>| { + "chord_length", + |_self: Ref<::bevy_math::primitives::CircularSegment>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::Segment2d::length_squared( + let output: f32 = ::bevy_math::primitives::CircularSegment::chord_length( &_self, ) .into(); @@ -4282,17 +4336,16 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { }; output }, - " Compute the squared length of the line segment.", + " Get the length of the segment's base, also known as its chord", &["_self"], ) .register_documented( - "resized", - |_self: Ref<::bevy_math::primitives::Segment2d>, length: f32| { - let output: Val<::bevy_math::primitives::Segment2d> = { + "chord_midpoint", + |_self: Ref<::bevy_math::primitives::CircularSegment>| { + let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::resized( + let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::CircularSegment::chord_midpoint( &_self, - length, ) .into(); output @@ -4300,16 +4353,16 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { }; output }, - " Compute the segment with a new length, keeping the same direction and center.", - &["_self", "length"], + " Get the midpoint of the segment's base, also known as its chord", + &["_self"], ) .register_documented( - "reverse", - |mut _self: Mut<::bevy_math::primitives::Segment2d>| { - let output: () = { + "clone", + |_self: Ref<::bevy_math::primitives::CircularSegment>| { + let output: Val<::bevy_math::primitives::CircularSegment> = { { - let output: () = ::bevy_math::primitives::Segment2d::reverse( - &mut _self, + let output: Val<::bevy_math::primitives::CircularSegment> = <::bevy_math::primitives::CircularSegment as ::core::clone::Clone>::clone( + &_self, ) .into(); output @@ -4317,33 +4370,37 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { }; output }, - " Reverses the direction of the line segment by swapping the endpoints.", + "", &["_self"], ) .register_documented( - "reversed", - |_self: Val<::bevy_math::primitives::Segment2d>| { - let output: Val<::bevy_math::primitives::Segment2d> = { + "eq", + | + _self: Ref<::bevy_math::primitives::CircularSegment>, + other: Ref<::bevy_math::primitives::CircularSegment>| + { + let output: bool = { { - let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::reversed( - _self.into_inner(), - ) + let output: bool = <::bevy_math::primitives::CircularSegment as ::core::cmp::PartialEq< + ::bevy_math::primitives::CircularSegment, + >>::eq(&_self, &other) .into(); output } }; output }, - " Returns the line segment with its direction reversed by swapping the endpoints.", - &["_self"], + "", + &["_self", "other"], ) .register_documented( - "right_normal", - |_self: Ref<::bevy_math::primitives::Segment2d>| { - let output: Val<::bevy_math::prelude::Dir2> = { + "from_degrees", + |radius: f32, angle: f32| { + let output: Val<::bevy_math::primitives::CircularSegment> = { { - let output: Val<::bevy_math::prelude::Dir2> = ::bevy_math::primitives::Segment2d::right_normal( - &_self, + let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::from_degrees( + radius, + angle, ) .into(); output @@ -4351,20 +4408,17 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { }; output }, - " Compute the normalized clockwise normal on the right-hand side of the line segment.\n For the non-panicking version, see [`Segment2d::try_right_normal`].\n # Panics\n Panics if a valid normal could not be computed, for example when the endpoints are coincident, NaN, or infinite.", - &["_self"], + " Create a new [`CircularSegment`] from a `radius` and an `angle` in degrees.", + &["radius", "angle"], ) .register_documented( - "rotated", - | - _self: Ref<::bevy_math::primitives::Segment2d>, - rotation: Val<::bevy_math::Rot2>| - { - let output: Val<::bevy_math::primitives::Segment2d> = { + "from_radians", + |radius: f32, angle: f32| { + let output: Val<::bevy_math::primitives::CircularSegment> = { { - let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::rotated( - &_self, - rotation.into_inner(), + let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::from_radians( + radius, + angle, ) .into(); output @@ -4372,20 +4426,17 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { }; output }, - " Compute the segment rotated around the origin by the given rotation.", - &["_self", "rotation"], + " Create a new [`CircularSegment`] from a `radius` and an `angle` in radians.", + &["radius", "angle"], ) .register_documented( - "rotated_around_center", - | - _self: Ref<::bevy_math::primitives::Segment2d>, - rotation: Val<::bevy_math::Rot2>| - { - let output: Val<::bevy_math::primitives::Segment2d> = { + "from_turns", + |radius: f32, fraction: f32| { + let output: Val<::bevy_math::primitives::CircularSegment> = { { - let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::rotated_around_center( - &_self, - rotation.into_inner(), + let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::from_turns( + radius, + fraction, ) .into(); output @@ -4393,27 +4444,113 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { }; output }, - " Compute the segment rotated around its own center.", - &["_self", "rotation"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::primitives::Segment2d, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_triangle_2_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Triangle2d, - >::new(world) + " Create a new [`CircularSegment`] from a `radius` and a number of `turns` of a circle.\n For instance, `0.5` turns is a semicircle.", + &["radius", "fraction"], + ) .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Triangle2d>| { - let output: Val<::bevy_math::primitives::Triangle2d> = { + "half_angle", + |_self: Ref<::bevy_math::primitives::CircularSegment>| { + let output: f32 = { { - let output: Val<::bevy_math::primitives::Triangle2d> = <::bevy_math::primitives::Triangle2d as ::core::clone::Clone>::clone( + let output: f32 = ::bevy_math::primitives::CircularSegment::half_angle( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the half-angle of the segment", + &["_self"], + ) + .register_documented( + "half_chord_length", + |_self: Ref<::bevy_math::primitives::CircularSegment>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::CircularSegment::half_chord_length( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get half the length of the segment's base, also known as its chord", + &["_self"], + ) + .register_documented( + "new", + |radius: f32, angle: f32| { + let output: Val<::bevy_math::primitives::CircularSegment> = { + { + let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::new( + radius, + angle, + ) + .into(); + output + } + }; + output + }, + " Create a new [`CircularSegment`] from a `radius`, and an `angle`", + &["radius", "angle"], + ) + .register_documented( + "radius", + |_self: Ref<::bevy_math::primitives::CircularSegment>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::CircularSegment::radius( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the radius of the segment", + &["_self"], + ) + .register_documented( + "sagitta", + |_self: Ref<::bevy_math::primitives::CircularSegment>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::CircularSegment::sagitta( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the length of the sagitta of this segment, also known as its height\n See [`Arc2d::sagitta`]", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::CircularSegment, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_ellipse_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Ellipse, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Ellipse>| { + let output: Val<::bevy_math::primitives::Ellipse> = { + { + let output: Val<::bevy_math::primitives::Ellipse> = <::bevy_math::primitives::Ellipse as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -4425,16 +4562,33 @@ pub(crate) fn register_triangle_2_d_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "eccentricity", + |_self: Ref<::bevy_math::primitives::Ellipse>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::Ellipse::eccentricity( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the [eccentricity](https://en.wikipedia.org/wiki/Eccentricity_(mathematics)) of the ellipse.\n It can be thought of as a measure of how \"stretched\" or elongated the ellipse is.\n The value should be in the range [0, 1), where 0 represents a circle, and 1 represents a parabola.", + &["_self"], + ) .register_documented( "eq", | - _self: Ref<::bevy_math::primitives::Triangle2d>, - other: Ref<::bevy_math::primitives::Triangle2d>| + _self: Ref<::bevy_math::primitives::Ellipse>, + other: Ref<::bevy_math::primitives::Ellipse>| { let output: bool = { { - let output: bool = <::bevy_math::primitives::Triangle2d as ::core::cmp::PartialEq< - ::bevy_math::primitives::Triangle2d, + let output: bool = <::bevy_math::primitives::Ellipse as ::core::cmp::PartialEq< + ::bevy_math::primitives::Ellipse, >>::eq(&_self, &other) .into(); output @@ -4446,11 +4600,11 @@ pub(crate) fn register_triangle_2_d_functions(world: &mut World) { &["_self", "other"], ) .register_documented( - "is_acute", - |_self: Ref<::bevy_math::primitives::Triangle2d>| { - let output: bool = { + "focal_length", + |_self: Ref<::bevy_math::primitives::Ellipse>| { + let output: f32 = { { - let output: bool = ::bevy_math::primitives::Triangle2d::is_acute( + let output: f32 = ::bevy_math::primitives::Ellipse::focal_length( &_self, ) .into(); @@ -4459,16 +4613,16 @@ pub(crate) fn register_triangle_2_d_functions(world: &mut World) { }; output }, - " Checks if the triangle is acute, meaning all angles are less than 90 degrees", + " Get the focal length of the ellipse. This corresponds to the distance between one of the foci and the center of the ellipse.\n The focal length of an ellipse is related to its eccentricity by `eccentricity = focal_length / semi_major`", &["_self"], ) .register_documented( - "is_degenerate", - |_self: Ref<::bevy_math::primitives::Triangle2d>| { - let output: bool = { + "from_size", + |size: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_math::primitives::Ellipse> = { { - let output: bool = ::bevy_math::primitives::Triangle2d::is_degenerate( - &_self, + let output: Val<::bevy_math::primitives::Ellipse> = ::bevy_math::primitives::Ellipse::from_size( + size.into_inner(), ) .into(); output @@ -4476,16 +4630,17 @@ pub(crate) fn register_triangle_2_d_functions(world: &mut World) { }; output }, - " Checks if the triangle is degenerate, meaning it has zero area.\n A triangle is degenerate if the cross product of the vectors `ab` and `ac` has a length less than `10e-7`.\n This indicates that the three vertices are collinear or nearly collinear.", - &["_self"], + " Create a new `Ellipse` from a given full size.\n `size.x` is the diameter along the X axis, and `size.y` is the diameter along the Y axis.", + &["size"], ) .register_documented( - "is_obtuse", - |_self: Ref<::bevy_math::primitives::Triangle2d>| { - let output: bool = { + "new", + |half_width: f32, half_height: f32| { + let output: Val<::bevy_math::primitives::Ellipse> = { { - let output: bool = ::bevy_math::primitives::Triangle2d::is_obtuse( - &_self, + let output: Val<::bevy_math::primitives::Ellipse> = ::bevy_math::primitives::Ellipse::new( + half_width, + half_height, ) .into(); output @@ -4493,16 +4648,16 @@ pub(crate) fn register_triangle_2_d_functions(world: &mut World) { }; output }, - " Checks if the triangle is obtuse, meaning one angle is greater than 90 degrees", - &["_self"], + " Create a new `Ellipse` from half of its width and height.\n This corresponds to the two perpendicular radii defining the ellipse.", + &["half_width", "half_height"], ) .register_documented( - "reverse", - |mut _self: Mut<::bevy_math::primitives::Triangle2d>| { - let output: () = { + "semi_major", + |_self: Ref<::bevy_math::primitives::Ellipse>| { + let output: f32 = { { - let output: () = ::bevy_math::primitives::Triangle2d::reverse( - &mut _self, + let output: f32 = ::bevy_math::primitives::Ellipse::semi_major( + &_self, ) .into(); output @@ -4510,16 +4665,16 @@ pub(crate) fn register_triangle_2_d_functions(world: &mut World) { }; output }, - " Reverse the [`WindingOrder`] of the triangle\n by swapping the first and last vertices.", + " Returns the length of the semi-major axis. This corresponds to the longest radius of the ellipse.", &["_self"], ) .register_documented( - "reversed", - |_self: Val<::bevy_math::primitives::Triangle2d>| { - let output: Val<::bevy_math::primitives::Triangle2d> = { + "semi_minor", + |_self: Ref<::bevy_math::primitives::Ellipse>| { + let output: f32 = { { - let output: Val<::bevy_math::primitives::Triangle2d> = ::bevy_math::primitives::Triangle2d::reversed( - _self.into_inner(), + let output: f32 = ::bevy_math::primitives::Ellipse::semi_minor( + &_self, ) .into(); output @@ -4527,76 +4682,76 @@ pub(crate) fn register_triangle_2_d_functions(world: &mut World) { }; output }, - " This triangle but reversed.", + " Returns the length of the semi-minor axis. This corresponds to the shortest radius of the ellipse.", &["_self"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::primitives::Triangle2d, + ::bevy_math::primitives::Ellipse, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_convex_polygon_functions(world: &mut World) { +pub(crate) fn register_line_2_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::ConvexPolygon, + ::bevy_math::primitives::Line2d, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::ConvexPolygon>| { - let output: Val<::bevy_math::primitives::ConvexPolygon> = { - { - let output: Val<::bevy_math::primitives::ConvexPolygon> = - <::bevy_math::primitives::ConvexPolygon as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::primitives::ConvexPolygon>, - other: Ref<::bevy_math::primitives::ConvexPolygon>| { - let output: bool = { - { - let output: bool = - <::bevy_math::primitives::ConvexPolygon as ::core::cmp::PartialEq< - ::bevy_math::primitives::ConvexPolygon, + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Line2d>| { + let output: Val<::bevy_math::primitives::Line2d> = { + { + let output: Val<::bevy_math::primitives::Line2d> = <::bevy_math::primitives::Line2d as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::primitives::Line2d>, + other: Ref<::bevy_math::primitives::Line2d>| + { + let output: bool = { + { + let output: bool = <::bevy_math::primitives::Line2d as ::core::cmp::PartialEq< + ::bevy_math::primitives::Line2d, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::primitives::ConvexPolygon, + ::bevy_math::primitives::Line2d, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_polygon_functions(world: &mut World) { +pub(crate) fn register_plane_2_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Polygon, + ::bevy_math::primitives::Plane2d, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_math::primitives::Polygon>| { - let output: Val<::bevy_math::primitives::Polygon> = { + |_self: Ref<::bevy_math::primitives::Plane2d>| { + let output: Val<::bevy_math::primitives::Plane2d> = { { - let output: Val<::bevy_math::primitives::Polygon> = <::bevy_math::primitives::Polygon as ::core::clone::Clone>::clone( + let output: Val<::bevy_math::primitives::Plane2d> = <::bevy_math::primitives::Plane2d as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -4611,13 +4766,13 @@ pub(crate) fn register_polygon_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_math::primitives::Polygon>, - other: Ref<::bevy_math::primitives::Polygon>| + _self: Ref<::bevy_math::primitives::Plane2d>, + other: Ref<::bevy_math::primitives::Plane2d>| { let output: bool = { { - let output: bool = <::bevy_math::primitives::Polygon as ::core::cmp::PartialEq< - ::bevy_math::primitives::Polygon, + let output: bool = <::bevy_math::primitives::Plane2d as ::core::cmp::PartialEq< + ::bevy_math::primitives::Plane2d, >>::eq(&_self, &other) .into(); output @@ -4629,12 +4784,12 @@ pub(crate) fn register_polygon_functions(world: &mut World) { &["_self", "other"], ) .register_documented( - "is_simple", - |_self: Ref<::bevy_math::primitives::Polygon>| { - let output: bool = { + "new", + |normal: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_math::primitives::Plane2d> = { { - let output: bool = ::bevy_math::primitives::Polygon::is_simple( - &_self, + let output: Val<::bevy_math::primitives::Plane2d> = ::bevy_math::primitives::Plane2d::new( + normal.into_inner(), ) .into(); output @@ -4642,290 +4797,201 @@ pub(crate) fn register_polygon_functions(world: &mut World) { }; output }, - " Tests if the polygon is simple.\n A polygon is simple if it is not self intersecting and not self tangent.\n As such, no two edges of the polygon may cross each other and each vertex must not lie on another edge.", - &["_self"], + " Create a new `Plane2d` from a normal\n # Panics\n Panics if the given `normal` is zero (or very close to zero), or non-finite.", + &["normal"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::primitives::Polygon, + ::bevy_math::primitives::Plane2d, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_polyline_2_d_functions(world: &mut World) { +pub(crate) fn register_rectangle_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Polyline2d, + ::bevy_math::primitives::Rectangle, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Polyline2d>| { - let output: Val<::bevy_math::primitives::Polyline2d> = { - { - let output: Val<::bevy_math::primitives::Polyline2d> = - <::bevy_math::primitives::Polyline2d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::primitives::Polyline2d>, - other: Ref<::bevy_math::primitives::Polyline2d>| { - let output: bool = { - { - let output: bool = - <::bevy_math::primitives::Polyline2d as ::core::cmp::PartialEq< - ::bevy_math::primitives::Polyline2d, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::primitives::Polyline2d, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_aabb_3_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::bounding::Aabb3d, - >::new(world) - .register_documented( - "bounding_sphere", - |_self: Ref<::bevy_math::bounding::Aabb3d>| { - let output: Val<::bevy_math::bounding::BoundingSphere> = { - { - let output: Val<::bevy_math::bounding::BoundingSphere> = - ::bevy_math::bounding::Aabb3d::bounding_sphere(&_self).into(); - output - } - }; - output - }, - " Computes the smallest [`BoundingSphere`] containing this [`Aabb3d`].", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_math::bounding::Aabb3d>| { - let output: Val<::bevy_math::bounding::Aabb3d> = { - { - let output: Val<::bevy_math::bounding::Aabb3d> = - <::bevy_math::bounding::Aabb3d as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::bounding::Aabb3d>, other: Ref<::bevy_math::bounding::Aabb3d>| { - let output: bool = { - { - let output: bool = <::bevy_math::bounding::Aabb3d as ::core::cmp::PartialEq< - ::bevy_math::bounding::Aabb3d, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::bounding::Aabb3d, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_bounding_sphere_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::bounding::BoundingSphere, - >::new(world) - .register_documented( - "aabb_3d", - |_self: Ref<::bevy_math::bounding::BoundingSphere>| { - let output: Val<::bevy_math::bounding::Aabb3d> = { - { - let output: Val<::bevy_math::bounding::Aabb3d> = - ::bevy_math::bounding::BoundingSphere::aabb_3d(&_self).into(); - output - } - }; - output - }, - " Computes the smallest [`Aabb3d`] containing this [`BoundingSphere`].", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_math::bounding::BoundingSphere>| { - let output: Val<::bevy_math::bounding::BoundingSphere> = { - { - let output: Val<::bevy_math::bounding::BoundingSphere> = - <::bevy_math::bounding::BoundingSphere as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::bounding::BoundingSphere>, - other: Ref<::bevy_math::bounding::BoundingSphere>| { - let output: bool = { - { - let output: bool = - <::bevy_math::bounding::BoundingSphere as ::core::cmp::PartialEq< - ::bevy_math::bounding::BoundingSphere, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "radius", - |_self: Ref<::bevy_math::bounding::BoundingSphere>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::bounding::BoundingSphere::radius(&_self).into(); - output - } - }; - output - }, - " Get the radius of the bounding sphere", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::bounding::BoundingSphere, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_sphere_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Sphere, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Sphere>| { - let output: Val<::bevy_math::primitives::Sphere> = { - { - let output: Val<::bevy_math::primitives::Sphere> = - <::bevy_math::primitives::Sphere as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "diameter", - |_self: Ref<::bevy_math::primitives::Sphere>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::Sphere::diameter(&_self).into(); - output - } - }; - output - }, - " Get the diameter of the sphere", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::primitives::Sphere>, - other: Ref<::bevy_math::primitives::Sphere>| { - let output: bool = { - { - let output: bool = - <::bevy_math::primitives::Sphere as ::core::cmp::PartialEq< - ::bevy_math::primitives::Sphere, + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Rectangle>| { + let output: Val<::bevy_math::primitives::Rectangle> = { + { + let output: Val<::bevy_math::primitives::Rectangle> = <::bevy_math::primitives::Rectangle as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "closest_point", + | + _self: Ref<::bevy_math::primitives::Rectangle>, + point: Val<::bevy_math::Vec2>| + { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Rectangle::closest_point( + &_self, + point.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Finds the point on the rectangle that is closest to the given `point`.\n If the point is outside the rectangle, the returned point will be on the perimeter of the rectangle.\n Otherwise, it will be inside the rectangle and returned as is.", + &["_self", "point"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::primitives::Rectangle>, + other: Ref<::bevy_math::primitives::Rectangle>| + { + let output: bool = { + { + let output: bool = <::bevy_math::primitives::Rectangle as ::core::cmp::PartialEq< + ::bevy_math::primitives::Rectangle, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "new", - |radius: f32| { - let output: Val<::bevy_math::primitives::Sphere> = { - { - let output: Val<::bevy_math::primitives::Sphere> = - ::bevy_math::primitives::Sphere::new(radius).into(); - output - } - }; - output - }, - " Create a new [`Sphere`] from a `radius`", - &["radius"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "from_corners", + |point1: Val<::bevy_math::Vec2>, point2: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_math::primitives::Rectangle> = { + { + let output: Val<::bevy_math::primitives::Rectangle> = ::bevy_math::primitives::Rectangle::from_corners( + point1.into_inner(), + point2.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new `Rectangle` from two corner points", + &["point1", "point2"], + ) + .register_documented( + "from_length", + |length: f32| { + let output: Val<::bevy_math::primitives::Rectangle> = { + { + let output: Val<::bevy_math::primitives::Rectangle> = ::bevy_math::primitives::Rectangle::from_length( + length, + ) + .into(); + output + } + }; + output + }, + " Create a `Rectangle` from a single length.\n The resulting `Rectangle` will be the same size in every direction.", + &["length"], + ) + .register_documented( + "from_size", + |size: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_math::primitives::Rectangle> = { + { + let output: Val<::bevy_math::primitives::Rectangle> = ::bevy_math::primitives::Rectangle::from_size( + size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new `Rectangle` from a given full size", + &["size"], + ) + .register_documented( + "new", + |width: f32, height: f32| { + let output: Val<::bevy_math::primitives::Rectangle> = { + { + let output: Val<::bevy_math::primitives::Rectangle> = ::bevy_math::primitives::Rectangle::new( + width, + height, + ) + .into(); + output + } + }; + output + }, + " Create a new `Rectangle` from a full width and height", + &["width", "height"], + ) + .register_documented( + "size", + |_self: Ref<::bevy_math::primitives::Rectangle>| { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Rectangle::size( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the size of the rectangle", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::primitives::Sphere, + ::bevy_math::primitives::Rectangle, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_cuboid_functions(world: &mut World) { +pub(crate) fn register_regular_polygon_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Cuboid, + ::bevy_math::primitives::RegularPolygon, >::new(world) + .register_documented( + "circumradius", + |_self: Ref<::bevy_math::primitives::RegularPolygon>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::RegularPolygon::circumradius( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the radius of the circumcircle on which all vertices\n of the regular polygon lie", + &["_self"], + ) .register_documented( "clone", - |_self: Ref<::bevy_math::primitives::Cuboid>| { - let output: Val<::bevy_math::primitives::Cuboid> = { + |_self: Ref<::bevy_math::primitives::RegularPolygon>| { + let output: Val<::bevy_math::primitives::RegularPolygon> = { { - let output: Val<::bevy_math::primitives::Cuboid> = <::bevy_math::primitives::Cuboid as ::core::clone::Clone>::clone( + let output: Val<::bevy_math::primitives::RegularPolygon> = <::bevy_math::primitives::RegularPolygon as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -4940,13 +5006,2526 @@ pub(crate) fn register_cuboid_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_math::primitives::Cuboid>, - other: Ref<::bevy_math::primitives::Cuboid>| + _self: Ref<::bevy_math::primitives::RegularPolygon>, + other: Ref<::bevy_math::primitives::RegularPolygon>| { let output: bool = { { - let output: bool = <::bevy_math::primitives::Cuboid as ::core::cmp::PartialEq< - ::bevy_math::primitives::Cuboid, + let output: bool = <::bevy_math::primitives::RegularPolygon as ::core::cmp::PartialEq< + ::bevy_math::primitives::RegularPolygon, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "external_angle_degrees", + |_self: Ref<::bevy_math::primitives::RegularPolygon>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::RegularPolygon::external_angle_degrees( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the external angle of the regular polygon in degrees.\n This is the angle formed by two adjacent sides with points\n within the angle being in the exterior of the polygon", + &["_self"], + ) + .register_documented( + "external_angle_radians", + |_self: Ref<::bevy_math::primitives::RegularPolygon>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::RegularPolygon::external_angle_radians( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the external angle of the regular polygon in radians.\n This is the angle formed by two adjacent sides with points\n within the angle being in the exterior of the polygon", + &["_self"], + ) + .register_documented( + "inradius", + |_self: Ref<::bevy_math::primitives::RegularPolygon>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::RegularPolygon::inradius( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the inradius or apothem of the regular polygon.\n This is the radius of the largest circle that can\n be drawn within the polygon", + &["_self"], + ) + .register_documented( + "internal_angle_degrees", + |_self: Ref<::bevy_math::primitives::RegularPolygon>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::RegularPolygon::internal_angle_degrees( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the internal angle of the regular polygon in degrees.\n This is the angle formed by two adjacent sides with points\n within the angle being in the interior of the polygon", + &["_self"], + ) + .register_documented( + "internal_angle_radians", + |_self: Ref<::bevy_math::primitives::RegularPolygon>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::RegularPolygon::internal_angle_radians( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the internal angle of the regular polygon in radians.\n This is the angle formed by two adjacent sides with points\n within the angle being in the interior of the polygon", + &["_self"], + ) + .register_documented( + "new", + |circumradius: f32, sides: u32| { + let output: Val<::bevy_math::primitives::RegularPolygon> = { + { + let output: Val<::bevy_math::primitives::RegularPolygon> = ::bevy_math::primitives::RegularPolygon::new( + circumradius, + sides, + ) + .into(); + output + } + }; + output + }, + " Create a new `RegularPolygon`\n from the radius of the circumcircle and a number of sides\n # Panics\n Panics if `circumradius` is negative", + &["circumradius", "sides"], + ) + .register_documented( + "side_length", + |_self: Ref<::bevy_math::primitives::RegularPolygon>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::RegularPolygon::side_length( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the length of one side of the regular polygon", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::RegularPolygon, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_rhombus_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Rhombus, + >::new(world) + .register_documented( + "circumradius", + |_self: Ref<::bevy_math::primitives::Rhombus>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::Rhombus::circumradius( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the radius of the circumcircle on which all vertices\n of the rhombus lie", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Rhombus>| { + let output: Val<::bevy_math::primitives::Rhombus> = { + { + let output: Val<::bevy_math::primitives::Rhombus> = <::bevy_math::primitives::Rhombus as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "closest_point", + | + _self: Ref<::bevy_math::primitives::Rhombus>, + point: Val<::bevy_math::Vec2>| + { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Rhombus::closest_point( + &_self, + point.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Finds the point on the rhombus that is closest to the given `point`.\n If the point is outside the rhombus, the returned point will be on the perimeter of the rhombus.\n Otherwise, it will be inside the rhombus and returned as is.", + &["_self", "point"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::primitives::Rhombus>, + other: Ref<::bevy_math::primitives::Rhombus>| + { + let output: bool = { + { + let output: bool = <::bevy_math::primitives::Rhombus as ::core::cmp::PartialEq< + ::bevy_math::primitives::Rhombus, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "from_inradius", + |inradius: f32| { + let output: Val<::bevy_math::primitives::Rhombus> = { + { + let output: Val<::bevy_math::primitives::Rhombus> = ::bevy_math::primitives::Rhombus::from_inradius( + inradius, + ) + .into(); + output + } + }; + output + }, + " Create a new `Rhombus` from a given inradius with all inner angles equal.", + &["inradius"], + ) + .register_documented( + "from_side", + |side: f32| { + let output: Val<::bevy_math::primitives::Rhombus> = { + { + let output: Val<::bevy_math::primitives::Rhombus> = ::bevy_math::primitives::Rhombus::from_side( + side, + ) + .into(); + output + } + }; + output + }, + " Create a new `Rhombus` from a side length with all inner angles equal.", + &["side"], + ) + .register_documented( + "inradius", + |_self: Ref<::bevy_math::primitives::Rhombus>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::Rhombus::inradius( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the radius of the largest circle that can\n be drawn within the rhombus", + &["_self"], + ) + .register_documented( + "new", + |horizontal_diagonal: f32, vertical_diagonal: f32| { + let output: Val<::bevy_math::primitives::Rhombus> = { + { + let output: Val<::bevy_math::primitives::Rhombus> = ::bevy_math::primitives::Rhombus::new( + horizontal_diagonal, + vertical_diagonal, + ) + .into(); + output + } + }; + output + }, + " Create a new `Rhombus` from a vertical and horizontal diagonal sizes.", + &["horizontal_diagonal", "vertical_diagonal"], + ) + .register_documented( + "side", + |_self: Ref<::bevy_math::primitives::Rhombus>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::Rhombus::side(&_self) + .into(); + output + } + }; + output + }, + " Get the length of each side of the rhombus", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::Rhombus, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_segment_2_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Segment2d, + >::new(world) + .register_documented( + "center", + |_self: Ref<::bevy_math::primitives::Segment2d>| { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Segment2d::center( + &_self, + ) + .into(); + output + } + }; + output + }, + " Compute the midpoint between the two endpoints of the line segment.", + &["_self"], + ) + .register_documented( + "centered", + |_self: Ref<::bevy_math::primitives::Segment2d>| { + let output: Val<::bevy_math::primitives::Segment2d> = { + { + let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::centered( + &_self, + ) + .into(); + output + } + }; + output + }, + " Compute the segment with its center at the origin, keeping the same direction and length.", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Segment2d>| { + let output: Val<::bevy_math::primitives::Segment2d> = { + { + let output: Val<::bevy_math::primitives::Segment2d> = <::bevy_math::primitives::Segment2d as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "closest_point", + | + _self: Ref<::bevy_math::primitives::Segment2d>, + point: Val<::bevy_math::Vec2>| + { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Segment2d::closest_point( + &_self, + point.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the point on the [`Segment2d`] that is closest to the specified `point`.", + &["_self", "point"], + ) + .register_documented( + "direction", + |_self: Ref<::bevy_math::primitives::Segment2d>| { + let output: Val<::bevy_math::Dir2> = { + { + let output: Val<::bevy_math::Dir2> = ::bevy_math::primitives::Segment2d::direction( + &_self, + ) + .into(); + output + } + }; + output + }, + " Compute the normalized direction pointing from the first endpoint to the second endpoint.\n For the non-panicking version, see [`Segment2d::try_direction`].\n # Panics\n Panics if a valid direction could not be computed, for example when the endpoints are coincident, NaN, or infinite.", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::primitives::Segment2d>, + other: Ref<::bevy_math::primitives::Segment2d>| + { + let output: bool = { + { + let output: bool = <::bevy_math::primitives::Segment2d as ::core::cmp::PartialEq< + ::bevy_math::primitives::Segment2d, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "from_direction_and_length", + |direction: Val<::bevy_math::Dir2>, length: f32| { + let output: Val<::bevy_math::primitives::Segment2d> = { + { + let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::from_direction_and_length( + direction.into_inner(), + length, + ) + .into(); + output + } + }; + output + }, + " Create a new `Segment2d` centered at the origin with the given direction and length.\n The endpoints will be at `-direction * length / 2.0` and `direction * length / 2.0`.", + &["direction", "length"], + ) + .register_documented( + "from_ray_and_length", + |ray: Val<::bevy_math::Ray2d>, length: f32| { + let output: Val<::bevy_math::primitives::Segment2d> = { + { + let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::from_ray_and_length( + ray.into_inner(), + length, + ) + .into(); + output + } + }; + output + }, + " Create a new `Segment2d` starting from the origin of the given `ray`,\n going in the direction of the ray for the given `length`.\n The endpoints will be at `ray.origin` and `ray.origin + length * ray.direction`.", + &["ray", "length"], + ) + .register_documented( + "from_scaled_direction", + |scaled_direction: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_math::primitives::Segment2d> = { + { + let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::from_scaled_direction( + scaled_direction.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new `Segment2d` centered at the origin from a vector representing\n the direction and length of the line segment.\n The endpoints will be at `-scaled_direction / 2.0` and `scaled_direction / 2.0`.", + &["scaled_direction"], + ) + .register_documented( + "left_normal", + |_self: Ref<::bevy_math::primitives::Segment2d>| { + let output: Val<::bevy_math::Dir2> = { + { + let output: Val<::bevy_math::Dir2> = ::bevy_math::primitives::Segment2d::left_normal( + &_self, + ) + .into(); + output + } + }; + output + }, + " Compute the normalized counterclockwise normal on the left-hand side of the line segment.\n For the non-panicking version, see [`Segment2d::try_left_normal`].\n # Panics\n Panics if a valid normal could not be computed, for example when the endpoints are coincident, NaN, or infinite.", + &["_self"], + ) + .register_documented( + "length", + |_self: Ref<::bevy_math::primitives::Segment2d>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::Segment2d::length( + &_self, + ) + .into(); + output + } + }; + output + }, + " Compute the length of the line segment.", + &["_self"], + ) + .register_documented( + "length_squared", + |_self: Ref<::bevy_math::primitives::Segment2d>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::Segment2d::length_squared( + &_self, + ) + .into(); + output + } + }; + output + }, + " Compute the squared length of the line segment.", + &["_self"], + ) + .register_documented( + "new", + |point1: Val<::bevy_math::Vec2>, point2: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_math::primitives::Segment2d> = { + { + let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::new( + point1.into_inner(), + point2.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new `Segment2d` from its endpoints.", + &["point1", "point2"], + ) + .register_documented( + "point1", + |_self: Ref<::bevy_math::primitives::Segment2d>| { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Segment2d::point1( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the position of the first endpoint of the line segment.", + &["_self"], + ) + .register_documented( + "point2", + |_self: Ref<::bevy_math::primitives::Segment2d>| { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Segment2d::point2( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the position of the second endpoint of the line segment.", + &["_self"], + ) + .register_documented( + "resized", + |_self: Ref<::bevy_math::primitives::Segment2d>, length: f32| { + let output: Val<::bevy_math::primitives::Segment2d> = { + { + let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::resized( + &_self, + length, + ) + .into(); + output + } + }; + output + }, + " Compute the segment with a new length, keeping the same direction and center.", + &["_self", "length"], + ) + .register_documented( + "reverse", + |mut _self: Mut<::bevy_math::primitives::Segment2d>| { + let output: () = { + { + let output: () = ::bevy_math::primitives::Segment2d::reverse( + &mut _self, + ) + .into(); + output + } + }; + output + }, + " Reverses the direction of the line segment by swapping the endpoints.", + &["_self"], + ) + .register_documented( + "reversed", + |_self: Val<::bevy_math::primitives::Segment2d>| { + let output: Val<::bevy_math::primitives::Segment2d> = { + { + let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::reversed( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the line segment with its direction reversed by swapping the endpoints.", + &["_self"], + ) + .register_documented( + "right_normal", + |_self: Ref<::bevy_math::primitives::Segment2d>| { + let output: Val<::bevy_math::Dir2> = { + { + let output: Val<::bevy_math::Dir2> = ::bevy_math::primitives::Segment2d::right_normal( + &_self, + ) + .into(); + output + } + }; + output + }, + " Compute the normalized clockwise normal on the right-hand side of the line segment.\n For the non-panicking version, see [`Segment2d::try_right_normal`].\n # Panics\n Panics if a valid normal could not be computed, for example when the endpoints are coincident, NaN, or infinite.", + &["_self"], + ) + .register_documented( + "rotated", + | + _self: Ref<::bevy_math::primitives::Segment2d>, + rotation: Val<::bevy_math::Rot2>| + { + let output: Val<::bevy_math::primitives::Segment2d> = { + { + let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::rotated( + &_self, + rotation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Compute the segment rotated around the origin by the given rotation.", + &["_self", "rotation"], + ) + .register_documented( + "rotated_around", + | + _self: Ref<::bevy_math::primitives::Segment2d>, + rotation: Val<::bevy_math::Rot2>, + point: Val<::bevy_math::Vec2>| + { + let output: Val<::bevy_math::primitives::Segment2d> = { + { + let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::rotated_around( + &_self, + rotation.into_inner(), + point.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Compute the segment rotated around the given point by the given rotation.", + &["_self", "rotation", "point"], + ) + .register_documented( + "rotated_around_center", + | + _self: Ref<::bevy_math::primitives::Segment2d>, + rotation: Val<::bevy_math::Rot2>| + { + let output: Val<::bevy_math::primitives::Segment2d> = { + { + let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::rotated_around_center( + &_self, + rotation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Compute the segment rotated around its own center.", + &["_self", "rotation"], + ) + .register_documented( + "scaled_direction", + |_self: Ref<::bevy_math::primitives::Segment2d>| { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Segment2d::scaled_direction( + &_self, + ) + .into(); + output + } + }; + output + }, + " Compute the vector from the first endpoint to the second endpoint.", + &["_self"], + ) + .register_documented( + "scaled_left_normal", + |_self: Ref<::bevy_math::primitives::Segment2d>| { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Segment2d::scaled_left_normal( + &_self, + ) + .into(); + output + } + }; + output + }, + " Compute the non-normalized counterclockwise normal on the left-hand side of the line segment.\n The length of the normal is the distance between the endpoints.", + &["_self"], + ) + .register_documented( + "scaled_right_normal", + |_self: Ref<::bevy_math::primitives::Segment2d>| { + let output: Val<::bevy_math::Vec2> = { + { + let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Segment2d::scaled_right_normal( + &_self, + ) + .into(); + output + } + }; + output + }, + " Compute the non-normalized clockwise normal on the right-hand side of the line segment.\n The length of the normal is the distance between the endpoints.", + &["_self"], + ) + .register_documented( + "translated", + | + _self: Ref<::bevy_math::primitives::Segment2d>, + translation: Val<::bevy_math::Vec2>| + { + let output: Val<::bevy_math::primitives::Segment2d> = { + { + let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::translated( + &_self, + translation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Compute the segment translated by the given vector.", + &["_self", "translation"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::Segment2d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_triangle_2_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Triangle2d, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Triangle2d>| { + let output: Val<::bevy_math::primitives::Triangle2d> = { + { + let output: Val<::bevy_math::primitives::Triangle2d> = <::bevy_math::primitives::Triangle2d as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::primitives::Triangle2d>, + other: Ref<::bevy_math::primitives::Triangle2d>| + { + let output: bool = { + { + let output: bool = <::bevy_math::primitives::Triangle2d as ::core::cmp::PartialEq< + ::bevy_math::primitives::Triangle2d, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "is_acute", + |_self: Ref<::bevy_math::primitives::Triangle2d>| { + let output: bool = { + { + let output: bool = ::bevy_math::primitives::Triangle2d::is_acute( + &_self, + ) + .into(); + output + } + }; + output + }, + " Checks if the triangle is acute, meaning all angles are less than 90 degrees", + &["_self"], + ) + .register_documented( + "is_degenerate", + |_self: Ref<::bevy_math::primitives::Triangle2d>| { + let output: bool = { + { + let output: bool = ::bevy_math::primitives::Triangle2d::is_degenerate( + &_self, + ) + .into(); + output + } + }; + output + }, + " Checks if the triangle is degenerate, meaning it has zero area.\n A triangle is degenerate if the cross product of the vectors `ab` and `ac` has a length less than `10e-7`.\n This indicates that the three vertices are collinear or nearly collinear.", + &["_self"], + ) + .register_documented( + "is_obtuse", + |_self: Ref<::bevy_math::primitives::Triangle2d>| { + let output: bool = { + { + let output: bool = ::bevy_math::primitives::Triangle2d::is_obtuse( + &_self, + ) + .into(); + output + } + }; + output + }, + " Checks if the triangle is obtuse, meaning one angle is greater than 90 degrees", + &["_self"], + ) + .register_documented( + "new", + | + a: Val<::bevy_math::Vec2>, + b: Val<::bevy_math::Vec2>, + c: Val<::bevy_math::Vec2>| + { + let output: Val<::bevy_math::primitives::Triangle2d> = { + { + let output: Val<::bevy_math::primitives::Triangle2d> = ::bevy_math::primitives::Triangle2d::new( + a.into_inner(), + b.into_inner(), + c.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new `Triangle2d` from points `a`, `b`, and `c`", + &["a", "b", "c"], + ) + .register_documented( + "reverse", + |mut _self: Mut<::bevy_math::primitives::Triangle2d>| { + let output: () = { + { + let output: () = ::bevy_math::primitives::Triangle2d::reverse( + &mut _self, + ) + .into(); + output + } + }; + output + }, + " Reverse the [`WindingOrder`] of the triangle\n by swapping the first and last vertices.", + &["_self"], + ) + .register_documented( + "reversed", + |_self: Val<::bevy_math::primitives::Triangle2d>| { + let output: Val<::bevy_math::primitives::Triangle2d> = { + { + let output: Val<::bevy_math::primitives::Triangle2d> = ::bevy_math::primitives::Triangle2d::reversed( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " This triangle but reversed.", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::Triangle2d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_convex_polygon_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::ConvexPolygon, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::ConvexPolygon>| { + let output: Val<::bevy_math::primitives::ConvexPolygon> = { + { + let output: Val<::bevy_math::primitives::ConvexPolygon> = <::bevy_math::primitives::ConvexPolygon as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::primitives::ConvexPolygon>, + other: Ref<::bevy_math::primitives::ConvexPolygon>| + { + let output: bool = { + { + let output: bool = <::bevy_math::primitives::ConvexPolygon as ::core::cmp::PartialEq< + ::bevy_math::primitives::ConvexPolygon, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::ConvexPolygon, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_polygon_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Polygon, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Polygon>| { + let output: Val<::bevy_math::primitives::Polygon> = { + { + let output: Val<::bevy_math::primitives::Polygon> = <::bevy_math::primitives::Polygon as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::primitives::Polygon>, + other: Ref<::bevy_math::primitives::Polygon>| + { + let output: bool = { + { + let output: bool = <::bevy_math::primitives::Polygon as ::core::cmp::PartialEq< + ::bevy_math::primitives::Polygon, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "is_simple", + |_self: Ref<::bevy_math::primitives::Polygon>| { + let output: bool = { + { + let output: bool = ::bevy_math::primitives::Polygon::is_simple( + &_self, + ) + .into(); + output + } + }; + output + }, + " Tests if the polygon is simple.\n A polygon is simple if it is not self intersecting and not self tangent.\n As such, no two edges of the polygon may cross each other and each vertex must not lie on another edge.", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::Polygon, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_polyline_2_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Polyline2d, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Polyline2d>| { + let output: Val<::bevy_math::primitives::Polyline2d> = { + { + let output: Val<::bevy_math::primitives::Polyline2d> = <::bevy_math::primitives::Polyline2d as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::primitives::Polyline2d>, + other: Ref<::bevy_math::primitives::Polyline2d>| + { + let output: bool = { + { + let output: bool = <::bevy_math::primitives::Polyline2d as ::core::cmp::PartialEq< + ::bevy_math::primitives::Polyline2d, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "with_subdivisions", + | + start: Val<::bevy_math::Vec2>, + end: Val<::bevy_math::Vec2>, + subdivisions: usize| + { + let output: Val<::bevy_math::primitives::Polyline2d> = { + { + let output: Val<::bevy_math::primitives::Polyline2d> = ::bevy_math::primitives::Polyline2d::with_subdivisions( + start.into_inner(), + end.into_inner(), + subdivisions, + ) + .into(); + output + } + }; + output + }, + " Create a new `Polyline2d` from two endpoints with subdivision points.\n `subdivisions = 0` creates a simple line with just start and end points.\n `subdivisions = 1` adds one point in the middle, creating 2 segments, etc.", + &["start", "end", "subdivisions"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::Polyline2d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_aabb_3_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::bounding::Aabb3d, + >::new(world) + .register_documented( + "bounding_sphere", + |_self: Ref<::bevy_math::bounding::Aabb3d>| { + let output: Val<::bevy_math::bounding::BoundingSphere> = { + { + let output: Val<::bevy_math::bounding::BoundingSphere> = ::bevy_math::bounding::Aabb3d::bounding_sphere( + &_self, + ) + .into(); + output + } + }; + output + }, + " Computes the smallest [`BoundingSphere`] containing this [`Aabb3d`].", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_math::bounding::Aabb3d>| { + let output: Val<::bevy_math::bounding::Aabb3d> = { + { + let output: Val<::bevy_math::bounding::Aabb3d> = <::bevy_math::bounding::Aabb3d as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::bounding::Aabb3d>, + other: Ref<::bevy_math::bounding::Aabb3d>| + { + let output: bool = { + { + let output: bool = <::bevy_math::bounding::Aabb3d as ::core::cmp::PartialEq< + ::bevy_math::bounding::Aabb3d, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::bounding::Aabb3d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_bounding_sphere_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::bounding::BoundingSphere, + >::new(world) + .register_documented( + "aabb_3d", + |_self: Ref<::bevy_math::bounding::BoundingSphere>| { + let output: Val<::bevy_math::bounding::Aabb3d> = { + { + let output: Val<::bevy_math::bounding::Aabb3d> = ::bevy_math::bounding::BoundingSphere::aabb_3d( + &_self, + ) + .into(); + output + } + }; + output + }, + " Computes the smallest [`Aabb3d`] containing this [`BoundingSphere`].", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_math::bounding::BoundingSphere>| { + let output: Val<::bevy_math::bounding::BoundingSphere> = { + { + let output: Val<::bevy_math::bounding::BoundingSphere> = <::bevy_math::bounding::BoundingSphere as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::bounding::BoundingSphere>, + other: Ref<::bevy_math::bounding::BoundingSphere>| + { + let output: bool = { + { + let output: bool = <::bevy_math::bounding::BoundingSphere as ::core::cmp::PartialEq< + ::bevy_math::bounding::BoundingSphere, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "radius", + |_self: Ref<::bevy_math::bounding::BoundingSphere>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::bounding::BoundingSphere::radius( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the radius of the bounding sphere", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::bounding::BoundingSphere, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_sphere_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Sphere, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Sphere>| { + let output: Val<::bevy_math::primitives::Sphere> = { + { + let output: Val<::bevy_math::primitives::Sphere> = <::bevy_math::primitives::Sphere as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "closest_point", + |_self: Ref<::bevy_math::primitives::Sphere>, point: Val<::bevy_math::Vec3>| { + let output: Val<::bevy_math::Vec3> = { + { + let output: Val<::bevy_math::Vec3> = ::bevy_math::primitives::Sphere::closest_point( + &_self, + point.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Finds the point on the sphere that is closest to the given `point`.\n If the point is outside the sphere, the returned point will be on the surface of the sphere.\n Otherwise, it will be inside the sphere and returned as is.", + &["_self", "point"], + ) + .register_documented( + "diameter", + |_self: Ref<::bevy_math::primitives::Sphere>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::Sphere::diameter( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the diameter of the sphere", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::primitives::Sphere>, + other: Ref<::bevy_math::primitives::Sphere>| + { + let output: bool = { + { + let output: bool = <::bevy_math::primitives::Sphere as ::core::cmp::PartialEq< + ::bevy_math::primitives::Sphere, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "new", + |radius: f32| { + let output: Val<::bevy_math::primitives::Sphere> = { + { + let output: Val<::bevy_math::primitives::Sphere> = ::bevy_math::primitives::Sphere::new( + radius, + ) + .into(); + output + } + }; + output + }, + " Create a new [`Sphere`] from a `radius`", + &["radius"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::Sphere, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_cuboid_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Cuboid, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Cuboid>| { + let output: Val<::bevy_math::primitives::Cuboid> = { + { + let output: Val<::bevy_math::primitives::Cuboid> = <::bevy_math::primitives::Cuboid as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "closest_point", + |_self: Ref<::bevy_math::primitives::Cuboid>, point: Val<::bevy_math::Vec3>| { + let output: Val<::bevy_math::Vec3> = { + { + let output: Val<::bevy_math::Vec3> = ::bevy_math::primitives::Cuboid::closest_point( + &_self, + point.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Finds the point on the cuboid that is closest to the given `point`.\n If the point is outside the cuboid, the returned point will be on the surface of the cuboid.\n Otherwise, it will be inside the cuboid and returned as is.", + &["_self", "point"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::primitives::Cuboid>, + other: Ref<::bevy_math::primitives::Cuboid>| + { + let output: bool = { + { + let output: bool = <::bevy_math::primitives::Cuboid as ::core::cmp::PartialEq< + ::bevy_math::primitives::Cuboid, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "from_corners", + |point1: Val<::bevy_math::Vec3>, point2: Val<::bevy_math::Vec3>| { + let output: Val<::bevy_math::primitives::Cuboid> = { + { + let output: Val<::bevy_math::primitives::Cuboid> = ::bevy_math::primitives::Cuboid::from_corners( + point1.into_inner(), + point2.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new `Cuboid` from two corner points", + &["point1", "point2"], + ) + .register_documented( + "from_length", + |length: f32| { + let output: Val<::bevy_math::primitives::Cuboid> = { + { + let output: Val<::bevy_math::primitives::Cuboid> = ::bevy_math::primitives::Cuboid::from_length( + length, + ) + .into(); + output + } + }; + output + }, + " Create a `Cuboid` from a single length.\n The resulting `Cuboid` will be the same size in every direction.", + &["length"], + ) + .register_documented( + "from_size", + |size: Val<::bevy_math::Vec3>| { + let output: Val<::bevy_math::primitives::Cuboid> = { + { + let output: Val<::bevy_math::primitives::Cuboid> = ::bevy_math::primitives::Cuboid::from_size( + size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new `Cuboid` from a given full size", + &["size"], + ) + .register_documented( + "new", + |x_length: f32, y_length: f32, z_length: f32| { + let output: Val<::bevy_math::primitives::Cuboid> = { + { + let output: Val<::bevy_math::primitives::Cuboid> = ::bevy_math::primitives::Cuboid::new( + x_length, + y_length, + z_length, + ) + .into(); + output + } + }; + output + }, + " Create a new `Cuboid` from a full x, y, and z length", + &["x_length", "y_length", "z_length"], + ) + .register_documented( + "size", + |_self: Ref<::bevy_math::primitives::Cuboid>| { + let output: Val<::bevy_math::Vec3> = { + { + let output: Val<::bevy_math::Vec3> = ::bevy_math::primitives::Cuboid::size( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the size of the cuboid", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::Cuboid, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_cylinder_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Cylinder, + >::new(world) + .register_documented( + "base", + |_self: Ref<::bevy_math::primitives::Cylinder>| { + let output: Val<::bevy_math::primitives::Circle> = { + { + let output: Val<::bevy_math::primitives::Circle> = ::bevy_math::primitives::Cylinder::base( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the base of the cylinder as a [`Circle`]", + &["_self"], + ) + .register_documented( + "base_area", + |_self: Ref<::bevy_math::primitives::Cylinder>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::Cylinder::base_area( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the surface area of one base of the cylinder", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Cylinder>| { + let output: Val<::bevy_math::primitives::Cylinder> = { + { + let output: Val<::bevy_math::primitives::Cylinder> = <::bevy_math::primitives::Cylinder as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::primitives::Cylinder>, + other: Ref<::bevy_math::primitives::Cylinder>| + { + let output: bool = { + { + let output: bool = <::bevy_math::primitives::Cylinder as ::core::cmp::PartialEq< + ::bevy_math::primitives::Cylinder, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "lateral_area", + |_self: Ref<::bevy_math::primitives::Cylinder>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::Cylinder::lateral_area( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the surface area of the side of the cylinder,\n also known as the lateral area", + &["_self"], + ) + .register_documented( + "new", + |radius: f32, height: f32| { + let output: Val<::bevy_math::primitives::Cylinder> = { + { + let output: Val<::bevy_math::primitives::Cylinder> = ::bevy_math::primitives::Cylinder::new( + radius, + height, + ) + .into(); + output + } + }; + output + }, + " Create a new `Cylinder` from a radius and full height", + &["radius", "height"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::Cylinder, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_capsule_3_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Capsule3d, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Capsule3d>| { + let output: Val<::bevy_math::primitives::Capsule3d> = { + { + let output: Val<::bevy_math::primitives::Capsule3d> = <::bevy_math::primitives::Capsule3d as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::primitives::Capsule3d>, + other: Ref<::bevy_math::primitives::Capsule3d>| + { + let output: bool = { + { + let output: bool = <::bevy_math::primitives::Capsule3d as ::core::cmp::PartialEq< + ::bevy_math::primitives::Capsule3d, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "new", + |radius: f32, length: f32| { + let output: Val<::bevy_math::primitives::Capsule3d> = { + { + let output: Val<::bevy_math::primitives::Capsule3d> = ::bevy_math::primitives::Capsule3d::new( + radius, + length, + ) + .into(); + output + } + }; + output + }, + " Create a new `Capsule3d` from a radius and length", + &["radius", "length"], + ) + .register_documented( + "to_cylinder", + |_self: Ref<::bevy_math::primitives::Capsule3d>| { + let output: Val<::bevy_math::primitives::Cylinder> = { + { + let output: Val<::bevy_math::primitives::Cylinder> = ::bevy_math::primitives::Capsule3d::to_cylinder( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the part connecting the hemispherical ends\n of the capsule as a [`Cylinder`]", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::Capsule3d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_cone_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Cone, + >::new(world) + .register_documented( + "base", + |_self: Ref<::bevy_math::primitives::Cone>| { + let output: Val<::bevy_math::primitives::Circle> = { + { + let output: Val<::bevy_math::primitives::Circle> = ::bevy_math::primitives::Cone::base( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the base of the cone as a [`Circle`]", + &["_self"], + ) + .register_documented( + "base_area", + |_self: Ref<::bevy_math::primitives::Cone>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::Cone::base_area( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the surface area of the base of the cone", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Cone>| { + let output: Val<::bevy_math::primitives::Cone> = { + { + let output: Val<::bevy_math::primitives::Cone> = <::bevy_math::primitives::Cone as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::primitives::Cone>, + other: Ref<::bevy_math::primitives::Cone>| + { + let output: bool = { + { + let output: bool = <::bevy_math::primitives::Cone as ::core::cmp::PartialEq< + ::bevy_math::primitives::Cone, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "lateral_area", + |_self: Ref<::bevy_math::primitives::Cone>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::Cone::lateral_area( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the surface area of the side of the cone,\n also known as the lateral area", + &["_self"], + ) + .register_documented( + "new", + |radius: f32, height: f32| { + let output: Val<::bevy_math::primitives::Cone> = { + { + let output: Val<::bevy_math::primitives::Cone> = ::bevy_math::primitives::Cone::new( + radius, + height, + ) + .into(); + output + } + }; + output + }, + " Create a new [`Cone`] from a radius and height.", + &["radius", "height"], + ) + .register_documented( + "slant_height", + |_self: Ref<::bevy_math::primitives::Cone>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::Cone::slant_height( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the slant height of the cone, the length of the line segment\n connecting a point on the base to the apex", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::Cone, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_conical_frustum_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::ConicalFrustum, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::ConicalFrustum>| { + let output: Val<::bevy_math::primitives::ConicalFrustum> = { + { + let output: Val<::bevy_math::primitives::ConicalFrustum> = <::bevy_math::primitives::ConicalFrustum as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::primitives::ConicalFrustum>, + other: Ref<::bevy_math::primitives::ConicalFrustum>| + { + let output: bool = { + { + let output: bool = <::bevy_math::primitives::ConicalFrustum as ::core::cmp::PartialEq< + ::bevy_math::primitives::ConicalFrustum, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::ConicalFrustum, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_infinite_plane_3_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::InfinitePlane3d, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::InfinitePlane3d>| { + let output: Val<::bevy_math::primitives::InfinitePlane3d> = { + { + let output: Val<::bevy_math::primitives::InfinitePlane3d> = <::bevy_math::primitives::InfinitePlane3d as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::primitives::InfinitePlane3d>, + other: Ref<::bevy_math::primitives::InfinitePlane3d>| + { + let output: bool = { + { + let output: bool = <::bevy_math::primitives::InfinitePlane3d as ::core::cmp::PartialEq< + ::bevy_math::primitives::InfinitePlane3d, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "isometry_from_xy", + | + _self: Ref<::bevy_math::primitives::InfinitePlane3d>, + origin: Val<::bevy_math::Vec3>| + { + let output: Val<::bevy_math::Isometry3d> = { + { + let output: Val<::bevy_math::Isometry3d> = ::bevy_math::primitives::InfinitePlane3d::isometry_from_xy( + &_self, + origin.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes an [`Isometry3d`] which transforms points from the XY-plane to this plane with the\n given `origin`.\n ## Guarantees\n * the transformation is a [congruence] meaning it will preserve all distances and angles of\n the transformed geometry\n * uses the least rotation possible to transform the geometry\n * if two geometries are transformed with the same isometry, then the relations between\n them, like distances, are also preserved\n * compared to projections, the transformation is lossless (up to floating point errors)\n reversible\n ## Non-Guarantees\n * the rotation used is generally not unique\n * the orientation of the transformed geometry in the XY plane might be arbitrary, to\n enforce some kind of alignment the user has to use an extra transformation ontop of this\n one\n See [`isometries_xy`] for example usescases.\n [congruence]: https://en.wikipedia.org/wiki/Congruence_(geometry)\n [`isometries_xy`]: `InfinitePlane3d::isometries_xy`", + &["_self", "origin"], + ) + .register_documented( + "isometry_into_xy", + | + _self: Ref<::bevy_math::primitives::InfinitePlane3d>, + origin: Val<::bevy_math::Vec3>| + { + let output: Val<::bevy_math::Isometry3d> = { + { + let output: Val<::bevy_math::Isometry3d> = ::bevy_math::primitives::InfinitePlane3d::isometry_into_xy( + &_self, + origin.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Computes an [`Isometry3d`] which transforms points from the plane in 3D space with the given\n `origin` to the XY-plane.\n ## Guarantees\n * the transformation is a [congruence] meaning it will preserve all distances and angles of\n the transformed geometry\n * uses the least rotation possible to transform the geometry\n * if two geometries are transformed with the same isometry, then the relations between\n them, like distances, are also preserved\n * compared to projections, the transformation is lossless (up to floating point errors)\n reversible\n ## Non-Guarantees\n * the rotation used is generally not unique\n * the orientation of the transformed geometry in the XY plane might be arbitrary, to\n enforce some kind of alignment the user has to use an extra transformation ontop of this\n one\n See [`isometries_xy`] for example usescases.\n [congruence]: https://en.wikipedia.org/wiki/Congruence_(geometry)\n [`isometries_xy`]: `InfinitePlane3d::isometries_xy`", + &["_self", "origin"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::InfinitePlane3d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_line_3_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Line3d, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Line3d>| { + let output: Val<::bevy_math::primitives::Line3d> = { + { + let output: Val<::bevy_math::primitives::Line3d> = <::bevy_math::primitives::Line3d as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::primitives::Line3d>, + other: Ref<::bevy_math::primitives::Line3d>| + { + let output: bool = { + { + let output: bool = <::bevy_math::primitives::Line3d as ::core::cmp::PartialEq< + ::bevy_math::primitives::Line3d, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::Line3d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_segment_3_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Segment3d, + >::new(world) + .register_documented( + "center", + |_self: Ref<::bevy_math::primitives::Segment3d>| { + let output: Val<::bevy_math::Vec3> = { + { + let output: Val<::bevy_math::Vec3> = ::bevy_math::primitives::Segment3d::center( + &_self, + ) + .into(); + output + } + }; + output + }, + " Compute the midpoint between the two endpoints of the line segment.", + &["_self"], + ) + .register_documented( + "centered", + |_self: Ref<::bevy_math::primitives::Segment3d>| { + let output: Val<::bevy_math::primitives::Segment3d> = { + { + let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::centered( + &_self, + ) + .into(); + output + } + }; + output + }, + " Compute the segment with its center at the origin, keeping the same direction and length.", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Segment3d>| { + let output: Val<::bevy_math::primitives::Segment3d> = { + { + let output: Val<::bevy_math::primitives::Segment3d> = <::bevy_math::primitives::Segment3d as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "closest_point", + | + _self: Ref<::bevy_math::primitives::Segment3d>, + point: Val<::bevy_math::Vec3>| + { + let output: Val<::bevy_math::Vec3> = { + { + let output: Val<::bevy_math::Vec3> = ::bevy_math::primitives::Segment3d::closest_point( + &_self, + point.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the point on the [`Segment3d`] that is closest to the specified `point`.", + &["_self", "point"], + ) + .register_documented( + "direction", + |_self: Ref<::bevy_math::primitives::Segment3d>| { + let output: Val<::bevy_math::Dir3> = { + { + let output: Val<::bevy_math::Dir3> = ::bevy_math::primitives::Segment3d::direction( + &_self, + ) + .into(); + output + } + }; + output + }, + " Compute the normalized direction pointing from the first endpoint to the second endpoint.\n For the non-panicking version, see [`Segment3d::try_direction`].\n # Panics\n Panics if a valid direction could not be computed, for example when the endpoints are coincident, NaN, or infinite.", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::primitives::Segment3d>, + other: Ref<::bevy_math::primitives::Segment3d>| + { + let output: bool = { + { + let output: bool = <::bevy_math::primitives::Segment3d as ::core::cmp::PartialEq< + ::bevy_math::primitives::Segment3d, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "from_direction_and_length", + |direction: Val<::bevy_math::Dir3>, length: f32| { + let output: Val<::bevy_math::primitives::Segment3d> = { + { + let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::from_direction_and_length( + direction.into_inner(), + length, + ) + .into(); + output + } + }; + output + }, + " Create a new `Segment3d` centered at the origin with the given direction and length.\n The endpoints will be at `-direction * length / 2.0` and `direction * length / 2.0`.", + &["direction", "length"], + ) + .register_documented( + "from_ray_and_length", + |ray: Val<::bevy_math::Ray3d>, length: f32| { + let output: Val<::bevy_math::primitives::Segment3d> = { + { + let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::from_ray_and_length( + ray.into_inner(), + length, + ) + .into(); + output + } + }; + output + }, + " Create a new `Segment3d` starting from the origin of the given `ray`,\n going in the direction of the ray for the given `length`.\n The endpoints will be at `ray.origin` and `ray.origin + length * ray.direction`.", + &["ray", "length"], + ) + .register_documented( + "from_scaled_direction", + |scaled_direction: Val<::bevy_math::Vec3>| { + let output: Val<::bevy_math::primitives::Segment3d> = { + { + let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::from_scaled_direction( + scaled_direction.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new `Segment3d` centered at the origin from a vector representing\n the direction and length of the line segment.\n The endpoints will be at `-scaled_direction / 2.0` and `scaled_direction / 2.0`.", + &["scaled_direction"], + ) + .register_documented( + "length", + |_self: Ref<::bevy_math::primitives::Segment3d>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::Segment3d::length( + &_self, + ) + .into(); + output + } + }; + output + }, + " Compute the length of the line segment.", + &["_self"], + ) + .register_documented( + "length_squared", + |_self: Ref<::bevy_math::primitives::Segment3d>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::Segment3d::length_squared( + &_self, + ) + .into(); + output + } + }; + output + }, + " Compute the squared length of the line segment.", + &["_self"], + ) + .register_documented( + "new", + |point1: Val<::bevy_math::Vec3>, point2: Val<::bevy_math::Vec3>| { + let output: Val<::bevy_math::primitives::Segment3d> = { + { + let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::new( + point1.into_inner(), + point2.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new `Segment3d` from its endpoints.", + &["point1", "point2"], + ) + .register_documented( + "point1", + |_self: Ref<::bevy_math::primitives::Segment3d>| { + let output: Val<::bevy_math::Vec3> = { + { + let output: Val<::bevy_math::Vec3> = ::bevy_math::primitives::Segment3d::point1( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the position of the first endpoint of the line segment.", + &["_self"], + ) + .register_documented( + "point2", + |_self: Ref<::bevy_math::primitives::Segment3d>| { + let output: Val<::bevy_math::Vec3> = { + { + let output: Val<::bevy_math::Vec3> = ::bevy_math::primitives::Segment3d::point2( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the position of the second endpoint of the line segment.", + &["_self"], + ) + .register_documented( + "resized", + |_self: Ref<::bevy_math::primitives::Segment3d>, length: f32| { + let output: Val<::bevy_math::primitives::Segment3d> = { + { + let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::resized( + &_self, + length, + ) + .into(); + output + } + }; + output + }, + " Compute the segment with a new length, keeping the same direction and center.", + &["_self", "length"], + ) + .register_documented( + "reverse", + |mut _self: Mut<::bevy_math::primitives::Segment3d>| { + let output: () = { + { + let output: () = ::bevy_math::primitives::Segment3d::reverse( + &mut _self, + ) + .into(); + output + } + }; + output + }, + " Reverses the direction of the line segment by swapping the endpoints.", + &["_self"], + ) + .register_documented( + "reversed", + |_self: Val<::bevy_math::primitives::Segment3d>| { + let output: Val<::bevy_math::primitives::Segment3d> = { + { + let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::reversed( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns the line segment with its direction reversed by swapping the endpoints.", + &["_self"], + ) + .register_documented( + "rotated", + | + _self: Ref<::bevy_math::primitives::Segment3d>, + rotation: Val<::bevy_math::Quat>| + { + let output: Val<::bevy_math::primitives::Segment3d> = { + { + let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::rotated( + &_self, + rotation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Compute the segment rotated around the origin by the given rotation.", + &["_self", "rotation"], + ) + .register_documented( + "rotated_around", + | + _self: Ref<::bevy_math::primitives::Segment3d>, + rotation: Val<::bevy_math::Quat>, + point: Val<::bevy_math::Vec3>| + { + let output: Val<::bevy_math::primitives::Segment3d> = { + { + let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::rotated_around( + &_self, + rotation.into_inner(), + point.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Compute the segment rotated around the given point by the given rotation.", + &["_self", "rotation", "point"], + ) + .register_documented( + "rotated_around_center", + | + _self: Ref<::bevy_math::primitives::Segment3d>, + rotation: Val<::bevy_math::Quat>| + { + let output: Val<::bevy_math::primitives::Segment3d> = { + { + let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::rotated_around_center( + &_self, + rotation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Compute the segment rotated around its own center.", + &["_self", "rotation"], + ) + .register_documented( + "scaled_direction", + |_self: Ref<::bevy_math::primitives::Segment3d>| { + let output: Val<::bevy_math::Vec3> = { + { + let output: Val<::bevy_math::Vec3> = ::bevy_math::primitives::Segment3d::scaled_direction( + &_self, + ) + .into(); + output + } + }; + output + }, + " Compute the vector from the first endpoint to the second endpoint.", + &["_self"], + ) + .register_documented( + "translated", + | + _self: Ref<::bevy_math::primitives::Segment3d>, + translation: Val<::bevy_math::Vec3>| + { + let output: Val<::bevy_math::primitives::Segment3d> = { + { + let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::translated( + &_self, + translation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Compute the segment translated by the given vector.", + &["_self", "translation"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::Segment3d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_torus_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Torus, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Torus>| { + let output: Val<::bevy_math::primitives::Torus> = { + { + let output: Val<::bevy_math::primitives::Torus> = <::bevy_math::primitives::Torus as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::primitives::Torus>, + other: Ref<::bevy_math::primitives::Torus>| + { + let output: bool = { + { + let output: bool = <::bevy_math::primitives::Torus as ::core::cmp::PartialEq< + ::bevy_math::primitives::Torus, >>::eq(&_self, &other) .into(); output @@ -4958,12 +7537,12 @@ pub(crate) fn register_cuboid_functions(world: &mut World) { &["_self", "other"], ) .register_documented( - "from_length", - |length: f32| { - let output: Val<::bevy_math::primitives::Cuboid> = { + "inner_radius", + |_self: Ref<::bevy_math::primitives::Torus>| { + let output: f32 = { { - let output: Val<::bevy_math::primitives::Cuboid> = ::bevy_math::primitives::Cuboid::from_length( - length, + let output: f32 = ::bevy_math::primitives::Torus::inner_radius( + &_self, ) .into(); output @@ -4971,18 +7550,17 @@ pub(crate) fn register_cuboid_functions(world: &mut World) { }; output }, - " Create a `Cuboid` from a single length.\n The resulting `Cuboid` will be the same size in every direction.", - &["length"], + " Get the inner radius of the torus.\n For a ring torus, this corresponds to the radius of the hole,\n or `major_radius - minor_radius`", + &["_self"], ) .register_documented( "new", - |x_length: f32, y_length: f32, z_length: f32| { - let output: Val<::bevy_math::primitives::Cuboid> = { + |inner_radius: f32, outer_radius: f32| { + let output: Val<::bevy_math::primitives::Torus> = { { - let output: Val<::bevy_math::primitives::Cuboid> = ::bevy_math::primitives::Cuboid::new( - x_length, - y_length, - z_length, + let output: Val<::bevy_math::primitives::Torus> = ::bevy_math::primitives::Torus::new( + inner_radius, + outer_radius, ) .into(); output @@ -4990,210 +7568,44 @@ pub(crate) fn register_cuboid_functions(world: &mut World) { }; output }, - " Create a new `Cuboid` from a full x, y, and z length", - &["x_length", "y_length", "z_length"], + " Create a new `Torus` from an inner and outer radius.\n The inner radius is the radius of the hole, and the outer radius\n is the radius of the entire object", + &["inner_radius", "outer_radius"], + ) + .register_documented( + "outer_radius", + |_self: Ref<::bevy_math::primitives::Torus>| { + let output: f32 = { + { + let output: f32 = ::bevy_math::primitives::Torus::outer_radius( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the outer radius of the torus.\n This corresponds to the overall radius of the entire object,\n or `major_radius + minor_radius`", + &["_self"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::primitives::Cuboid, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_cylinder_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Cylinder, - >::new(world) - .register_documented( - "base", - |_self: Ref<::bevy_math::primitives::Cylinder>| { - let output: Val<::bevy_math::primitives::Circle> = { - { - let output: Val<::bevy_math::primitives::Circle> = - ::bevy_math::primitives::Cylinder::base(&_self).into(); - output - } - }; - output - }, - " Get the base of the cylinder as a [`Circle`]", - &["_self"], - ) - .register_documented( - "base_area", - |_self: Ref<::bevy_math::primitives::Cylinder>| { - let output: f32 = { - { - let output: f32 = ::bevy_math::primitives::Cylinder::base_area(&_self).into(); - output - } - }; - output - }, - " Get the surface area of one base of the cylinder", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Cylinder>| { - let output: Val<::bevy_math::primitives::Cylinder> = { - { - let output: Val<::bevy_math::primitives::Cylinder> = - <::bevy_math::primitives::Cylinder as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::primitives::Cylinder>, - other: Ref<::bevy_math::primitives::Cylinder>| { - let output: bool = { - { - let output: bool = - <::bevy_math::primitives::Cylinder as ::core::cmp::PartialEq< - ::bevy_math::primitives::Cylinder, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "lateral_area", - |_self: Ref<::bevy_math::primitives::Cylinder>| { - let output: f32 = { - { - let output: f32 = - ::bevy_math::primitives::Cylinder::lateral_area(&_self).into(); - output - } - }; - output - }, - " Get the surface area of the side of the cylinder,\n also known as the lateral area", - &["_self"], - ) - .register_documented( - "new", - |radius: f32, height: f32| { - let output: Val<::bevy_math::primitives::Cylinder> = { - { - let output: Val<::bevy_math::primitives::Cylinder> = - ::bevy_math::primitives::Cylinder::new(radius, height).into(); - output - } - }; - output - }, - " Create a new `Cylinder` from a radius and full height", - &["radius", "height"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::primitives::Cylinder, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_capsule_3_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Capsule3d, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Capsule3d>| { - let output: Val<::bevy_math::primitives::Capsule3d> = { - { - let output: Val<::bevy_math::primitives::Capsule3d> = - <::bevy_math::primitives::Capsule3d as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::primitives::Capsule3d>, - other: Ref<::bevy_math::primitives::Capsule3d>| { - let output: bool = { - { - let output: bool = - <::bevy_math::primitives::Capsule3d as ::core::cmp::PartialEq< - ::bevy_math::primitives::Capsule3d, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "new", - |radius: f32, length: f32| { - let output: Val<::bevy_math::primitives::Capsule3d> = { - { - let output: Val<::bevy_math::primitives::Capsule3d> = - ::bevy_math::primitives::Capsule3d::new(radius, length).into(); - output - } - }; - output - }, - " Create a new `Capsule3d` from a radius and length", - &["radius", "length"], - ) - .register_documented( - "to_cylinder", - |_self: Ref<::bevy_math::primitives::Capsule3d>| { - let output: Val<::bevy_math::primitives::Cylinder> = { - { - let output: Val<::bevy_math::primitives::Cylinder> = - ::bevy_math::primitives::Capsule3d::to_cylinder(&_self).into(); - output - } - }; - output - }, - " Get the part connecting the hemispherical ends\n of the capsule as a [`Cylinder`]", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::primitives::Capsule3d, + ::bevy_math::primitives::Torus, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_cone_functions(world: &mut World) { +pub(crate) fn register_triangle_3_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Cone, + ::bevy_math::primitives::Triangle3d, >::new(world) .register_documented( - "base", - |_self: Ref<::bevy_math::primitives::Cone>| { - let output: Val<::bevy_math::primitives::Circle> = { + "centroid", + |_self: Ref<::bevy_math::primitives::Triangle3d>| { + let output: Val<::bevy_math::Vec3> = { { - let output: Val<::bevy_math::primitives::Circle> = ::bevy_math::primitives::Cone::base( + let output: Val<::bevy_math::Vec3> = ::bevy_math::primitives::Triangle3d::centroid( &_self, ) .into(); @@ -5202,15 +7614,15 @@ pub(crate) fn register_cone_functions(world: &mut World) { }; output }, - " Get the base of the cone as a [`Circle`]", + " Get the centroid of the triangle.\n This function finds the geometric center of the triangle by averaging the vertices:\n `centroid = (a + b + c) / 3`.", &["_self"], ) .register_documented( - "base_area", - |_self: Ref<::bevy_math::primitives::Cone>| { - let output: f32 = { + "circumcenter", + |_self: Ref<::bevy_math::primitives::Triangle3d>| { + let output: Val<::bevy_math::Vec3> = { { - let output: f32 = ::bevy_math::primitives::Cone::base_area( + let output: Val<::bevy_math::Vec3> = ::bevy_math::primitives::Triangle3d::circumcenter( &_self, ) .into(); @@ -5219,15 +7631,15 @@ pub(crate) fn register_cone_functions(world: &mut World) { }; output }, - " Get the surface area of the base of the cone", + " Get the circumcenter of the triangle.", &["_self"], ) .register_documented( "clone", - |_self: Ref<::bevy_math::primitives::Cone>| { - let output: Val<::bevy_math::primitives::Cone> = { + |_self: Ref<::bevy_math::primitives::Triangle3d>| { + let output: Val<::bevy_math::primitives::Triangle3d> = { { - let output: Val<::bevy_math::primitives::Cone> = <::bevy_math::primitives::Cone as ::core::clone::Clone>::clone( + let output: Val<::bevy_math::primitives::Triangle3d> = <::bevy_math::primitives::Triangle3d as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -5242,13 +7654,13 @@ pub(crate) fn register_cone_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_math::primitives::Cone>, - other: Ref<::bevy_math::primitives::Cone>| + _self: Ref<::bevy_math::primitives::Triangle3d>, + other: Ref<::bevy_math::primitives::Triangle3d>| { let output: bool = { { - let output: bool = <::bevy_math::primitives::Cone as ::core::cmp::PartialEq< - ::bevy_math::primitives::Cone, + let output: bool = <::bevy_math::primitives::Triangle3d as ::core::cmp::PartialEq< + ::bevy_math::primitives::Triangle3d, >>::eq(&_self, &other) .into(); output @@ -5260,11 +7672,11 @@ pub(crate) fn register_cone_functions(world: &mut World) { &["_self", "other"], ) .register_documented( - "lateral_area", - |_self: Ref<::bevy_math::primitives::Cone>| { - let output: f32 = { + "is_acute", + |_self: Ref<::bevy_math::primitives::Triangle3d>| { + let output: bool = { { - let output: f32 = ::bevy_math::primitives::Cone::lateral_area( + let output: bool = ::bevy_math::primitives::Triangle3d::is_acute( &_self, ) .into(); @@ -5273,17 +7685,16 @@ pub(crate) fn register_cone_functions(world: &mut World) { }; output }, - " Get the surface area of the side of the cone,\n also known as the lateral area", + " Checks if the triangle is acute, meaning all angles are less than 90 degrees", &["_self"], ) .register_documented( - "new", - |radius: f32, height: f32| { - let output: Val<::bevy_math::primitives::Cone> = { + "is_degenerate", + |_self: Ref<::bevy_math::primitives::Triangle3d>| { + let output: bool = { { - let output: Val<::bevy_math::primitives::Cone> = ::bevy_math::primitives::Cone::new( - radius, - height, + let output: bool = ::bevy_math::primitives::Triangle3d::is_degenerate( + &_self, ) .into(); output @@ -5291,15 +7702,15 @@ pub(crate) fn register_cone_functions(world: &mut World) { }; output }, - " Create a new [`Cone`] from a radius and height.", - &["radius", "height"], + " Checks if the triangle is degenerate, meaning it has zero area.\n A triangle is degenerate if the cross product of the vectors `ab` and `ac` has a length less than `10e-7`.\n This indicates that the three vertices are collinear or nearly collinear.", + &["_self"], ) .register_documented( - "slant_height", - |_self: Ref<::bevy_math::primitives::Cone>| { - let output: f32 = { + "is_obtuse", + |_self: Ref<::bevy_math::primitives::Triangle3d>| { + let output: bool = { { - let output: f32 = ::bevy_math::primitives::Cone::slant_height( + let output: bool = ::bevy_math::primitives::Triangle3d::is_obtuse( &_self, ) .into(); @@ -5308,173 +7719,22 @@ pub(crate) fn register_cone_functions(world: &mut World) { }; output }, - " Get the slant height of the cone, the length of the line segment\n connecting a point on the base to the apex", + " Checks if the triangle is obtuse, meaning one angle is greater than 90 degrees", &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::primitives::Cone, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_conical_frustum_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::ConicalFrustum, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::ConicalFrustum>| { - let output: Val<::bevy_math::primitives::ConicalFrustum> = { - { - let output: Val<::bevy_math::primitives::ConicalFrustum> = - <::bevy_math::primitives::ConicalFrustum as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::primitives::ConicalFrustum>, - other: Ref<::bevy_math::primitives::ConicalFrustum>| { - let output: bool = { - { - let output: bool = - <::bevy_math::primitives::ConicalFrustum as ::core::cmp::PartialEq< - ::bevy_math::primitives::ConicalFrustum, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::primitives::ConicalFrustum, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_infinite_plane_3_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::InfinitePlane3d, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::InfinitePlane3d>| { - let output: Val<::bevy_math::primitives::InfinitePlane3d> = { - { - let output: Val<::bevy_math::primitives::InfinitePlane3d> = - <::bevy_math::primitives::InfinitePlane3d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::primitives::InfinitePlane3d>, - other: Ref<::bevy_math::primitives::InfinitePlane3d>| { - let output: bool = { - { - let output: bool = - <::bevy_math::primitives::InfinitePlane3d as ::core::cmp::PartialEq< - ::bevy_math::primitives::InfinitePlane3d, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::primitives::InfinitePlane3d, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_line_3_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Line3d, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Line3d>| { - let output: Val<::bevy_math::primitives::Line3d> = { - { - let output: Val<::bevy_math::primitives::Line3d> = - <::bevy_math::primitives::Line3d as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::primitives::Line3d>, - other: Ref<::bevy_math::primitives::Line3d>| { - let output: bool = { - { - let output: bool = - <::bevy_math::primitives::Line3d as ::core::cmp::PartialEq< - ::bevy_math::primitives::Line3d, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::primitives::Line3d, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_segment_3_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Segment3d, - >::new(world) + ) .register_documented( - "centered", - |_self: Ref<::bevy_math::primitives::Segment3d>| { - let output: Val<::bevy_math::primitives::Segment3d> = { + "new", + | + a: Val<::bevy_math::Vec3>, + b: Val<::bevy_math::Vec3>, + c: Val<::bevy_math::Vec3>| + { + let output: Val<::bevy_math::primitives::Triangle3d> = { { - let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::centered( - &_self, + let output: Val<::bevy_math::primitives::Triangle3d> = ::bevy_math::primitives::Triangle3d::new( + a.into_inner(), + b.into_inner(), + c.into_inner(), ) .into(); output @@ -5482,16 +7742,16 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { }; output }, - " Compute the segment with its center at the origin, keeping the same direction and length.", - &["_self"], + " Create a new [`Triangle3d`] from points `a`, `b`, and `c`.", + &["a", "b", "c"], ) .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Segment3d>| { - let output: Val<::bevy_math::primitives::Segment3d> = { + "reverse", + |mut _self: Mut<::bevy_math::primitives::Triangle3d>| { + let output: () = { { - let output: Val<::bevy_math::primitives::Segment3d> = <::bevy_math::primitives::Segment3d as ::core::clone::Clone>::clone( - &_self, + let output: () = ::bevy_math::primitives::Triangle3d::reverse( + &mut _self, ) .into(); output @@ -5499,15 +7759,44 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { }; output }, - "", + " Reverse the triangle by swapping the first and last vertices.", &["_self"], ) .register_documented( - "direction", - |_self: Ref<::bevy_math::primitives::Segment3d>| { - let output: Val<::bevy_math::prelude::Dir3> = { + "reversed", + |_self: Val<::bevy_math::primitives::Triangle3d>| { + let output: Val<::bevy_math::primitives::Triangle3d> = { + { + let output: Val<::bevy_math::primitives::Triangle3d> = ::bevy_math::primitives::Triangle3d::reversed( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " This triangle but reversed.", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::Triangle3d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_polyline_3_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::primitives::Polyline3d, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Polyline3d>| { + let output: Val<::bevy_math::primitives::Polyline3d> = { { - let output: Val<::bevy_math::prelude::Dir3> = ::bevy_math::primitives::Segment3d::direction( + let output: Val<::bevy_math::primitives::Polyline3d> = <::bevy_math::primitives::Polyline3d as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -5516,19 +7805,19 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { }; output }, - " Compute the normalized direction pointing from the first endpoint to the second endpoint.\n For the non-panicking version, see [`Segment3d::try_direction`].\n # Panics\n Panics if a valid direction could not be computed, for example when the endpoints are coincident, NaN, or infinite.", + "", &["_self"], ) .register_documented( "eq", | - _self: Ref<::bevy_math::primitives::Segment3d>, - other: Ref<::bevy_math::primitives::Segment3d>| + _self: Ref<::bevy_math::primitives::Polyline3d>, + other: Ref<::bevy_math::primitives::Polyline3d>| { let output: bool = { { - let output: bool = <::bevy_math::primitives::Segment3d as ::core::cmp::PartialEq< - ::bevy_math::primitives::Segment3d, + let output: bool = <::bevy_math::primitives::Polyline3d as ::core::cmp::PartialEq< + ::bevy_math::primitives::Polyline3d, >>::eq(&_self, &other) .into(); output @@ -5540,13 +7829,18 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { &["_self", "other"], ) .register_documented( - "from_direction_and_length", - |direction: Val<::bevy_math::prelude::Dir3>, length: f32| { - let output: Val<::bevy_math::primitives::Segment3d> = { + "with_subdivisions", + | + start: Val<::bevy_math::Vec3>, + end: Val<::bevy_math::Vec3>, + subdivisions: usize| + { + let output: Val<::bevy_math::primitives::Polyline3d> = { { - let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::from_direction_and_length( - direction.into_inner(), - length, + let output: Val<::bevy_math::primitives::Polyline3d> = ::bevy_math::primitives::Polyline3d::with_subdivisions( + start.into_inner(), + end.into_inner(), + subdivisions, ) .into(); output @@ -5554,17 +7848,32 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { }; output }, - " Create a new `Segment3d` centered at the origin with the given direction and length.\n The endpoints will be at `-direction * length / 2.0` and `direction * length / 2.0`.", - &["direction", "length"], - ) + " Create a new `Polyline3d` from two endpoints with subdivision points.\n `subdivisions = 0` creates a simple line with just start and end points.\n `subdivisions = 1` adds one point in the middle, creating 2 segments, etc.", + &["start", "end", "subdivisions"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::primitives::Polyline3d, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_ray_cast_2_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::bounding::RayCast2d, + >::new(world) .register_documented( - "from_ray_and_length", - |ray: Val<::bevy_math::Ray3d>, length: f32| { - let output: Val<::bevy_math::primitives::Segment3d> = { + "aabb_intersection_at", + | + _self: Ref<::bevy_math::bounding::RayCast2d>, + aabb: Ref<::bevy_math::bounding::Aabb2d>| + { + let output: ::core::option::Option = { { - let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::from_ray_and_length( - ray.into_inner(), - length, + let output: ::core::option::Option = ::bevy_math::bounding::RayCast2d::aabb_intersection_at( + &_self, + &aabb, ) .into(); output @@ -5572,16 +7881,20 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { }; output }, - " Create a new `Segment3d` starting from the origin of the given `ray`,\n going in the direction of the ray for the given `length`.\n The endpoints will be at `ray.origin` and `ray.origin + length * ray.direction`.", - &["ray", "length"], + " Get the distance of an intersection with an [`Aabb2d`], if any.", + &["_self", "aabb"], ) .register_documented( - "length", - |_self: Ref<::bevy_math::primitives::Segment3d>| { - let output: f32 = { + "circle_intersection_at", + | + _self: Ref<::bevy_math::bounding::RayCast2d>, + circle: Ref<::bevy_math::bounding::BoundingCircle>| + { + let output: ::core::option::Option = { { - let output: f32 = ::bevy_math::primitives::Segment3d::length( + let output: ::core::option::Option = ::bevy_math::bounding::RayCast2d::circle_intersection_at( &_self, + &circle, ) .into(); output @@ -5589,15 +7902,15 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { }; output }, - " Compute the length of the line segment.", - &["_self"], + " Get the distance of an intersection with a [`BoundingCircle`], if any.", + &["_self", "circle"], ) .register_documented( - "length_squared", - |_self: Ref<::bevy_math::primitives::Segment3d>| { - let output: f32 = { + "clone", + |_self: Ref<::bevy_math::bounding::RayCast2d>| { + let output: Val<::bevy_math::bounding::RayCast2d> = { { - let output: f32 = ::bevy_math::primitives::Segment3d::length_squared( + let output: Val<::bevy_math::bounding::RayCast2d> = <::bevy_math::bounding::RayCast2d as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -5606,17 +7919,16 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { }; output }, - " Compute the squared length of the line segment.", + "", &["_self"], ) .register_documented( - "resized", - |_self: Ref<::bevy_math::primitives::Segment3d>, length: f32| { - let output: Val<::bevy_math::primitives::Segment3d> = { + "direction_recip", + |_self: Ref<::bevy_math::bounding::RayCast2d>| { + let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::resized( + let output: Val<::bevy_math::Vec2> = ::bevy_math::bounding::RayCast2d::direction_recip( &_self, - length, ) .into(); output @@ -5624,16 +7936,17 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { }; output }, - " Compute the segment with a new length, keeping the same direction and center.", - &["_self", "length"], + " Get the cached multiplicative inverse of the direction of the ray.", + &["_self"], ) .register_documented( - "reverse", - |mut _self: Mut<::bevy_math::primitives::Segment3d>| { - let output: () = { + "from_ray", + |ray: Val<::bevy_math::Ray2d>, max: f32| { + let output: Val<::bevy_math::bounding::RayCast2d> = { { - let output: () = ::bevy_math::primitives::Segment3d::reverse( - &mut _self, + let output: Val<::bevy_math::bounding::RayCast2d> = ::bevy_math::bounding::RayCast2d::from_ray( + ray.into_inner(), + max, ) .into(); output @@ -5641,16 +7954,22 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { }; output }, - " Reverses the direction of the line segment by swapping the endpoints.", - &["_self"], + " Construct a [`RayCast2d`] from a [`Ray2d`] and max distance.", + &["ray", "max"], ) .register_documented( - "reversed", - |_self: Val<::bevy_math::primitives::Segment3d>| { - let output: Val<::bevy_math::primitives::Segment3d> = { + "new", + | + origin: Val<::bevy_math::Vec2>, + direction: Val<::bevy_math::Dir2>, + max: f32| + { + let output: Val<::bevy_math::bounding::RayCast2d> = { { - let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::reversed( - _self.into_inner(), + let output: Val<::bevy_math::bounding::RayCast2d> = ::bevy_math::bounding::RayCast2d::new( + origin.into_inner(), + direction.into_inner(), + max, ) .into(); output @@ -5658,64 +7977,48 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { }; output }, - " Returns the line segment with its direction reversed by swapping the endpoints.", - &["_self"], + " Construct a [`RayCast2d`] from an origin, [`Dir2`], and max distance.", + &["origin", "direction", "max"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::primitives::Segment3d, + ::bevy_math::bounding::RayCast2d, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_torus_functions(world: &mut World) { +pub(crate) fn register_aabb_cast_2_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Torus, + ::bevy_math::bounding::AabbCast2d, >::new(world) .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Torus>| { - let output: Val<::bevy_math::primitives::Torus> = { - { - let output: Val<::bevy_math::primitives::Torus> = <::bevy_math::primitives::Torus as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", + "aabb_collision_at", | - _self: Ref<::bevy_math::primitives::Torus>, - other: Ref<::bevy_math::primitives::Torus>| + _self: Ref<::bevy_math::bounding::AabbCast2d>, + aabb: Val<::bevy_math::bounding::Aabb2d>| { - let output: bool = { + let output: ::core::option::Option = { { - let output: bool = <::bevy_math::primitives::Torus as ::core::cmp::PartialEq< - ::bevy_math::primitives::Torus, - >>::eq(&_self, &other) + let output: ::core::option::Option = ::bevy_math::bounding::AabbCast2d::aabb_collision_at( + &_self, + aabb.into_inner(), + ) .into(); output } }; output }, - "", - &["_self", "other"], + " Get the distance at which the [`Aabb2d`]s collide, if at all.", + &["_self", "aabb"], ) .register_documented( - "inner_radius", - |_self: Ref<::bevy_math::primitives::Torus>| { - let output: f32 = { + "clone", + |_self: Ref<::bevy_math::bounding::AabbCast2d>| { + let output: Val<::bevy_math::bounding::AabbCast2d> = { { - let output: f32 = ::bevy_math::primitives::Torus::inner_radius( + let output: Val<::bevy_math::bounding::AabbCast2d> = <::bevy_math::bounding::AabbCast2d as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -5724,17 +8027,22 @@ pub(crate) fn register_torus_functions(world: &mut World) { }; output }, - " Get the inner radius of the torus.\n For a ring torus, this corresponds to the radius of the hole,\n or `major_radius - minor_radius`", + "", &["_self"], ) .register_documented( - "new", - |inner_radius: f32, outer_radius: f32| { - let output: Val<::bevy_math::primitives::Torus> = { + "from_ray", + | + aabb: Val<::bevy_math::bounding::Aabb2d>, + ray: Val<::bevy_math::Ray2d>, + max: f32| + { + let output: Val<::bevy_math::bounding::AabbCast2d> = { { - let output: Val<::bevy_math::primitives::Torus> = ::bevy_math::primitives::Torus::new( - inner_radius, - outer_radius, + let output: Val<::bevy_math::bounding::AabbCast2d> = ::bevy_math::bounding::AabbCast2d::from_ray( + aabb.into_inner(), + ray.into_inner(), + max, ) .into(); output @@ -5742,16 +8050,24 @@ pub(crate) fn register_torus_functions(world: &mut World) { }; output }, - " Create a new `Torus` from an inner and outer radius.\n The inner radius is the radius of the hole, and the outer radius\n is the radius of the entire object", - &["inner_radius", "outer_radius"], + " Construct an [`AabbCast2d`] from an [`Aabb2d`], [`Ray2d`], and max distance.", + &["aabb", "ray", "max"], ) .register_documented( - "outer_radius", - |_self: Ref<::bevy_math::primitives::Torus>| { - let output: f32 = { + "new", + | + aabb: Val<::bevy_math::bounding::Aabb2d>, + origin: Val<::bevy_math::Vec2>, + direction: Val<::bevy_math::Dir2>, + max: f32| + { + let output: Val<::bevy_math::bounding::AabbCast2d> = { { - let output: f32 = ::bevy_math::primitives::Torus::outer_radius( - &_self, + let output: Val<::bevy_math::bounding::AabbCast2d> = ::bevy_math::bounding::AabbCast2d::new( + aabb.into_inner(), + origin.into_inner(), + direction.into_inner(), + max, ) .into(); output @@ -5759,27 +8075,48 @@ pub(crate) fn register_torus_functions(world: &mut World) { }; output }, - " Get the outer radius of the torus.\n This corresponds to the overall radius of the entire object,\n or `major_radius + minor_radius`", - &["_self"], + " Construct an [`AabbCast2d`] from an [`Aabb2d`], origin, [`Dir2`], and max distance.", + &["aabb", "origin", "direction", "max"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::primitives::Torus, + ::bevy_math::bounding::AabbCast2d, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_triangle_3_d_functions(world: &mut World) { +pub(crate) fn register_bounding_circle_cast_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Triangle3d, + ::bevy_math::bounding::BoundingCircleCast, >::new(world) + .register_documented( + "circle_collision_at", + | + _self: Ref<::bevy_math::bounding::BoundingCircleCast>, + circle: Val<::bevy_math::bounding::BoundingCircle>| + { + let output: ::core::option::Option = { + { + let output: ::core::option::Option = ::bevy_math::bounding::BoundingCircleCast::circle_collision_at( + &_self, + circle.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Get the distance at which the [`BoundingCircle`]s collide, if at all.", + &["_self", "circle"], + ) .register_documented( "clone", - |_self: Ref<::bevy_math::primitives::Triangle3d>| { - let output: Val<::bevy_math::primitives::Triangle3d> = { + |_self: Ref<::bevy_math::bounding::BoundingCircleCast>| { + let output: Val<::bevy_math::bounding::BoundingCircleCast> = { { - let output: Val<::bevy_math::primitives::Triangle3d> = <::bevy_math::primitives::Triangle3d as ::core::clone::Clone>::clone( + let output: Val<::bevy_math::bounding::BoundingCircleCast> = <::bevy_math::bounding::BoundingCircleCast as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -5792,32 +8129,76 @@ pub(crate) fn register_triangle_3_d_functions(world: &mut World) { &["_self"], ) .register_documented( - "eq", + "from_ray", | - _self: Ref<::bevy_math::primitives::Triangle3d>, - other: Ref<::bevy_math::primitives::Triangle3d>| + circle: Val<::bevy_math::bounding::BoundingCircle>, + ray: Val<::bevy_math::Ray2d>, + max: f32| { - let output: bool = { + let output: Val<::bevy_math::bounding::BoundingCircleCast> = { { - let output: bool = <::bevy_math::primitives::Triangle3d as ::core::cmp::PartialEq< - ::bevy_math::primitives::Triangle3d, - >>::eq(&_self, &other) + let output: Val<::bevy_math::bounding::BoundingCircleCast> = ::bevy_math::bounding::BoundingCircleCast::from_ray( + circle.into_inner(), + ray.into_inner(), + max, + ) .into(); output } }; output }, - "", - &["_self", "other"], + " Construct a [`BoundingCircleCast`] from a [`BoundingCircle`], [`Ray2d`], and max distance.", + &["circle", "ray", "max"], ) .register_documented( - "is_acute", - |_self: Ref<::bevy_math::primitives::Triangle3d>| { - let output: bool = { + "new", + | + circle: Val<::bevy_math::bounding::BoundingCircle>, + origin: Val<::bevy_math::Vec2>, + direction: Val<::bevy_math::Dir2>, + max: f32| + { + let output: Val<::bevy_math::bounding::BoundingCircleCast> = { { - let output: bool = ::bevy_math::primitives::Triangle3d::is_acute( + let output: Val<::bevy_math::bounding::BoundingCircleCast> = ::bevy_math::bounding::BoundingCircleCast::new( + circle.into_inner(), + origin.into_inner(), + direction.into_inner(), + max, + ) + .into(); + output + } + }; + output + }, + " Construct a [`BoundingCircleCast`] from a [`BoundingCircle`], origin, [`Dir2`], and max distance.", + &["circle", "origin", "direction", "max"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_math::bounding::BoundingCircleCast, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_ray_cast_3_d_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_math::bounding::RayCast3d, + >::new(world) + .register_documented( + "aabb_intersection_at", + | + _self: Ref<::bevy_math::bounding::RayCast3d>, + aabb: Ref<::bevy_math::bounding::Aabb3d>| + { + let output: ::core::option::Option = { + { + let output: ::core::option::Option = ::bevy_math::bounding::RayCast3d::aabb_intersection_at( &_self, + &aabb, ) .into(); output @@ -5825,15 +8206,15 @@ pub(crate) fn register_triangle_3_d_functions(world: &mut World) { }; output }, - " Checks if the triangle is acute, meaning all angles are less than 90 degrees", - &["_self"], + " Get the distance of an intersection with an [`Aabb3d`], if any.", + &["_self", "aabb"], ) .register_documented( - "is_degenerate", - |_self: Ref<::bevy_math::primitives::Triangle3d>| { - let output: bool = { + "clone", + |_self: Ref<::bevy_math::bounding::RayCast3d>| { + let output: Val<::bevy_math::bounding::RayCast3d> = { { - let output: bool = ::bevy_math::primitives::Triangle3d::is_degenerate( + let output: Val<::bevy_math::bounding::RayCast3d> = <::bevy_math::bounding::RayCast3d as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -5842,15 +8223,15 @@ pub(crate) fn register_triangle_3_d_functions(world: &mut World) { }; output }, - " Checks if the triangle is degenerate, meaning it has zero area.\n A triangle is degenerate if the cross product of the vectors `ab` and `ac` has a length less than `10e-7`.\n This indicates that the three vertices are collinear or nearly collinear.", + "", &["_self"], ) .register_documented( - "is_obtuse", - |_self: Ref<::bevy_math::primitives::Triangle3d>| { - let output: bool = { + "direction_recip", + |_self: Ref<::bevy_math::bounding::RayCast3d>| { + let output: Val<::bevy_math::Vec3A> = { { - let output: bool = ::bevy_math::primitives::Triangle3d::is_obtuse( + let output: Val<::bevy_math::Vec3A> = ::bevy_math::bounding::RayCast3d::direction_recip( &_self, ) .into(); @@ -5859,16 +8240,17 @@ pub(crate) fn register_triangle_3_d_functions(world: &mut World) { }; output }, - " Checks if the triangle is obtuse, meaning one angle is greater than 90 degrees", + " Get the cached multiplicative inverse of the direction of the ray.", &["_self"], ) .register_documented( - "reverse", - |mut _self: Mut<::bevy_math::primitives::Triangle3d>| { - let output: () = { + "from_ray", + |ray: Val<::bevy_math::Ray3d>, max: f32| { + let output: Val<::bevy_math::bounding::RayCast3d> = { { - let output: () = ::bevy_math::primitives::Triangle3d::reverse( - &mut _self, + let output: Val<::bevy_math::bounding::RayCast3d> = ::bevy_math::bounding::RayCast3d::from_ray( + ray.into_inner(), + max, ) .into(); output @@ -5876,16 +8258,20 @@ pub(crate) fn register_triangle_3_d_functions(world: &mut World) { }; output }, - " Reverse the triangle by swapping the first and last vertices.", - &["_self"], + " Construct a [`RayCast3d`] from a [`Ray3d`] and max distance.", + &["ray", "max"], ) .register_documented( - "reversed", - |_self: Val<::bevy_math::primitives::Triangle3d>| { - let output: Val<::bevy_math::primitives::Triangle3d> = { + "sphere_intersection_at", + | + _self: Ref<::bevy_math::bounding::RayCast3d>, + sphere: Ref<::bevy_math::bounding::BoundingSphere>| + { + let output: ::core::option::Option = { { - let output: Val<::bevy_math::primitives::Triangle3d> = ::bevy_math::primitives::Triangle3d::reversed( - _self.into_inner(), + let output: ::core::option::Option = ::bevy_math::bounding::RayCast3d::sphere_intersection_at( + &_self, + &sphere, ) .into(); output @@ -5893,225 +8279,32 @@ pub(crate) fn register_triangle_3_d_functions(world: &mut World) { }; output }, - " This triangle but reversed.", - &["_self"], + " Get the distance of an intersection with a [`BoundingSphere`], if any.", + &["_self", "sphere"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::primitives::Triangle3d, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_polyline_3_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::primitives::Polyline3d, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Polyline3d>| { - let output: Val<::bevy_math::primitives::Polyline3d> = { - { - let output: Val<::bevy_math::primitives::Polyline3d> = - <::bevy_math::primitives::Polyline3d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::primitives::Polyline3d>, - other: Ref<::bevy_math::primitives::Polyline3d>| { - let output: bool = { - { - let output: bool = - <::bevy_math::primitives::Polyline3d as ::core::cmp::PartialEq< - ::bevy_math::primitives::Polyline3d, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::primitives::Polyline3d, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_ray_cast_2_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::bounding::RayCast2d, - >::new(world) - .register_documented( - "aabb_intersection_at", - |_self: Ref<::bevy_math::bounding::RayCast2d>, aabb: Ref<::bevy_math::bounding::Aabb2d>| { - let output: ::core::option::Option = { - { - let output: ::core::option::Option = - ::bevy_math::bounding::RayCast2d::aabb_intersection_at(&_self, &aabb) - .into(); - output - } - }; - output - }, - " Get the distance of an intersection with an [`Aabb2d`], if any.", - &["_self", "aabb"], - ) - .register_documented( - "circle_intersection_at", - |_self: Ref<::bevy_math::bounding::RayCast2d>, - circle: Ref<::bevy_math::bounding::BoundingCircle>| { - let output: ::core::option::Option = { - { - let output: ::core::option::Option = - ::bevy_math::bounding::RayCast2d::circle_intersection_at(&_self, &circle) - .into(); - output - } - }; - output - }, - " Get the distance of an intersection with a [`BoundingCircle`], if any.", - &["_self", "circle"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_math::bounding::RayCast2d>| { - let output: Val<::bevy_math::bounding::RayCast2d> = { - { - let output: Val<::bevy_math::bounding::RayCast2d> = - <::bevy_math::bounding::RayCast2d as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "from_ray", - |ray: Val<::bevy_math::Ray2d>, max: f32| { - let output: Val<::bevy_math::bounding::RayCast2d> = { - { - let output: Val<::bevy_math::bounding::RayCast2d> = - ::bevy_math::bounding::RayCast2d::from_ray(ray.into_inner(), max).into(); - output - } - }; - output - }, - " Construct a [`RayCast2d`] from a [`Ray2d`] and max distance.", - &["ray", "max"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::bounding::RayCast2d, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_aabb_cast_2_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::bounding::AabbCast2d, - >::new(world) - .register_documented( - "aabb_collision_at", - |_self: Ref<::bevy_math::bounding::AabbCast2d>, - aabb: Val<::bevy_math::bounding::Aabb2d>| { - let output: ::core::option::Option = { - { - let output: ::core::option::Option = - ::bevy_math::bounding::AabbCast2d::aabb_collision_at( - &_self, - aabb.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Get the distance at which the [`Aabb2d`]s collide, if at all.", - &["_self", "aabb"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_math::bounding::AabbCast2d>| { - let output: Val<::bevy_math::bounding::AabbCast2d> = { - { - let output: Val<::bevy_math::bounding::AabbCast2d> = - <::bevy_math::bounding::AabbCast2d as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "from_ray", - |aabb: Val<::bevy_math::bounding::Aabb2d>, ray: Val<::bevy_math::Ray2d>, max: f32| { - let output: Val<::bevy_math::bounding::AabbCast2d> = { - { - let output: Val<::bevy_math::bounding::AabbCast2d> = - ::bevy_math::bounding::AabbCast2d::from_ray( - aabb.into_inner(), - ray.into_inner(), - max, - ) - .into(); - output - } - }; - output - }, - " Construct an [`AabbCast2d`] from an [`Aabb2d`], [`Ray2d`], and max distance.", - &["aabb", "ray", "max"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::bounding::AabbCast2d, + ::bevy_math::bounding::RayCast3d, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_bounding_circle_cast_functions(world: &mut World) { +pub(crate) fn register_aabb_cast_3_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::bounding::BoundingCircleCast, + ::bevy_math::bounding::AabbCast3d, >::new(world) .register_documented( - "circle_collision_at", + "aabb_collision_at", | - _self: Ref<::bevy_math::bounding::BoundingCircleCast>, - circle: Val<::bevy_math::bounding::BoundingCircle>| + _self: Ref<::bevy_math::bounding::AabbCast3d>, + aabb: Val<::bevy_math::bounding::Aabb3d>| { let output: ::core::option::Option = { { - let output: ::core::option::Option = ::bevy_math::bounding::BoundingCircleCast::circle_collision_at( + let output: ::core::option::Option = ::bevy_math::bounding::AabbCast3d::aabb_collision_at( &_self, - circle.into_inner(), + aabb.into_inner(), ) .into(); output @@ -6119,15 +8312,15 @@ pub(crate) fn register_bounding_circle_cast_functions(world: &mut World) { }; output }, - " Get the distance at which the [`BoundingCircle`]s collide, if at all.", - &["_self", "circle"], + " Get the distance at which the [`Aabb3d`]s collide, if at all.", + &["_self", "aabb"], ) .register_documented( "clone", - |_self: Ref<::bevy_math::bounding::BoundingCircleCast>| { - let output: Val<::bevy_math::bounding::BoundingCircleCast> = { + |_self: Ref<::bevy_math::bounding::AabbCast3d>| { + let output: Val<::bevy_math::bounding::AabbCast3d> = { { - let output: Val<::bevy_math::bounding::BoundingCircleCast> = <::bevy_math::bounding::BoundingCircleCast as ::core::clone::Clone>::clone( + let output: Val<::bevy_math::bounding::AabbCast3d> = <::bevy_math::bounding::AabbCast3d as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -6142,14 +8335,14 @@ pub(crate) fn register_bounding_circle_cast_functions(world: &mut World) { .register_documented( "from_ray", | - circle: Val<::bevy_math::bounding::BoundingCircle>, - ray: Val<::bevy_math::Ray2d>, + aabb: Val<::bevy_math::bounding::Aabb3d>, + ray: Val<::bevy_math::Ray3d>, max: f32| { - let output: Val<::bevy_math::bounding::BoundingCircleCast> = { + let output: Val<::bevy_math::bounding::AabbCast3d> = { { - let output: Val<::bevy_math::bounding::BoundingCircleCast> = ::bevy_math::bounding::BoundingCircleCast::from_ray( - circle.into_inner(), + let output: Val<::bevy_math::bounding::AabbCast3d> = ::bevy_math::bounding::AabbCast3d::from_ray( + aabb.into_inner(), ray.into_inner(), max, ) @@ -6159,155 +8352,11 @@ pub(crate) fn register_bounding_circle_cast_functions(world: &mut World) { }; output }, - " Construct a [`BoundingCircleCast`] from a [`BoundingCircle`], [`Ray2d`], and max distance.", - &["circle", "ray", "max"], + " Construct an [`AabbCast3d`] from an [`Aabb3d`], [`Ray3d`], and max distance.", + &["aabb", "ray", "max"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::bounding::BoundingCircleCast, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_ray_cast_3_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::bounding::RayCast3d, - >::new(world) - .register_documented( - "aabb_intersection_at", - |_self: Ref<::bevy_math::bounding::RayCast3d>, aabb: Ref<::bevy_math::bounding::Aabb3d>| { - let output: ::core::option::Option = { - { - let output: ::core::option::Option = - ::bevy_math::bounding::RayCast3d::aabb_intersection_at(&_self, &aabb) - .into(); - output - } - }; - output - }, - " Get the distance of an intersection with an [`Aabb3d`], if any.", - &["_self", "aabb"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_math::bounding::RayCast3d>| { - let output: Val<::bevy_math::bounding::RayCast3d> = { - { - let output: Val<::bevy_math::bounding::RayCast3d> = - <::bevy_math::bounding::RayCast3d as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "from_ray", - |ray: Val<::bevy_math::Ray3d>, max: f32| { - let output: Val<::bevy_math::bounding::RayCast3d> = { - { - let output: Val<::bevy_math::bounding::RayCast3d> = - ::bevy_math::bounding::RayCast3d::from_ray(ray.into_inner(), max).into(); - output - } - }; - output - }, - " Construct a [`RayCast3d`] from a [`Ray3d`] and max distance.", - &["ray", "max"], - ) - .register_documented( - "sphere_intersection_at", - |_self: Ref<::bevy_math::bounding::RayCast3d>, - sphere: Ref<::bevy_math::bounding::BoundingSphere>| { - let output: ::core::option::Option = { - { - let output: ::core::option::Option = - ::bevy_math::bounding::RayCast3d::sphere_intersection_at(&_self, &sphere) - .into(); - output - } - }; - output - }, - " Get the distance of an intersection with a [`BoundingSphere`], if any.", - &["_self", "sphere"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_math::bounding::RayCast3d, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_aabb_cast_3_d_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::bounding::AabbCast3d, - >::new(world) - .register_documented( - "aabb_collision_at", - |_self: Ref<::bevy_math::bounding::AabbCast3d>, - aabb: Val<::bevy_math::bounding::Aabb3d>| { - let output: ::core::option::Option = { - { - let output: ::core::option::Option = - ::bevy_math::bounding::AabbCast3d::aabb_collision_at( - &_self, - aabb.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Get the distance at which the [`Aabb3d`]s collide, if at all.", - &["_self", "aabb"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_math::bounding::AabbCast3d>| { - let output: Val<::bevy_math::bounding::AabbCast3d> = { - { - let output: Val<::bevy_math::bounding::AabbCast3d> = - <::bevy_math::bounding::AabbCast3d as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "from_ray", - |aabb: Val<::bevy_math::bounding::Aabb3d>, ray: Val<::bevy_math::Ray3d>, max: f32| { - let output: Val<::bevy_math::bounding::AabbCast3d> = { - { - let output: Val<::bevy_math::bounding::AabbCast3d> = - ::bevy_math::bounding::AabbCast3d::from_ray( - aabb.into_inner(), - ray.into_inner(), - max, - ) - .into(); - output - } - }; - output - }, - " Construct an [`AabbCast3d`] from an [`Aabb3d`], [`Ray3d`], and max distance.", - &["aabb", "ray", "max"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); registry .register_type_data::< ::bevy_math::bounding::AabbCast3d, @@ -6389,14 +8438,14 @@ pub(crate) fn register_bounding_sphere_cast_functions(world: &mut World) { } pub(crate) fn register_interval_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::curve::interval::Interval, + ::bevy_math::curve::Interval, >::new(world) .register_documented( "clamp", - |_self: Val<::bevy_math::curve::interval::Interval>, value: f32| { + |_self: Val<::bevy_math::curve::Interval>, value: f32| { let output: f32 = { { - let output: f32 = ::bevy_math::curve::interval::Interval::clamp( + let output: f32 = ::bevy_math::curve::Interval::clamp( _self.into_inner(), value, ) @@ -6411,10 +8460,10 @@ pub(crate) fn register_interval_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_math::curve::interval::Interval>| { - let output: Val<::bevy_math::curve::interval::Interval> = { + |_self: Ref<::bevy_math::curve::Interval>| { + let output: Val<::bevy_math::curve::Interval> = { { - let output: Val<::bevy_math::curve::interval::Interval> = <::bevy_math::curve::interval::Interval as ::core::clone::Clone>::clone( + let output: Val<::bevy_math::curve::Interval> = <::bevy_math::curve::Interval as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -6428,10 +8477,10 @@ pub(crate) fn register_interval_functions(world: &mut World) { ) .register_documented( "contains", - |_self: Val<::bevy_math::curve::interval::Interval>, item: f32| { + |_self: Val<::bevy_math::curve::Interval>, item: f32| { let output: bool = { { - let output: bool = ::bevy_math::curve::interval::Interval::contains( + let output: bool = ::bevy_math::curve::Interval::contains( _self.into_inner(), item, ) @@ -6447,12 +8496,12 @@ pub(crate) fn register_interval_functions(world: &mut World) { .register_documented( "contains_interval", | - _self: Val<::bevy_math::curve::interval::Interval>, - other: Val<::bevy_math::curve::interval::Interval>| + _self: Val<::bevy_math::curve::Interval>, + other: Val<::bevy_math::curve::Interval>| { let output: bool = { { - let output: bool = ::bevy_math::curve::interval::Interval::contains_interval( + let output: bool = ::bevy_math::curve::Interval::contains_interval( _self.into_inner(), other.into_inner(), ) @@ -6467,10 +8516,10 @@ pub(crate) fn register_interval_functions(world: &mut World) { ) .register_documented( "end", - |_self: Val<::bevy_math::curve::interval::Interval>| { + |_self: Val<::bevy_math::curve::Interval>| { let output: f32 = { { - let output: f32 = ::bevy_math::curve::interval::Interval::end( + let output: f32 = ::bevy_math::curve::Interval::end( _self.into_inner(), ) .into(); @@ -6485,13 +8534,13 @@ pub(crate) fn register_interval_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_math::curve::interval::Interval>, - other: Ref<::bevy_math::curve::interval::Interval>| + _self: Ref<::bevy_math::curve::Interval>, + other: Ref<::bevy_math::curve::Interval>| { let output: bool = { { - let output: bool = <::bevy_math::curve::interval::Interval as ::core::cmp::PartialEq< - ::bevy_math::curve::interval::Interval, + let output: bool = <::bevy_math::curve::Interval as ::core::cmp::PartialEq< + ::bevy_math::curve::Interval, >>::eq(&_self, &other) .into(); output @@ -6504,10 +8553,10 @@ pub(crate) fn register_interval_functions(world: &mut World) { ) .register_documented( "has_finite_end", - |_self: Val<::bevy_math::curve::interval::Interval>| { + |_self: Val<::bevy_math::curve::Interval>| { let output: bool = { { - let output: bool = ::bevy_math::curve::interval::Interval::has_finite_end( + let output: bool = ::bevy_math::curve::Interval::has_finite_end( _self.into_inner(), ) .into(); @@ -6521,10 +8570,10 @@ pub(crate) fn register_interval_functions(world: &mut World) { ) .register_documented( "has_finite_start", - |_self: Val<::bevy_math::curve::interval::Interval>| { + |_self: Val<::bevy_math::curve::Interval>| { let output: bool = { { - let output: bool = ::bevy_math::curve::interval::Interval::has_finite_start( + let output: bool = ::bevy_math::curve::Interval::has_finite_start( _self.into_inner(), ) .into(); @@ -6538,10 +8587,10 @@ pub(crate) fn register_interval_functions(world: &mut World) { ) .register_documented( "is_bounded", - |_self: Val<::bevy_math::curve::interval::Interval>| { + |_self: Val<::bevy_math::curve::Interval>| { let output: bool = { { - let output: bool = ::bevy_math::curve::interval::Interval::is_bounded( + let output: bool = ::bevy_math::curve::Interval::is_bounded( _self.into_inner(), ) .into(); @@ -6555,10 +8604,10 @@ pub(crate) fn register_interval_functions(world: &mut World) { ) .register_documented( "length", - |_self: Val<::bevy_math::curve::interval::Interval>| { + |_self: Val<::bevy_math::curve::Interval>| { let output: f32 = { { - let output: f32 = ::bevy_math::curve::interval::Interval::length( + let output: f32 = ::bevy_math::curve::Interval::length( _self.into_inner(), ) .into(); @@ -6572,10 +8621,10 @@ pub(crate) fn register_interval_functions(world: &mut World) { ) .register_documented( "start", - |_self: Val<::bevy_math::curve::interval::Interval>| { + |_self: Val<::bevy_math::curve::Interval>| { let output: f32 = { { - let output: f32 = ::bevy_math::curve::interval::Interval::start( + let output: f32 = ::bevy_math::curve::Interval::start( _self.into_inner(), ) .into(); @@ -6591,7 +8640,7 @@ pub(crate) fn register_interval_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::curve::interval::Interval, + ::bevy_math::curve::Interval, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -6599,6 +8648,23 @@ pub(crate) fn register_dir_4_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_math::Dir4, >::new(world) + .register_documented( + "as_vec4", + |_self: Ref<::bevy_math::Dir4>| { + let output: Val<::bevy_math::Vec4> = { + { + let output: Val<::bevy_math::Vec4> = ::bevy_math::Dir4::as_vec4( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the inner [`Vec4`]", + &["_self"], + ) .register_documented( "clone", |_self: Ref<::bevy_math::Dir4>| { @@ -6670,6 +8736,23 @@ pub(crate) fn register_dir_4_functions(world: &mut World) { " Create a direction from its `x`, `y`, `z`, and `w` components, assuming the resulting vector is normalized.\n # Warning\n The vector produced from `x`, `y`, `z`, and `w` must be normalized, i.e its length must be `1.0`.", &["x", "y", "z", "w"], ) + .register_documented( + "mul", + |_self: Val<::bevy_math::Dir4>, rhs: f32| { + let output: Val<::bevy_math::Vec4> = { + { + let output: Val<::bevy_math::Vec4> = <::bevy_math::Dir4 as ::core::ops::Mul< + f32, + >>::mul(_self.into_inner(), rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) .register_documented( "neg", |_self: Val<::bevy_math::Dir4>| { @@ -6686,11 +8769,31 @@ pub(crate) fn register_dir_4_functions(world: &mut World) { }, "", &["_self"], + ) + .register_documented( + "new_unchecked", + |value: Val<::bevy_math::Vec4>| { + let output: Val<::bevy_math::Dir4> = { + { + let output: Val<::bevy_math::Dir4> = ::bevy_math::Dir4::new_unchecked( + value.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a [`Dir4`] from a [`Vec4`] that is already normalized.\n # Warning\n `value` must be normalized, i.e its length must be `1.0`.", + &["value"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::bevy_math::Dir4, bevy_mod_scripting_bindings::MarkAsGenerated>(); + .register_type_data::< + ::bevy_math::Dir4, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_float_ord_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -6818,48 +8921,70 @@ pub(crate) fn register_float_ord_functions(world: &mut World) { let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::bevy_math::FloatOrd, bevy_mod_scripting_bindings::MarkAsGenerated>( - ); + .register_type_data::< + ::bevy_math::FloatOrd, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_plane_3_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_math::primitives::Plane3d, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::primitives::Plane3d>| { - let output: Val<::bevy_math::primitives::Plane3d> = { - { - let output: Val<::bevy_math::primitives::Plane3d> = - <::bevy_math::primitives::Plane3d as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::primitives::Plane3d>, - other: Ref<::bevy_math::primitives::Plane3d>| { - let output: bool = { - { - let output: bool = - <::bevy_math::primitives::Plane3d as ::core::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_math::primitives::Plane3d>| { + let output: Val<::bevy_math::primitives::Plane3d> = { + { + let output: Val<::bevy_math::primitives::Plane3d> = <::bevy_math::primitives::Plane3d as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::primitives::Plane3d>, + other: Ref<::bevy_math::primitives::Plane3d>| + { + let output: bool = { + { + let output: bool = <::bevy_math::primitives::Plane3d as ::core::cmp::PartialEq< ::bevy_math::primitives::Plane3d, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "new", + |normal: Val<::bevy_math::Vec3>, half_size: Val<::bevy_math::Vec2>| { + let output: Val<::bevy_math::primitives::Plane3d> = { + { + let output: Val<::bevy_math::primitives::Plane3d> = ::bevy_math::primitives::Plane3d::new( + normal.into_inner(), + half_size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new `Plane3d` from a normal and a half size\n # Panics\n Panics if the given `normal` is zero (or very close to zero), or non-finite.", + &["normal", "half_size"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -6872,6 +8997,23 @@ pub(crate) fn register_tetrahedron_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_math::primitives::Tetrahedron, >::new(world) + .register_documented( + "centroid", + |_self: Ref<::bevy_math::primitives::Tetrahedron>| { + let output: Val<::bevy_math::Vec3> = { + { + let output: Val<::bevy_math::Vec3> = ::bevy_math::primitives::Tetrahedron::centroid( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the centroid of the tetrahedron.\n This function finds the geometric center of the tetrahedron\n by averaging the vertices: `centroid = (a + b + c + d) / 4`.", + &["_self"], + ) .register_documented( "clone", |_self: Ref<::bevy_math::primitives::Tetrahedron>| { @@ -6909,6 +9051,31 @@ pub(crate) fn register_tetrahedron_functions(world: &mut World) { "", &["_self", "other"], ) + .register_documented( + "new", + | + a: Val<::bevy_math::Vec3>, + b: Val<::bevy_math::Vec3>, + c: Val<::bevy_math::Vec3>, + d: Val<::bevy_math::Vec3>| + { + let output: Val<::bevy_math::primitives::Tetrahedron> = { + { + let output: Val<::bevy_math::primitives::Tetrahedron> = ::bevy_math::primitives::Tetrahedron::new( + a.into_inner(), + b.into_inner(), + c.into_inner(), + d.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new [`Tetrahedron`] from points `a`, `b`, `c` and `d`.", + &["a", "b", "c", "d"], + ) .register_documented( "signed_volume", |_self: Ref<::bevy_math::primitives::Tetrahedron>| { @@ -6936,63 +9103,63 @@ pub(crate) fn register_tetrahedron_functions(world: &mut World) { } pub(crate) fn register_ease_function_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::curve::easing::EaseFunction, + ::bevy_math::curve::EaseFunction, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_math::curve::easing::EaseFunction>| { - let output: Val<::bevy_math::curve::easing::EaseFunction> = { - { - let output: Val<::bevy_math::curve::easing::EaseFunction> = - <::bevy_math::curve::easing::EaseFunction as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_math::curve::easing::EaseFunction>, - other: Ref<::bevy_math::curve::easing::EaseFunction>| { - let output: bool = { - { - let output: bool = - <::bevy_math::curve::easing::EaseFunction as ::core::cmp::PartialEq< - ::bevy_math::curve::easing::EaseFunction, + .register_documented( + "clone", + |_self: Ref<::bevy_math::curve::EaseFunction>| { + let output: Val<::bevy_math::curve::EaseFunction> = { + { + let output: Val<::bevy_math::curve::EaseFunction> = <::bevy_math::curve::EaseFunction as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_math::curve::EaseFunction>, + other: Ref<::bevy_math::curve::EaseFunction>| + { + let output: bool = { + { + let output: bool = <::bevy_math::curve::EaseFunction as ::core::cmp::PartialEq< + ::bevy_math::curve::EaseFunction, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::curve::easing::EaseFunction, + ::bevy_math::curve::EaseFunction, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_jump_at_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_math::curve::easing::JumpAt, + ::bevy_math::curve::JumpAt, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_math::curve::easing::JumpAt>| { + |_self: Ref<::bevy_math::curve::JumpAt>| { let output: () = { { - let output: () = <::bevy_math::curve::easing::JumpAt as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_math::curve::JumpAt as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -7006,10 +9173,10 @@ pub(crate) fn register_jump_at_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_math::curve::easing::JumpAt>| { - let output: Val<::bevy_math::curve::easing::JumpAt> = { + |_self: Ref<::bevy_math::curve::JumpAt>| { + let output: Val<::bevy_math::curve::JumpAt> = { { - let output: Val<::bevy_math::curve::easing::JumpAt> = <::bevy_math::curve::easing::JumpAt as ::core::clone::Clone>::clone( + let output: Val<::bevy_math::curve::JumpAt> = <::bevy_math::curve::JumpAt as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -7024,13 +9191,13 @@ pub(crate) fn register_jump_at_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_math::curve::easing::JumpAt>, - other: Ref<::bevy_math::curve::easing::JumpAt>| + _self: Ref<::bevy_math::curve::JumpAt>, + other: Ref<::bevy_math::curve::JumpAt>| { let output: bool = { { - let output: bool = <::bevy_math::curve::easing::JumpAt as ::core::cmp::PartialEq< - ::bevy_math::curve::easing::JumpAt, + let output: bool = <::bevy_math::curve::JumpAt as ::core::cmp::PartialEq< + ::bevy_math::curve::JumpAt, >>::eq(&_self, &other) .into(); output @@ -7045,7 +9212,7 @@ pub(crate) fn register_jump_at_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_math::curve::easing::JumpAt, + ::bevy_math::curve::JumpAt, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } diff --git a/crates/bindings/bevy_mesh_bms_bindings/src/lib.rs b/crates/bindings/bevy_mesh_bms_bindings/src/lib.rs index c15d28bc38..f9c7d38e06 100644 --- a/crates/bindings/bevy_mesh_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_mesh_bms_bindings/src/lib.rs @@ -1,37 +1,41 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyMeshScriptingPlugin; pub(crate) fn register_morph_weights_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_mesh::morph::MorphWeights, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_mesh::morph::MorphWeights>| { - let output: Val<::bevy_mesh::morph::MorphWeights> = { - { - let output: Val<::bevy_mesh::morph::MorphWeights> = - <::bevy_mesh::morph::MorphWeights as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_mesh::morph::MorphWeights>| { + let output: Val<::bevy_mesh::morph::MorphWeights> = { + { + let output: Val<::bevy_mesh::morph::MorphWeights> = <::bevy_mesh::morph::MorphWeights as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -42,14 +46,14 @@ pub(crate) fn register_morph_weights_functions(world: &mut World) { } pub(crate) fn register_mesh_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::prelude::Mesh, + ::bevy_mesh::Mesh, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_mesh::prelude::Mesh>| { - let output: Val<::bevy_mesh::prelude::Mesh> = { + |_self: Ref<::bevy_mesh::Mesh>| { + let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::prelude::Mesh> = <::bevy_mesh::prelude::Mesh as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::Mesh> = <::bevy_mesh::Mesh as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -63,10 +67,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "compute_area_weighted_normals", - |mut _self: Mut<::bevy_mesh::prelude::Mesh>| { + |mut _self: Mut<::bevy_mesh::Mesh>| { let output: () = { { - let output: () = ::bevy_mesh::prelude::Mesh::compute_area_weighted_normals( + let output: () = ::bevy_mesh::Mesh::compute_area_weighted_normals( &mut _self, ) .into(); @@ -80,10 +84,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "compute_flat_normals", - |mut _self: Mut<::bevy_mesh::prelude::Mesh>| { + |mut _self: Mut<::bevy_mesh::Mesh>| { let output: () = { { - let output: () = ::bevy_mesh::prelude::Mesh::compute_flat_normals( + let output: () = ::bevy_mesh::Mesh::compute_flat_normals( &mut _self, ) .into(); @@ -97,12 +101,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "compute_normals", - |mut _self: Mut<::bevy_mesh::prelude::Mesh>| { + |mut _self: Mut<::bevy_mesh::Mesh>| { let output: () = { { - let output: () = ::bevy_mesh::prelude::Mesh::compute_normals( - &mut _self, - ) + let output: () = ::bevy_mesh::Mesh::compute_normals(&mut _self) .into(); output } @@ -114,10 +116,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "compute_smooth_normals", - |mut _self: Mut<::bevy_mesh::prelude::Mesh>| { + |mut _self: Mut<::bevy_mesh::Mesh>| { let output: () = { { - let output: () = ::bevy_mesh::prelude::Mesh::compute_smooth_normals( + let output: () = ::bevy_mesh::Mesh::compute_smooth_normals( &mut _self, ) .into(); @@ -131,12 +133,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "count_vertices", - |_self: Ref<::bevy_mesh::prelude::Mesh>| { + |_self: Ref<::bevy_mesh::Mesh>| { let output: usize = { { - let output: usize = ::bevy_mesh::prelude::Mesh::count_vertices( - &_self, - ) + let output: usize = ::bevy_mesh::Mesh::count_vertices(&_self) .into(); output } @@ -148,10 +148,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "create_packed_vertex_buffer_data", - |_self: Ref<::bevy_mesh::prelude::Mesh>| { + |_self: Ref<::bevy_mesh::Mesh>| { let output: ::std::vec::Vec = { { - let output: ::std::vec::Vec = ::bevy_mesh::prelude::Mesh::create_packed_vertex_buffer_data( + let output: ::std::vec::Vec = ::bevy_mesh::Mesh::create_packed_vertex_buffer_data( &_self, ) .into(); @@ -165,10 +165,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "duplicate_vertices", - |mut _self: Mut<::bevy_mesh::prelude::Mesh>| { + |mut _self: Mut<::bevy_mesh::Mesh>| { let output: () = { { - let output: () = ::bevy_mesh::prelude::Mesh::duplicate_vertices( + let output: () = ::bevy_mesh::Mesh::duplicate_vertices( &mut _self, ) .into(); @@ -182,14 +182,11 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_mesh::prelude::Mesh>, - other: Ref<::bevy_mesh::prelude::Mesh>| - { + |_self: Ref<::bevy_mesh::Mesh>, other: Ref<::bevy_mesh::Mesh>| { let output: bool = { { - let output: bool = <::bevy_mesh::prelude::Mesh as ::std::cmp::PartialEq< - ::bevy_mesh::prelude::Mesh, + let output: bool = <::bevy_mesh::Mesh as ::std::cmp::PartialEq< + ::bevy_mesh::Mesh, >>::eq(&_self, &other) .into(); output @@ -202,10 +199,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "get_vertex_buffer_size", - |_self: Ref<::bevy_mesh::prelude::Mesh>| { + |_self: Ref<::bevy_mesh::Mesh>| { let output: usize = { { - let output: usize = ::bevy_mesh::prelude::Mesh::get_vertex_buffer_size( + let output: usize = ::bevy_mesh::Mesh::get_vertex_buffer_size( &_self, ) .into(); @@ -219,12 +216,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "get_vertex_size", - |_self: Ref<::bevy_mesh::prelude::Mesh>| { + |_self: Ref<::bevy_mesh::Mesh>| { let output: u64 = { { - let output: u64 = ::bevy_mesh::prelude::Mesh::get_vertex_size( - &_self, - ) + let output: u64 = ::bevy_mesh::Mesh::get_vertex_size(&_self) .into(); output } @@ -236,12 +231,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "has_morph_targets", - |_self: Ref<::bevy_mesh::prelude::Mesh>| { + |_self: Ref<::bevy_mesh::Mesh>| { let output: bool = { { - let output: bool = ::bevy_mesh::prelude::Mesh::has_morph_targets( - &_self, - ) + let output: bool = ::bevy_mesh::Mesh::has_morph_targets(&_self) .into(); output } @@ -253,13 +246,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "insert_indices", - | - mut _self: Mut<::bevy_mesh::prelude::Mesh>, - indices: Val<::bevy_mesh::Indices>| - { + |mut _self: Mut<::bevy_mesh::Mesh>, indices: Val<::bevy_mesh::Indices>| { let output: () = { { - let output: () = ::bevy_mesh::prelude::Mesh::insert_indices( + let output: () = ::bevy_mesh::Mesh::insert_indices( &mut _self, indices.into_inner(), ) @@ -274,10 +264,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "normalize_joint_weights", - |mut _self: Mut<::bevy_mesh::prelude::Mesh>| { + |mut _self: Mut<::bevy_mesh::Mesh>| { let output: () = { { - let output: () = ::bevy_mesh::prelude::Mesh::normalize_joint_weights( + let output: () = ::bevy_mesh::Mesh::normalize_joint_weights( &mut _self, ) .into(); @@ -289,15 +279,87 @@ pub(crate) fn register_mesh_functions(world: &mut World) { " Normalize joint weights so they sum to 1.", &["_self"], ) + .register_documented( + "rotate_by", + |mut _self: Mut<::bevy_mesh::Mesh>, rotation: Val<::glam::Quat>| { + let output: () = { + { + let output: () = ::bevy_mesh::Mesh::rotate_by( + &mut _self, + rotation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Rotates the vertex positions, normals, and tangents of the mesh in place by the given [`Quat`].\n `Aabb` of entities with modified mesh are not updated automatically.", + &["_self", "rotation"], + ) + .register_documented( + "rotated_by", + |_self: Val<::bevy_mesh::Mesh>, rotation: Val<::glam::Quat>| { + let output: Val<::bevy_mesh::Mesh> = { + { + let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::rotated_by( + _self.into_inner(), + rotation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Rotates the vertex positions, normals, and tangents of the mesh by the given [`Quat`].\n `Aabb` of entities with modified mesh are not updated automatically.", + &["_self", "rotation"], + ) + .register_documented( + "scale_by", + |mut _self: Mut<::bevy_mesh::Mesh>, scale: Val<::glam::Vec3>| { + let output: () = { + { + let output: () = ::bevy_mesh::Mesh::scale_by( + &mut _self, + scale.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Scales the vertex positions, normals, and tangents of the mesh in place by the given [`Vec3`].\n `Aabb` of entities with modified mesh are not updated automatically.", + &["_self", "scale"], + ) + .register_documented( + "scaled_by", + |_self: Val<::bevy_mesh::Mesh>, scale: Val<::glam::Vec3>| { + let output: Val<::bevy_mesh::Mesh> = { + { + let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::scaled_by( + _self.into_inner(), + scale.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Scales the vertex positions, normals, and tangents of the mesh by the given [`Vec3`].\n `Aabb` of entities with modified mesh are not updated automatically.", + &["_self", "scale"], + ) .register_documented( "set_morph_target_names", | - mut _self: Mut<::bevy_mesh::prelude::Mesh>, + mut _self: Mut<::bevy_mesh::Mesh>, names: ::std::vec::Vec<::std::string::String>| { let output: () = { { - let output: () = ::bevy_mesh::prelude::Mesh::set_morph_target_names( + let output: () = ::bevy_mesh::Mesh::set_morph_target_names( &mut _self, names, ) @@ -313,12 +375,12 @@ pub(crate) fn register_mesh_functions(world: &mut World) { .register_documented( "transform_by", | - mut _self: Mut<::bevy_mesh::prelude::Mesh>, + mut _self: Mut<::bevy_mesh::Mesh>, transform: Val<::bevy_transform::components::Transform>| { let output: () = { { - let output: () = ::bevy_mesh::prelude::Mesh::transform_by( + let output: () = ::bevy_mesh::Mesh::transform_by( &mut _self, transform.into_inner(), ) @@ -334,12 +396,12 @@ pub(crate) fn register_mesh_functions(world: &mut World) { .register_documented( "transformed_by", | - _self: Val<::bevy_mesh::prelude::Mesh>, + _self: Val<::bevy_mesh::Mesh>, transform: Val<::bevy_transform::components::Transform>| { - let output: Val<::bevy_mesh::prelude::Mesh> = { + let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::transformed_by( + let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::transformed_by( _self.into_inner(), transform.into_inner(), ) @@ -352,12 +414,48 @@ pub(crate) fn register_mesh_functions(world: &mut World) { " Transforms the vertex positions, normals, and tangents of the mesh by the given [`Transform`].\n `Aabb` of entities with modified mesh are not updated automatically.", &["_self", "transform"], ) + .register_documented( + "translate_by", + |mut _self: Mut<::bevy_mesh::Mesh>, translation: Val<::glam::Vec3>| { + let output: () = { + { + let output: () = ::bevy_mesh::Mesh::translate_by( + &mut _self, + translation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Translates the vertex positions of the mesh in place by the given [`Vec3`].\n `Aabb` of entities with modified mesh are not updated automatically.", + &["_self", "translation"], + ) + .register_documented( + "translated_by", + |_self: Val<::bevy_mesh::Mesh>, translation: Val<::glam::Vec3>| { + let output: Val<::bevy_mesh::Mesh> = { + { + let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::translated_by( + _self.into_inner(), + translation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Translates the vertex positions of the mesh by the given [`Vec3`].\n `Aabb` of entities with modified mesh are not updated automatically.", + &["_self", "translation"], + ) .register_documented( "with_computed_area_weighted_normals", - |_self: Val<::bevy_mesh::prelude::Mesh>| { - let output: Val<::bevy_mesh::prelude::Mesh> = { + |_self: Val<::bevy_mesh::Mesh>| { + let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::with_computed_area_weighted_normals( + let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::with_computed_area_weighted_normals( _self.into_inner(), ) .into(); @@ -371,10 +469,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "with_computed_flat_normals", - |_self: Val<::bevy_mesh::prelude::Mesh>| { - let output: Val<::bevy_mesh::prelude::Mesh> = { + |_self: Val<::bevy_mesh::Mesh>| { + let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::with_computed_flat_normals( + let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::with_computed_flat_normals( _self.into_inner(), ) .into(); @@ -388,10 +486,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "with_computed_normals", - |_self: Val<::bevy_mesh::prelude::Mesh>| { - let output: Val<::bevy_mesh::prelude::Mesh> = { + |_self: Val<::bevy_mesh::Mesh>| { + let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::with_computed_normals( + let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::with_computed_normals( _self.into_inner(), ) .into(); @@ -405,10 +503,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "with_computed_smooth_normals", - |_self: Val<::bevy_mesh::prelude::Mesh>| { - let output: Val<::bevy_mesh::prelude::Mesh> = { + |_self: Val<::bevy_mesh::Mesh>| { + let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::with_computed_smooth_normals( + let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::with_computed_smooth_normals( _self.into_inner(), ) .into(); @@ -422,10 +520,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "with_duplicated_vertices", - |_self: Val<::bevy_mesh::prelude::Mesh>| { - let output: Val<::bevy_mesh::prelude::Mesh> = { + |_self: Val<::bevy_mesh::Mesh>| { + let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::with_duplicated_vertices( + let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::with_duplicated_vertices( _self.into_inner(), ) .into(); @@ -439,10 +537,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "with_inserted_indices", - |_self: Val<::bevy_mesh::prelude::Mesh>, indices: Val<::bevy_mesh::Indices>| { - let output: Val<::bevy_mesh::prelude::Mesh> = { + |_self: Val<::bevy_mesh::Mesh>, indices: Val<::bevy_mesh::Indices>| { + let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::with_inserted_indices( + let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::with_inserted_indices( _self.into_inner(), indices.into_inner(), ) @@ -458,12 +556,12 @@ pub(crate) fn register_mesh_functions(world: &mut World) { .register_documented( "with_morph_target_names", | - _self: Val<::bevy_mesh::prelude::Mesh>, + _self: Val<::bevy_mesh::Mesh>, names: ::std::vec::Vec<::std::string::String>| { - let output: Val<::bevy_mesh::prelude::Mesh> = { + let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::with_morph_target_names( + let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::with_morph_target_names( _self.into_inner(), names, ) @@ -478,10 +576,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "with_removed_indices", - |_self: Val<::bevy_mesh::prelude::Mesh>| { - let output: Val<::bevy_mesh::prelude::Mesh> = { + |_self: Val<::bevy_mesh::Mesh>| { + let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::prelude::Mesh::with_removed_indices( + let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::with_removed_indices( _self.into_inner(), ) .into(); @@ -497,20 +595,20 @@ pub(crate) fn register_mesh_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::prelude::Mesh, + ::bevy_mesh::Mesh, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_mesh_2_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::prelude::Mesh2d, + ::bevy_mesh::Mesh2d, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_mesh::prelude::Mesh2d>| { + |_self: Ref<::bevy_mesh::Mesh2d>| { let output: () = { { - let output: () = <::bevy_mesh::prelude::Mesh2d as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_mesh::Mesh2d as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -524,10 +622,10 @@ pub(crate) fn register_mesh_2_d_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_mesh::prelude::Mesh2d>| { - let output: Val<::bevy_mesh::prelude::Mesh2d> = { + |_self: Ref<::bevy_mesh::Mesh2d>| { + let output: Val<::bevy_mesh::Mesh2d> = { { - let output: Val<::bevy_mesh::prelude::Mesh2d> = <::bevy_mesh::prelude::Mesh2d as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::Mesh2d> = <::bevy_mesh::Mesh2d as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -541,14 +639,11 @@ pub(crate) fn register_mesh_2_d_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_mesh::prelude::Mesh2d>, - other: Ref<::bevy_mesh::prelude::Mesh2d>| - { + |_self: Ref<::bevy_mesh::Mesh2d>, other: Ref<::bevy_mesh::Mesh2d>| { let output: bool = { { - let output: bool = <::bevy_mesh::prelude::Mesh2d as ::std::cmp::PartialEq< - ::bevy_mesh::prelude::Mesh2d, + let output: bool = <::bevy_mesh::Mesh2d as ::std::cmp::PartialEq< + ::bevy_mesh::Mesh2d, >>::eq(&_self, &other) .into(); output @@ -563,20 +658,20 @@ pub(crate) fn register_mesh_2_d_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::prelude::Mesh2d, + ::bevy_mesh::Mesh2d, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_mesh_3_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::prelude::Mesh3d, + ::bevy_mesh::Mesh3d, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_mesh::prelude::Mesh3d>| { + |_self: Ref<::bevy_mesh::Mesh3d>| { let output: () = { { - let output: () = <::bevy_mesh::prelude::Mesh3d as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_mesh::Mesh3d as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -590,10 +685,10 @@ pub(crate) fn register_mesh_3_d_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_mesh::prelude::Mesh3d>| { - let output: Val<::bevy_mesh::prelude::Mesh3d> = { + |_self: Ref<::bevy_mesh::Mesh3d>| { + let output: Val<::bevy_mesh::Mesh3d> = { { - let output: Val<::bevy_mesh::prelude::Mesh3d> = <::bevy_mesh::prelude::Mesh3d as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::Mesh3d> = <::bevy_mesh::Mesh3d as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -607,14 +702,11 @@ pub(crate) fn register_mesh_3_d_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_mesh::prelude::Mesh3d>, - other: Ref<::bevy_mesh::prelude::Mesh3d>| - { + |_self: Ref<::bevy_mesh::Mesh3d>, other: Ref<::bevy_mesh::Mesh3d>| { let output: bool = { { - let output: bool = <::bevy_mesh::prelude::Mesh3d as ::std::cmp::PartialEq< - ::bevy_mesh::prelude::Mesh3d, + let output: bool = <::bevy_mesh::Mesh3d as ::std::cmp::PartialEq< + ::bevy_mesh::Mesh3d, >>::eq(&_self, &other) .into(); output @@ -629,7 +721,7 @@ pub(crate) fn register_mesh_3_d_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::prelude::Mesh3d, + ::bevy_mesh::Mesh3d, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -691,7 +783,10 @@ pub(crate) fn register_mesh_tag_functions(world: &mut World) { let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::bevy_mesh::MeshTag, bevy_mod_scripting_bindings::MarkAsGenerated>(); + .register_type_data::< + ::bevy_mesh::MeshTag, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_indices_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -777,45 +872,49 @@ pub(crate) fn register_indices_functions(world: &mut World) { let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::bevy_mesh::Indices, bevy_mod_scripting_bindings::MarkAsGenerated>(); + .register_type_data::< + ::bevy_mesh::Indices, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_mesh_morph_weights_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_mesh::morph::MeshMorphWeights, >::new(world) - .register_documented( - "clear_weights", - |mut _self: Mut<::bevy_mesh::morph::MeshMorphWeights>| { - let output: () = { - { - let output: () = - ::bevy_mesh::morph::MeshMorphWeights::clear_weights(&mut _self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_mesh::morph::MeshMorphWeights>| { - let output: Val<::bevy_mesh::morph::MeshMorphWeights> = { - { - let output: Val<::bevy_mesh::morph::MeshMorphWeights> = - <::bevy_mesh::morph::MeshMorphWeights as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clear_weights", + |mut _self: Mut<::bevy_mesh::morph::MeshMorphWeights>| { + let output: () = { + { + let output: () = ::bevy_mesh::morph::MeshMorphWeights::clear_weights( + &mut _self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_mesh::morph::MeshMorphWeights>| { + let output: Val<::bevy_mesh::morph::MeshMorphWeights> = { + { + let output: Val<::bevy_mesh::morph::MeshMorphWeights> = <::bevy_mesh::morph::MeshMorphWeights as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -826,78 +925,79 @@ pub(crate) fn register_mesh_morph_weights_functions(world: &mut World) { } pub(crate) fn register_circle_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::CircleMeshBuilder, + ::bevy_mesh::CircleMeshBuilder, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_mesh::primitives::CircleMeshBuilder>| { - let output: Val<::bevy_mesh::primitives::CircleMeshBuilder> = { - { - let output: Val<::bevy_mesh::primitives::CircleMeshBuilder> = - <::bevy_mesh::primitives::CircleMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "new", - |radius: f32, resolution: u32| { - let output: Val<::bevy_mesh::primitives::CircleMeshBuilder> = { - { - let output: Val<::bevy_mesh::primitives::CircleMeshBuilder> = - ::bevy_mesh::primitives::CircleMeshBuilder::new(radius, resolution).into(); - output - } - }; - output - }, - " Creates a new [`CircleMeshBuilder`] from a given radius and vertex count.", - &["radius", "resolution"], - ) - .register_documented( - "resolution", - |_self: Val<::bevy_mesh::primitives::CircleMeshBuilder>, resolution: u32| { - let output: Val<::bevy_mesh::primitives::CircleMeshBuilder> = { - { - let output: Val<::bevy_mesh::primitives::CircleMeshBuilder> = - ::bevy_mesh::primitives::CircleMeshBuilder::resolution( - _self.into_inner(), - resolution, - ) - .into(); - output - } - }; - output - }, - " Sets the number of vertices used for the circle mesh.", - &["_self", "resolution"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_mesh::CircleMeshBuilder>| { + let output: Val<::bevy_mesh::CircleMeshBuilder> = { + { + let output: Val<::bevy_mesh::CircleMeshBuilder> = <::bevy_mesh::CircleMeshBuilder as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "new", + |radius: f32, resolution: u32| { + let output: Val<::bevy_mesh::CircleMeshBuilder> = { + { + let output: Val<::bevy_mesh::CircleMeshBuilder> = ::bevy_mesh::CircleMeshBuilder::new( + radius, + resolution, + ) + .into(); + output + } + }; + output + }, + " Creates a new [`CircleMeshBuilder`] from a given radius and vertex count.", + &["radius", "resolution"], + ) + .register_documented( + "resolution", + |_self: Val<::bevy_mesh::CircleMeshBuilder>, resolution: u32| { + let output: Val<::bevy_mesh::CircleMeshBuilder> = { + { + let output: Val<::bevy_mesh::CircleMeshBuilder> = ::bevy_mesh::CircleMeshBuilder::resolution( + _self.into_inner(), + resolution, + ) + .into(); + output + } + }; + output + }, + " Sets the number of vertices used for the circle mesh.", + &["_self", "resolution"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::CircleMeshBuilder, + ::bevy_mesh::CircleMeshBuilder, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_circular_mesh_uv_mode_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::CircularMeshUvMode, + ::bevy_mesh::CircularMeshUvMode, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_mesh::primitives::CircularMeshUvMode>| { - let output: Val<::bevy_mesh::primitives::CircularMeshUvMode> = { + |_self: Ref<::bevy_mesh::CircularMeshUvMode>| { + let output: Val<::bevy_mesh::CircularMeshUvMode> = { { - let output: Val<::bevy_mesh::primitives::CircularMeshUvMode> = <::bevy_mesh::primitives::CircularMeshUvMode as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::CircularMeshUvMode> = <::bevy_mesh::CircularMeshUvMode as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -912,13 +1012,13 @@ pub(crate) fn register_circular_mesh_uv_mode_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_mesh::primitives::CircularMeshUvMode>, - other: Ref<::bevy_mesh::primitives::CircularMeshUvMode>| + _self: Ref<::bevy_mesh::CircularMeshUvMode>, + other: Ref<::bevy_mesh::CircularMeshUvMode>| { let output: bool = { { - let output: bool = <::bevy_mesh::primitives::CircularMeshUvMode as ::std::cmp::PartialEq< - ::bevy_mesh::primitives::CircularMeshUvMode, + let output: bool = <::bevy_mesh::CircularMeshUvMode as ::std::cmp::PartialEq< + ::bevy_mesh::CircularMeshUvMode, >>::eq(&_self, &other) .into(); output @@ -933,22 +1033,20 @@ pub(crate) fn register_circular_mesh_uv_mode_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::CircularMeshUvMode, + ::bevy_mesh::CircularMeshUvMode, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_circular_sector_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::CircularSectorMeshBuilder, + ::bevy_mesh::CircularSectorMeshBuilder, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_mesh::primitives::CircularSectorMeshBuilder>| { - let output: Val<::bevy_mesh::primitives::CircularSectorMeshBuilder> = { + |_self: Ref<::bevy_mesh::CircularSectorMeshBuilder>| { + let output: Val<::bevy_mesh::CircularSectorMeshBuilder> = { { - let output: Val< - ::bevy_mesh::primitives::CircularSectorMeshBuilder, - > = <::bevy_mesh::primitives::CircularSectorMeshBuilder as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::CircularSectorMeshBuilder> = <::bevy_mesh::CircularSectorMeshBuilder as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -963,11 +1061,9 @@ pub(crate) fn register_circular_sector_mesh_builder_functions(world: &mut World) .register_documented( "new", |sector: Val<::bevy_math::primitives::CircularSector>| { - let output: Val<::bevy_mesh::primitives::CircularSectorMeshBuilder> = { + let output: Val<::bevy_mesh::CircularSectorMeshBuilder> = { { - let output: Val< - ::bevy_mesh::primitives::CircularSectorMeshBuilder, - > = ::bevy_mesh::primitives::CircularSectorMeshBuilder::new( + let output: Val<::bevy_mesh::CircularSectorMeshBuilder> = ::bevy_mesh::CircularSectorMeshBuilder::new( sector.into_inner(), ) .into(); @@ -981,15 +1077,10 @@ pub(crate) fn register_circular_sector_mesh_builder_functions(world: &mut World) ) .register_documented( "resolution", - | - _self: Val<::bevy_mesh::primitives::CircularSectorMeshBuilder>, - resolution: u32| - { - let output: Val<::bevy_mesh::primitives::CircularSectorMeshBuilder> = { + |_self: Val<::bevy_mesh::CircularSectorMeshBuilder>, resolution: u32| { + let output: Val<::bevy_mesh::CircularSectorMeshBuilder> = { { - let output: Val< - ::bevy_mesh::primitives::CircularSectorMeshBuilder, - > = ::bevy_mesh::primitives::CircularSectorMeshBuilder::resolution( + let output: Val<::bevy_mesh::CircularSectorMeshBuilder> = ::bevy_mesh::CircularSectorMeshBuilder::resolution( _self.into_inner(), resolution, ) @@ -1005,14 +1096,12 @@ pub(crate) fn register_circular_sector_mesh_builder_functions(world: &mut World) .register_documented( "uv_mode", | - _self: Val<::bevy_mesh::primitives::CircularSectorMeshBuilder>, - uv_mode: Val<::bevy_mesh::primitives::CircularMeshUvMode>| + _self: Val<::bevy_mesh::CircularSectorMeshBuilder>, + uv_mode: Val<::bevy_mesh::CircularMeshUvMode>| { - let output: Val<::bevy_mesh::primitives::CircularSectorMeshBuilder> = { + let output: Val<::bevy_mesh::CircularSectorMeshBuilder> = { { - let output: Val< - ::bevy_mesh::primitives::CircularSectorMeshBuilder, - > = ::bevy_mesh::primitives::CircularSectorMeshBuilder::uv_mode( + let output: Val<::bevy_mesh::CircularSectorMeshBuilder> = ::bevy_mesh::CircularSectorMeshBuilder::uv_mode( _self.into_inner(), uv_mode.into_inner(), ) @@ -1029,22 +1118,20 @@ pub(crate) fn register_circular_sector_mesh_builder_functions(world: &mut World) let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::CircularSectorMeshBuilder, + ::bevy_mesh::CircularSectorMeshBuilder, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_circular_segment_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::CircularSegmentMeshBuilder, + ::bevy_mesh::CircularSegmentMeshBuilder, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_mesh::primitives::CircularSegmentMeshBuilder>| { - let output: Val<::bevy_mesh::primitives::CircularSegmentMeshBuilder> = { + |_self: Ref<::bevy_mesh::CircularSegmentMeshBuilder>| { + let output: Val<::bevy_mesh::CircularSegmentMeshBuilder> = { { - let output: Val< - ::bevy_mesh::primitives::CircularSegmentMeshBuilder, - > = <::bevy_mesh::primitives::CircularSegmentMeshBuilder as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::CircularSegmentMeshBuilder> = <::bevy_mesh::CircularSegmentMeshBuilder as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1059,11 +1146,9 @@ pub(crate) fn register_circular_segment_mesh_builder_functions(world: &mut World .register_documented( "new", |segment: Val<::bevy_math::primitives::CircularSegment>| { - let output: Val<::bevy_mesh::primitives::CircularSegmentMeshBuilder> = { + let output: Val<::bevy_mesh::CircularSegmentMeshBuilder> = { { - let output: Val< - ::bevy_mesh::primitives::CircularSegmentMeshBuilder, - > = ::bevy_mesh::primitives::CircularSegmentMeshBuilder::new( + let output: Val<::bevy_mesh::CircularSegmentMeshBuilder> = ::bevy_mesh::CircularSegmentMeshBuilder::new( segment.into_inner(), ) .into(); @@ -1077,15 +1162,10 @@ pub(crate) fn register_circular_segment_mesh_builder_functions(world: &mut World ) .register_documented( "resolution", - | - _self: Val<::bevy_mesh::primitives::CircularSegmentMeshBuilder>, - resolution: u32| - { - let output: Val<::bevy_mesh::primitives::CircularSegmentMeshBuilder> = { + |_self: Val<::bevy_mesh::CircularSegmentMeshBuilder>, resolution: u32| { + let output: Val<::bevy_mesh::CircularSegmentMeshBuilder> = { { - let output: Val< - ::bevy_mesh::primitives::CircularSegmentMeshBuilder, - > = ::bevy_mesh::primitives::CircularSegmentMeshBuilder::resolution( + let output: Val<::bevy_mesh::CircularSegmentMeshBuilder> = ::bevy_mesh::CircularSegmentMeshBuilder::resolution( _self.into_inner(), resolution, ) @@ -1101,14 +1181,12 @@ pub(crate) fn register_circular_segment_mesh_builder_functions(world: &mut World .register_documented( "uv_mode", | - _self: Val<::bevy_mesh::primitives::CircularSegmentMeshBuilder>, - uv_mode: Val<::bevy_mesh::primitives::CircularMeshUvMode>| + _self: Val<::bevy_mesh::CircularSegmentMeshBuilder>, + uv_mode: Val<::bevy_mesh::CircularMeshUvMode>| { - let output: Val<::bevy_mesh::primitives::CircularSegmentMeshBuilder> = { + let output: Val<::bevy_mesh::CircularSegmentMeshBuilder> = { { - let output: Val< - ::bevy_mesh::primitives::CircularSegmentMeshBuilder, - > = ::bevy_mesh::primitives::CircularSegmentMeshBuilder::uv_mode( + let output: Val<::bevy_mesh::CircularSegmentMeshBuilder> = ::bevy_mesh::CircularSegmentMeshBuilder::uv_mode( _self.into_inner(), uv_mode.into_inner(), ) @@ -1125,22 +1203,20 @@ pub(crate) fn register_circular_segment_mesh_builder_functions(world: &mut World let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::CircularSegmentMeshBuilder, + ::bevy_mesh::CircularSegmentMeshBuilder, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_convex_polygon_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::ConvexPolygonMeshBuilder, + ::bevy_mesh::ConvexPolygonMeshBuilder, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_mesh::primitives::ConvexPolygonMeshBuilder>| { - let output: Val<::bevy_mesh::primitives::ConvexPolygonMeshBuilder> = { + |_self: Ref<::bevy_mesh::ConvexPolygonMeshBuilder>| { + let output: Val<::bevy_mesh::ConvexPolygonMeshBuilder> = { { - let output: Val< - ::bevy_mesh::primitives::ConvexPolygonMeshBuilder, - > = <::bevy_mesh::primitives::ConvexPolygonMeshBuilder as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::ConvexPolygonMeshBuilder> = <::bevy_mesh::ConvexPolygonMeshBuilder as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1156,22 +1232,20 @@ pub(crate) fn register_convex_polygon_mesh_builder_functions(world: &mut World) let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::ConvexPolygonMeshBuilder, + ::bevy_mesh::ConvexPolygonMeshBuilder, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_regular_polygon_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::RegularPolygonMeshBuilder, + ::bevy_mesh::RegularPolygonMeshBuilder, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_mesh::primitives::RegularPolygonMeshBuilder>| { - let output: Val<::bevy_mesh::primitives::RegularPolygonMeshBuilder> = { + |_self: Ref<::bevy_mesh::RegularPolygonMeshBuilder>| { + let output: Val<::bevy_mesh::RegularPolygonMeshBuilder> = { { - let output: Val< - ::bevy_mesh::primitives::RegularPolygonMeshBuilder, - > = <::bevy_mesh::primitives::RegularPolygonMeshBuilder as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::RegularPolygonMeshBuilder> = <::bevy_mesh::RegularPolygonMeshBuilder as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1186,11 +1260,9 @@ pub(crate) fn register_regular_polygon_mesh_builder_functions(world: &mut World) .register_documented( "new", |circumradius: f32, sides: u32| { - let output: Val<::bevy_mesh::primitives::RegularPolygonMeshBuilder> = { + let output: Val<::bevy_mesh::RegularPolygonMeshBuilder> = { { - let output: Val< - ::bevy_mesh::primitives::RegularPolygonMeshBuilder, - > = ::bevy_mesh::primitives::RegularPolygonMeshBuilder::new( + let output: Val<::bevy_mesh::RegularPolygonMeshBuilder> = ::bevy_mesh::RegularPolygonMeshBuilder::new( circumradius, sides, ) @@ -1207,20 +1279,20 @@ pub(crate) fn register_regular_polygon_mesh_builder_functions(world: &mut World) let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::RegularPolygonMeshBuilder, + ::bevy_mesh::RegularPolygonMeshBuilder, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_ellipse_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::EllipseMeshBuilder, + ::bevy_mesh::EllipseMeshBuilder, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_mesh::primitives::EllipseMeshBuilder>| { - let output: Val<::bevy_mesh::primitives::EllipseMeshBuilder> = { + |_self: Ref<::bevy_mesh::EllipseMeshBuilder>| { + let output: Val<::bevy_mesh::EllipseMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::EllipseMeshBuilder> = <::bevy_mesh::primitives::EllipseMeshBuilder as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::EllipseMeshBuilder> = <::bevy_mesh::EllipseMeshBuilder as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1235,9 +1307,9 @@ pub(crate) fn register_ellipse_mesh_builder_functions(world: &mut World) { .register_documented( "new", |half_width: f32, half_height: f32, resolution: u32| { - let output: Val<::bevy_mesh::primitives::EllipseMeshBuilder> = { + let output: Val<::bevy_mesh::EllipseMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::EllipseMeshBuilder> = ::bevy_mesh::primitives::EllipseMeshBuilder::new( + let output: Val<::bevy_mesh::EllipseMeshBuilder> = ::bevy_mesh::EllipseMeshBuilder::new( half_width, half_height, resolution, @@ -1253,10 +1325,10 @@ pub(crate) fn register_ellipse_mesh_builder_functions(world: &mut World) { ) .register_documented( "resolution", - |_self: Val<::bevy_mesh::primitives::EllipseMeshBuilder>, resolution: u32| { - let output: Val<::bevy_mesh::primitives::EllipseMeshBuilder> = { + |_self: Val<::bevy_mesh::EllipseMeshBuilder>, resolution: u32| { + let output: Val<::bevy_mesh::EllipseMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::EllipseMeshBuilder> = ::bevy_mesh::primitives::EllipseMeshBuilder::resolution( + let output: Val<::bevy_mesh::EllipseMeshBuilder> = ::bevy_mesh::EllipseMeshBuilder::resolution( _self.into_inner(), resolution, ) @@ -1273,22 +1345,20 @@ pub(crate) fn register_ellipse_mesh_builder_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::EllipseMeshBuilder, + ::bevy_mesh::EllipseMeshBuilder, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_polyline_2_d_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::Polyline2dMeshBuilder, + ::bevy_mesh::Polyline2dMeshBuilder, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_mesh::primitives::Polyline2dMeshBuilder>| { - let output: Val<::bevy_mesh::primitives::Polyline2dMeshBuilder> = { + |_self: Ref<::bevy_mesh::Polyline2dMeshBuilder>| { + let output: Val<::bevy_mesh::Polyline2dMeshBuilder> = { { - let output: Val< - ::bevy_mesh::primitives::Polyline2dMeshBuilder, - > = <::bevy_mesh::primitives::Polyline2dMeshBuilder as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::Polyline2dMeshBuilder> = <::bevy_mesh::Polyline2dMeshBuilder as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1304,20 +1374,20 @@ pub(crate) fn register_polyline_2_d_mesh_builder_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::Polyline2dMeshBuilder, + ::bevy_mesh::Polyline2dMeshBuilder, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_annulus_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::AnnulusMeshBuilder, + ::bevy_mesh::AnnulusMeshBuilder, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_mesh::primitives::AnnulusMeshBuilder>| { - let output: Val<::bevy_mesh::primitives::AnnulusMeshBuilder> = { + |_self: Ref<::bevy_mesh::AnnulusMeshBuilder>| { + let output: Val<::bevy_mesh::AnnulusMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::AnnulusMeshBuilder> = <::bevy_mesh::primitives::AnnulusMeshBuilder as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::AnnulusMeshBuilder> = <::bevy_mesh::AnnulusMeshBuilder as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1332,9 +1402,9 @@ pub(crate) fn register_annulus_mesh_builder_functions(world: &mut World) { .register_documented( "new", |inner_radius: f32, outer_radius: f32, resolution: u32| { - let output: Val<::bevy_mesh::primitives::AnnulusMeshBuilder> = { + let output: Val<::bevy_mesh::AnnulusMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::AnnulusMeshBuilder> = ::bevy_mesh::primitives::AnnulusMeshBuilder::new( + let output: Val<::bevy_mesh::AnnulusMeshBuilder> = ::bevy_mesh::AnnulusMeshBuilder::new( inner_radius, outer_radius, resolution, @@ -1350,10 +1420,10 @@ pub(crate) fn register_annulus_mesh_builder_functions(world: &mut World) { ) .register_documented( "resolution", - |_self: Val<::bevy_mesh::primitives::AnnulusMeshBuilder>, resolution: u32| { - let output: Val<::bevy_mesh::primitives::AnnulusMeshBuilder> = { + |_self: Val<::bevy_mesh::AnnulusMeshBuilder>, resolution: u32| { + let output: Val<::bevy_mesh::AnnulusMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::AnnulusMeshBuilder> = ::bevy_mesh::primitives::AnnulusMeshBuilder::resolution( + let output: Val<::bevy_mesh::AnnulusMeshBuilder> = ::bevy_mesh::AnnulusMeshBuilder::resolution( _self.into_inner(), resolution, ) @@ -1370,20 +1440,20 @@ pub(crate) fn register_annulus_mesh_builder_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::AnnulusMeshBuilder, + ::bevy_mesh::AnnulusMeshBuilder, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_rhombus_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::RhombusMeshBuilder, + ::bevy_mesh::RhombusMeshBuilder, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_mesh::primitives::RhombusMeshBuilder>| { - let output: Val<::bevy_mesh::primitives::RhombusMeshBuilder> = { + |_self: Ref<::bevy_mesh::RhombusMeshBuilder>| { + let output: Val<::bevy_mesh::RhombusMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::RhombusMeshBuilder> = <::bevy_mesh::primitives::RhombusMeshBuilder as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::RhombusMeshBuilder> = <::bevy_mesh::RhombusMeshBuilder as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1398,9 +1468,9 @@ pub(crate) fn register_rhombus_mesh_builder_functions(world: &mut World) { .register_documented( "new", |horizontal_diagonal: f32, vertical_diagonal: f32| { - let output: Val<::bevy_mesh::primitives::RhombusMeshBuilder> = { + let output: Val<::bevy_mesh::RhombusMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::RhombusMeshBuilder> = ::bevy_mesh::primitives::RhombusMeshBuilder::new( + let output: Val<::bevy_mesh::RhombusMeshBuilder> = ::bevy_mesh::RhombusMeshBuilder::new( horizontal_diagonal, vertical_diagonal, ) @@ -1417,22 +1487,20 @@ pub(crate) fn register_rhombus_mesh_builder_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::RhombusMeshBuilder, + ::bevy_mesh::RhombusMeshBuilder, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_triangle_2_d_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::Triangle2dMeshBuilder, + ::bevy_mesh::Triangle2dMeshBuilder, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_mesh::primitives::Triangle2dMeshBuilder>| { - let output: Val<::bevy_mesh::primitives::Triangle2dMeshBuilder> = { + |_self: Ref<::bevy_mesh::Triangle2dMeshBuilder>| { + let output: Val<::bevy_mesh::Triangle2dMeshBuilder> = { { - let output: Val< - ::bevy_mesh::primitives::Triangle2dMeshBuilder, - > = <::bevy_mesh::primitives::Triangle2dMeshBuilder as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::Triangle2dMeshBuilder> = <::bevy_mesh::Triangle2dMeshBuilder as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1443,25 +1511,44 @@ pub(crate) fn register_triangle_2_d_mesh_builder_functions(world: &mut World) { }, "", &["_self"], + ) + .register_documented( + "new", + |a: Val<::glam::Vec2>, b: Val<::glam::Vec2>, c: Val<::glam::Vec2>| { + let output: Val<::bevy_mesh::Triangle2dMeshBuilder> = { + { + let output: Val<::bevy_mesh::Triangle2dMeshBuilder> = ::bevy_mesh::Triangle2dMeshBuilder::new( + a.into_inner(), + b.into_inner(), + c.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a new [`Triangle2dMeshBuilder`] from the points `a`, `b`, and `c`.", + &["a", "b", "c"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::Triangle2dMeshBuilder, + ::bevy_mesh::Triangle2dMeshBuilder, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_rectangle_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::RectangleMeshBuilder, + ::bevy_mesh::RectangleMeshBuilder, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_mesh::primitives::RectangleMeshBuilder>| { - let output: Val<::bevy_mesh::primitives::RectangleMeshBuilder> = { + |_self: Ref<::bevy_mesh::RectangleMeshBuilder>| { + let output: Val<::bevy_mesh::RectangleMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::RectangleMeshBuilder> = <::bevy_mesh::primitives::RectangleMeshBuilder as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::RectangleMeshBuilder> = <::bevy_mesh::RectangleMeshBuilder as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1476,9 +1563,9 @@ pub(crate) fn register_rectangle_mesh_builder_functions(world: &mut World) { .register_documented( "new", |width: f32, height: f32| { - let output: Val<::bevy_mesh::primitives::RectangleMeshBuilder> = { + let output: Val<::bevy_mesh::RectangleMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::RectangleMeshBuilder> = ::bevy_mesh::primitives::RectangleMeshBuilder::new( + let output: Val<::bevy_mesh::RectangleMeshBuilder> = ::bevy_mesh::RectangleMeshBuilder::new( width, height, ) @@ -1495,20 +1582,20 @@ pub(crate) fn register_rectangle_mesh_builder_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::RectangleMeshBuilder, + ::bevy_mesh::RectangleMeshBuilder, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_capsule_2_d_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::Capsule2dMeshBuilder, + ::bevy_mesh::Capsule2dMeshBuilder, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_mesh::primitives::Capsule2dMeshBuilder>| { - let output: Val<::bevy_mesh::primitives::Capsule2dMeshBuilder> = { + |_self: Ref<::bevy_mesh::Capsule2dMeshBuilder>| { + let output: Val<::bevy_mesh::Capsule2dMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::Capsule2dMeshBuilder> = <::bevy_mesh::primitives::Capsule2dMeshBuilder as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::Capsule2dMeshBuilder> = <::bevy_mesh::Capsule2dMeshBuilder as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1523,9 +1610,9 @@ pub(crate) fn register_capsule_2_d_mesh_builder_functions(world: &mut World) { .register_documented( "new", |radius: f32, length: f32, resolution: u32| { - let output: Val<::bevy_mesh::primitives::Capsule2dMeshBuilder> = { + let output: Val<::bevy_mesh::Capsule2dMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::Capsule2dMeshBuilder> = ::bevy_mesh::primitives::Capsule2dMeshBuilder::new( + let output: Val<::bevy_mesh::Capsule2dMeshBuilder> = ::bevy_mesh::Capsule2dMeshBuilder::new( radius, length, resolution, @@ -1541,10 +1628,10 @@ pub(crate) fn register_capsule_2_d_mesh_builder_functions(world: &mut World) { ) .register_documented( "resolution", - |_self: Val<::bevy_mesh::primitives::Capsule2dMeshBuilder>, resolution: u32| { - let output: Val<::bevy_mesh::primitives::Capsule2dMeshBuilder> = { + |_self: Val<::bevy_mesh::Capsule2dMeshBuilder>, resolution: u32| { + let output: Val<::bevy_mesh::Capsule2dMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::Capsule2dMeshBuilder> = ::bevy_mesh::primitives::Capsule2dMeshBuilder::resolution( + let output: Val<::bevy_mesh::Capsule2dMeshBuilder> = ::bevy_mesh::Capsule2dMeshBuilder::resolution( _self.into_inner(), resolution, ) @@ -1561,50 +1648,49 @@ pub(crate) fn register_capsule_2_d_mesh_builder_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::Capsule2dMeshBuilder, + ::bevy_mesh::Capsule2dMeshBuilder, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_capsule_uv_profile_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::CapsuleUvProfile, + ::bevy_mesh::CapsuleUvProfile, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_mesh::primitives::CapsuleUvProfile>| { - let output: Val<::bevy_mesh::primitives::CapsuleUvProfile> = { - { - let output: Val<::bevy_mesh::primitives::CapsuleUvProfile> = - <::bevy_mesh::primitives::CapsuleUvProfile as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_mesh::CapsuleUvProfile>| { + let output: Val<::bevy_mesh::CapsuleUvProfile> = { + { + let output: Val<::bevy_mesh::CapsuleUvProfile> = <::bevy_mesh::CapsuleUvProfile as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::CapsuleUvProfile, + ::bevy_mesh::CapsuleUvProfile, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_capsule_3_d_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::Capsule3dMeshBuilder, + ::bevy_mesh::Capsule3dMeshBuilder, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_mesh::primitives::Capsule3dMeshBuilder>| { - let output: Val<::bevy_mesh::primitives::Capsule3dMeshBuilder> = { + |_self: Ref<::bevy_mesh::Capsule3dMeshBuilder>| { + let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::Capsule3dMeshBuilder> = <::bevy_mesh::primitives::Capsule3dMeshBuilder as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = <::bevy_mesh::Capsule3dMeshBuilder as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1618,10 +1704,10 @@ pub(crate) fn register_capsule_3_d_mesh_builder_functions(world: &mut World) { ) .register_documented( "latitudes", - |_self: Val<::bevy_mesh::primitives::Capsule3dMeshBuilder>, latitudes: u32| { - let output: Val<::bevy_mesh::primitives::Capsule3dMeshBuilder> = { + |_self: Val<::bevy_mesh::Capsule3dMeshBuilder>, latitudes: u32| { + let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::Capsule3dMeshBuilder> = ::bevy_mesh::primitives::Capsule3dMeshBuilder::latitudes( + let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = ::bevy_mesh::Capsule3dMeshBuilder::latitudes( _self.into_inner(), latitudes, ) @@ -1636,10 +1722,10 @@ pub(crate) fn register_capsule_3_d_mesh_builder_functions(world: &mut World) { ) .register_documented( "longitudes", - |_self: Val<::bevy_mesh::primitives::Capsule3dMeshBuilder>, longitudes: u32| { - let output: Val<::bevy_mesh::primitives::Capsule3dMeshBuilder> = { + |_self: Val<::bevy_mesh::Capsule3dMeshBuilder>, longitudes: u32| { + let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::Capsule3dMeshBuilder> = ::bevy_mesh::primitives::Capsule3dMeshBuilder::longitudes( + let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = ::bevy_mesh::Capsule3dMeshBuilder::longitudes( _self.into_inner(), longitudes, ) @@ -1655,9 +1741,9 @@ pub(crate) fn register_capsule_3_d_mesh_builder_functions(world: &mut World) { .register_documented( "new", |radius: f32, height: f32, longitudes: u32, latitudes: u32| { - let output: Val<::bevy_mesh::primitives::Capsule3dMeshBuilder> = { + let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::Capsule3dMeshBuilder> = ::bevy_mesh::primitives::Capsule3dMeshBuilder::new( + let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = ::bevy_mesh::Capsule3dMeshBuilder::new( radius, height, longitudes, @@ -1674,10 +1760,10 @@ pub(crate) fn register_capsule_3_d_mesh_builder_functions(world: &mut World) { ) .register_documented( "rings", - |_self: Val<::bevy_mesh::primitives::Capsule3dMeshBuilder>, rings: u32| { - let output: Val<::bevy_mesh::primitives::Capsule3dMeshBuilder> = { + |_self: Val<::bevy_mesh::Capsule3dMeshBuilder>, rings: u32| { + let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::Capsule3dMeshBuilder> = ::bevy_mesh::primitives::Capsule3dMeshBuilder::rings( + let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = ::bevy_mesh::Capsule3dMeshBuilder::rings( _self.into_inner(), rings, ) @@ -1693,12 +1779,12 @@ pub(crate) fn register_capsule_3_d_mesh_builder_functions(world: &mut World) { .register_documented( "uv_profile", | - _self: Val<::bevy_mesh::primitives::Capsule3dMeshBuilder>, - uv_profile: Val<::bevy_mesh::primitives::CapsuleUvProfile>| + _self: Val<::bevy_mesh::Capsule3dMeshBuilder>, + uv_profile: Val<::bevy_mesh::CapsuleUvProfile>| { - let output: Val<::bevy_mesh::primitives::Capsule3dMeshBuilder> = { + let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::Capsule3dMeshBuilder> = ::bevy_mesh::primitives::Capsule3dMeshBuilder::uv_profile( + let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = ::bevy_mesh::Capsule3dMeshBuilder::uv_profile( _self.into_inner(), uv_profile.into_inner(), ) @@ -1715,51 +1801,52 @@ pub(crate) fn register_capsule_3_d_mesh_builder_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::Capsule3dMeshBuilder, + ::bevy_mesh::Capsule3dMeshBuilder, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_cone_anchor_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::ConeAnchor, + ::bevy_mesh::ConeAnchor, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_mesh::primitives::ConeAnchor>| { - let output: Val<::bevy_mesh::primitives::ConeAnchor> = { - { - let output: Val<::bevy_mesh::primitives::ConeAnchor> = - <::bevy_mesh::primitives::ConeAnchor as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_mesh::ConeAnchor>| { + let output: Val<::bevy_mesh::ConeAnchor> = { + { + let output: Val<::bevy_mesh::ConeAnchor> = <::bevy_mesh::ConeAnchor as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::ConeAnchor, + ::bevy_mesh::ConeAnchor, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_cone_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::ConeMeshBuilder, + ::bevy_mesh::ConeMeshBuilder, >::new(world) .register_documented( "anchor", | - _self: Val<::bevy_mesh::primitives::ConeMeshBuilder>, - anchor: Val<::bevy_mesh::primitives::ConeAnchor>| + _self: Val<::bevy_mesh::ConeMeshBuilder>, + anchor: Val<::bevy_mesh::ConeAnchor>| { - let output: Val<::bevy_mesh::primitives::ConeMeshBuilder> = { + let output: Val<::bevy_mesh::ConeMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::ConeMeshBuilder> = ::bevy_mesh::primitives::ConeMeshBuilder::anchor( + let output: Val<::bevy_mesh::ConeMeshBuilder> = ::bevy_mesh::ConeMeshBuilder::anchor( _self.into_inner(), anchor.into_inner(), ) @@ -1774,10 +1861,10 @@ pub(crate) fn register_cone_mesh_builder_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_mesh::primitives::ConeMeshBuilder>| { - let output: Val<::bevy_mesh::primitives::ConeMeshBuilder> = { + |_self: Ref<::bevy_mesh::ConeMeshBuilder>| { + let output: Val<::bevy_mesh::ConeMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::ConeMeshBuilder> = <::bevy_mesh::primitives::ConeMeshBuilder as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::ConeMeshBuilder> = <::bevy_mesh::ConeMeshBuilder as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1792,9 +1879,9 @@ pub(crate) fn register_cone_mesh_builder_functions(world: &mut World) { .register_documented( "new", |radius: f32, height: f32, resolution: u32| { - let output: Val<::bevy_mesh::primitives::ConeMeshBuilder> = { + let output: Val<::bevy_mesh::ConeMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::ConeMeshBuilder> = ::bevy_mesh::primitives::ConeMeshBuilder::new( + let output: Val<::bevy_mesh::ConeMeshBuilder> = ::bevy_mesh::ConeMeshBuilder::new( radius, height, resolution, @@ -1810,10 +1897,10 @@ pub(crate) fn register_cone_mesh_builder_functions(world: &mut World) { ) .register_documented( "resolution", - |_self: Val<::bevy_mesh::primitives::ConeMeshBuilder>, resolution: u32| { - let output: Val<::bevy_mesh::primitives::ConeMeshBuilder> = { + |_self: Val<::bevy_mesh::ConeMeshBuilder>, resolution: u32| { + let output: Val<::bevy_mesh::ConeMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::ConeMeshBuilder> = ::bevy_mesh::primitives::ConeMeshBuilder::resolution( + let output: Val<::bevy_mesh::ConeMeshBuilder> = ::bevy_mesh::ConeMeshBuilder::resolution( _self.into_inner(), resolution, ) @@ -1830,22 +1917,20 @@ pub(crate) fn register_cone_mesh_builder_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::ConeMeshBuilder, + ::bevy_mesh::ConeMeshBuilder, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_conical_frustum_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::ConicalFrustumMeshBuilder, + ::bevy_mesh::ConicalFrustumMeshBuilder, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_mesh::primitives::ConicalFrustumMeshBuilder>| { - let output: Val<::bevy_mesh::primitives::ConicalFrustumMeshBuilder> = { + |_self: Ref<::bevy_mesh::ConicalFrustumMeshBuilder>| { + let output: Val<::bevy_mesh::ConicalFrustumMeshBuilder> = { { - let output: Val< - ::bevy_mesh::primitives::ConicalFrustumMeshBuilder, - > = <::bevy_mesh::primitives::ConicalFrustumMeshBuilder as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::ConicalFrustumMeshBuilder> = <::bevy_mesh::ConicalFrustumMeshBuilder as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1860,11 +1945,9 @@ pub(crate) fn register_conical_frustum_mesh_builder_functions(world: &mut World) .register_documented( "new", |radius_top: f32, radius_bottom: f32, height: f32, resolution: u32| { - let output: Val<::bevy_mesh::primitives::ConicalFrustumMeshBuilder> = { + let output: Val<::bevy_mesh::ConicalFrustumMeshBuilder> = { { - let output: Val< - ::bevy_mesh::primitives::ConicalFrustumMeshBuilder, - > = ::bevy_mesh::primitives::ConicalFrustumMeshBuilder::new( + let output: Val<::bevy_mesh::ConicalFrustumMeshBuilder> = ::bevy_mesh::ConicalFrustumMeshBuilder::new( radius_top, radius_bottom, height, @@ -1881,15 +1964,10 @@ pub(crate) fn register_conical_frustum_mesh_builder_functions(world: &mut World) ) .register_documented( "resolution", - | - _self: Val<::bevy_mesh::primitives::ConicalFrustumMeshBuilder>, - resolution: u32| - { - let output: Val<::bevy_mesh::primitives::ConicalFrustumMeshBuilder> = { + |_self: Val<::bevy_mesh::ConicalFrustumMeshBuilder>, resolution: u32| { + let output: Val<::bevy_mesh::ConicalFrustumMeshBuilder> = { { - let output: Val< - ::bevy_mesh::primitives::ConicalFrustumMeshBuilder, - > = ::bevy_mesh::primitives::ConicalFrustumMeshBuilder::resolution( + let output: Val<::bevy_mesh::ConicalFrustumMeshBuilder> = ::bevy_mesh::ConicalFrustumMeshBuilder::resolution( _self.into_inner(), resolution, ) @@ -1904,15 +1982,10 @@ pub(crate) fn register_conical_frustum_mesh_builder_functions(world: &mut World) ) .register_documented( "segments", - | - _self: Val<::bevy_mesh::primitives::ConicalFrustumMeshBuilder>, - segments: u32| - { - let output: Val<::bevy_mesh::primitives::ConicalFrustumMeshBuilder> = { + |_self: Val<::bevy_mesh::ConicalFrustumMeshBuilder>, segments: u32| { + let output: Val<::bevy_mesh::ConicalFrustumMeshBuilder> = { { - let output: Val< - ::bevy_mesh::primitives::ConicalFrustumMeshBuilder, - > = ::bevy_mesh::primitives::ConicalFrustumMeshBuilder::segments( + let output: Val<::bevy_mesh::ConicalFrustumMeshBuilder> = ::bevy_mesh::ConicalFrustumMeshBuilder::segments( _self.into_inner(), segments, ) @@ -1929,83 +2002,81 @@ pub(crate) fn register_conical_frustum_mesh_builder_functions(world: &mut World) let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::ConicalFrustumMeshBuilder, + ::bevy_mesh::ConicalFrustumMeshBuilder, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_cuboid_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::CuboidMeshBuilder, + ::bevy_mesh::CuboidMeshBuilder, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_mesh::primitives::CuboidMeshBuilder>| { - let output: Val<::bevy_mesh::primitives::CuboidMeshBuilder> = { - { - let output: Val<::bevy_mesh::primitives::CuboidMeshBuilder> = - <::bevy_mesh::primitives::CuboidMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_mesh::CuboidMeshBuilder>| { + let output: Val<::bevy_mesh::CuboidMeshBuilder> = { + { + let output: Val<::bevy_mesh::CuboidMeshBuilder> = <::bevy_mesh::CuboidMeshBuilder as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::CuboidMeshBuilder, + ::bevy_mesh::CuboidMeshBuilder, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_cylinder_anchor_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::CylinderAnchor, + ::bevy_mesh::CylinderAnchor, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_mesh::primitives::CylinderAnchor>| { - let output: Val<::bevy_mesh::primitives::CylinderAnchor> = { - { - let output: Val<::bevy_mesh::primitives::CylinderAnchor> = - <::bevy_mesh::primitives::CylinderAnchor as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_mesh::CylinderAnchor>| { + let output: Val<::bevy_mesh::CylinderAnchor> = { + { + let output: Val<::bevy_mesh::CylinderAnchor> = <::bevy_mesh::CylinderAnchor as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::CylinderAnchor, + ::bevy_mesh::CylinderAnchor, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_cylinder_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::CylinderMeshBuilder, + ::bevy_mesh::CylinderMeshBuilder, >::new(world) .register_documented( "anchor", | - _self: Val<::bevy_mesh::primitives::CylinderMeshBuilder>, - anchor: Val<::bevy_mesh::primitives::CylinderAnchor>| + _self: Val<::bevy_mesh::CylinderMeshBuilder>, + anchor: Val<::bevy_mesh::CylinderAnchor>| { - let output: Val<::bevy_mesh::primitives::CylinderMeshBuilder> = { + let output: Val<::bevy_mesh::CylinderMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::CylinderMeshBuilder> = ::bevy_mesh::primitives::CylinderMeshBuilder::anchor( + let output: Val<::bevy_mesh::CylinderMeshBuilder> = ::bevy_mesh::CylinderMeshBuilder::anchor( _self.into_inner(), anchor.into_inner(), ) @@ -2020,10 +2091,10 @@ pub(crate) fn register_cylinder_mesh_builder_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_mesh::primitives::CylinderMeshBuilder>| { - let output: Val<::bevy_mesh::primitives::CylinderMeshBuilder> = { + |_self: Ref<::bevy_mesh::CylinderMeshBuilder>| { + let output: Val<::bevy_mesh::CylinderMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::CylinderMeshBuilder> = <::bevy_mesh::primitives::CylinderMeshBuilder as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::CylinderMeshBuilder> = <::bevy_mesh::CylinderMeshBuilder as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -2038,9 +2109,9 @@ pub(crate) fn register_cylinder_mesh_builder_functions(world: &mut World) { .register_documented( "new", |radius: f32, height: f32, resolution: u32| { - let output: Val<::bevy_mesh::primitives::CylinderMeshBuilder> = { + let output: Val<::bevy_mesh::CylinderMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::CylinderMeshBuilder> = ::bevy_mesh::primitives::CylinderMeshBuilder::new( + let output: Val<::bevy_mesh::CylinderMeshBuilder> = ::bevy_mesh::CylinderMeshBuilder::new( radius, height, resolution, @@ -2056,10 +2127,10 @@ pub(crate) fn register_cylinder_mesh_builder_functions(world: &mut World) { ) .register_documented( "resolution", - |_self: Val<::bevy_mesh::primitives::CylinderMeshBuilder>, resolution: u32| { - let output: Val<::bevy_mesh::primitives::CylinderMeshBuilder> = { + |_self: Val<::bevy_mesh::CylinderMeshBuilder>, resolution: u32| { + let output: Val<::bevy_mesh::CylinderMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::CylinderMeshBuilder> = ::bevy_mesh::primitives::CylinderMeshBuilder::resolution( + let output: Val<::bevy_mesh::CylinderMeshBuilder> = ::bevy_mesh::CylinderMeshBuilder::resolution( _self.into_inner(), resolution, ) @@ -2074,10 +2145,10 @@ pub(crate) fn register_cylinder_mesh_builder_functions(world: &mut World) { ) .register_documented( "segments", - |_self: Val<::bevy_mesh::primitives::CylinderMeshBuilder>, segments: u32| { - let output: Val<::bevy_mesh::primitives::CylinderMeshBuilder> = { + |_self: Val<::bevy_mesh::CylinderMeshBuilder>, segments: u32| { + let output: Val<::bevy_mesh::CylinderMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::CylinderMeshBuilder> = ::bevy_mesh::primitives::CylinderMeshBuilder::segments( + let output: Val<::bevy_mesh::CylinderMeshBuilder> = ::bevy_mesh::CylinderMeshBuilder::segments( _self.into_inner(), segments, ) @@ -2092,10 +2163,10 @@ pub(crate) fn register_cylinder_mesh_builder_functions(world: &mut World) { ) .register_documented( "without_caps", - |_self: Val<::bevy_mesh::primitives::CylinderMeshBuilder>| { - let output: Val<::bevy_mesh::primitives::CylinderMeshBuilder> = { + |_self: Val<::bevy_mesh::CylinderMeshBuilder>| { + let output: Val<::bevy_mesh::CylinderMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::CylinderMeshBuilder> = ::bevy_mesh::primitives::CylinderMeshBuilder::without_caps( + let output: Val<::bevy_mesh::CylinderMeshBuilder> = ::bevy_mesh::CylinderMeshBuilder::without_caps( _self.into_inner(), ) .into(); @@ -2111,20 +2182,20 @@ pub(crate) fn register_cylinder_mesh_builder_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::CylinderMeshBuilder, + ::bevy_mesh::CylinderMeshBuilder, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_plane_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::PlaneMeshBuilder, + ::bevy_mesh::PlaneMeshBuilder, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_mesh::primitives::PlaneMeshBuilder>| { - let output: Val<::bevy_mesh::primitives::PlaneMeshBuilder> = { + |_self: Ref<::bevy_mesh::PlaneMeshBuilder>| { + let output: Val<::bevy_mesh::PlaneMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::PlaneMeshBuilder> = <::bevy_mesh::primitives::PlaneMeshBuilder as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::PlaneMeshBuilder> = <::bevy_mesh::PlaneMeshBuilder as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -2139,9 +2210,9 @@ pub(crate) fn register_plane_mesh_builder_functions(world: &mut World) { .register_documented( "from_length", |length: f32| { - let output: Val<::bevy_mesh::primitives::PlaneMeshBuilder> = { + let output: Val<::bevy_mesh::PlaneMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::PlaneMeshBuilder> = ::bevy_mesh::primitives::PlaneMeshBuilder::from_length( + let output: Val<::bevy_mesh::PlaneMeshBuilder> = ::bevy_mesh::PlaneMeshBuilder::from_length( length, ) .into(); @@ -2153,15 +2224,47 @@ pub(crate) fn register_plane_mesh_builder_functions(world: &mut World) { " Creates a new [`PlaneMeshBuilder`] from the given length, with the normal pointing upwards,\n and the resulting [`PlaneMeshBuilder`] being a square.", &["length"], ) + .register_documented( + "from_size", + |size: Val<::glam::Vec2>| { + let output: Val<::bevy_mesh::PlaneMeshBuilder> = { + { + let output: Val<::bevy_mesh::PlaneMeshBuilder> = ::bevy_mesh::PlaneMeshBuilder::from_size( + size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a new [`PlaneMeshBuilder`] from the given size, with the normal pointing upwards.", + &["size"], + ) + .register_documented( + "new", + |normal: Val<::bevy_math::Dir3>, size: Val<::glam::Vec2>| { + let output: Val<::bevy_mesh::PlaneMeshBuilder> = { + { + let output: Val<::bevy_mesh::PlaneMeshBuilder> = ::bevy_mesh::PlaneMeshBuilder::new( + normal.into_inner(), + size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a new [`PlaneMeshBuilder`] from a given normal and size.", + &["normal", "size"], + ) .register_documented( "normal", - | - _self: Val<::bevy_mesh::primitives::PlaneMeshBuilder>, - normal: Val<::bevy_math::Dir3>| - { - let output: Val<::bevy_mesh::primitives::PlaneMeshBuilder> = { + |_self: Val<::bevy_mesh::PlaneMeshBuilder>, normal: Val<::bevy_math::Dir3>| { + let output: Val<::bevy_mesh::PlaneMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::PlaneMeshBuilder> = ::bevy_mesh::primitives::PlaneMeshBuilder::normal( + let output: Val<::bevy_mesh::PlaneMeshBuilder> = ::bevy_mesh::PlaneMeshBuilder::normal( _self.into_inner(), normal.into_inner(), ) @@ -2176,14 +2279,10 @@ pub(crate) fn register_plane_mesh_builder_functions(world: &mut World) { ) .register_documented( "size", - | - _self: Val<::bevy_mesh::primitives::PlaneMeshBuilder>, - width: f32, - height: f32| - { - let output: Val<::bevy_mesh::primitives::PlaneMeshBuilder> = { + |_self: Val<::bevy_mesh::PlaneMeshBuilder>, width: f32, height: f32| { + let output: Val<::bevy_mesh::PlaneMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::PlaneMeshBuilder> = ::bevy_mesh::primitives::PlaneMeshBuilder::size( + let output: Val<::bevy_mesh::PlaneMeshBuilder> = ::bevy_mesh::PlaneMeshBuilder::size( _self.into_inner(), width, height, @@ -2199,10 +2298,10 @@ pub(crate) fn register_plane_mesh_builder_functions(world: &mut World) { ) .register_documented( "subdivisions", - |_self: Val<::bevy_mesh::primitives::PlaneMeshBuilder>, subdivisions: u32| { - let output: Val<::bevy_mesh::primitives::PlaneMeshBuilder> = { + |_self: Val<::bevy_mesh::PlaneMeshBuilder>, subdivisions: u32| { + let output: Val<::bevy_mesh::PlaneMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::PlaneMeshBuilder> = ::bevy_mesh::primitives::PlaneMeshBuilder::subdivisions( + let output: Val<::bevy_mesh::PlaneMeshBuilder> = ::bevy_mesh::PlaneMeshBuilder::subdivisions( _self.into_inner(), subdivisions, ) @@ -2219,48 +2318,49 @@ pub(crate) fn register_plane_mesh_builder_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::PlaneMeshBuilder, + ::bevy_mesh::PlaneMeshBuilder, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_sphere_kind_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::SphereKind, + ::bevy_mesh::SphereKind, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_mesh::primitives::SphereKind>| { - let output: Val<::bevy_mesh::primitives::SphereKind> = { - { - let output: Val<::bevy_mesh::primitives::SphereKind> = - <::bevy_mesh::primitives::SphereKind as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_mesh::SphereKind>| { + let output: Val<::bevy_mesh::SphereKind> = { + { + let output: Val<::bevy_mesh::SphereKind> = <::bevy_mesh::SphereKind as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::SphereKind, + ::bevy_mesh::SphereKind, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_sphere_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::SphereMeshBuilder, + ::bevy_mesh::SphereMeshBuilder, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_mesh::primitives::SphereMeshBuilder>| { - let output: Val<::bevy_mesh::primitives::SphereMeshBuilder> = { + |_self: Ref<::bevy_mesh::SphereMeshBuilder>| { + let output: Val<::bevy_mesh::SphereMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::SphereMeshBuilder> = <::bevy_mesh::primitives::SphereMeshBuilder as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::SphereMeshBuilder> = <::bevy_mesh::SphereMeshBuilder as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -2275,12 +2375,12 @@ pub(crate) fn register_sphere_mesh_builder_functions(world: &mut World) { .register_documented( "kind", | - _self: Val<::bevy_mesh::primitives::SphereMeshBuilder>, - kind: Val<::bevy_mesh::primitives::SphereKind>| + _self: Val<::bevy_mesh::SphereMeshBuilder>, + kind: Val<::bevy_mesh::SphereKind>| { - let output: Val<::bevy_mesh::primitives::SphereMeshBuilder> = { + let output: Val<::bevy_mesh::SphereMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::SphereMeshBuilder> = ::bevy_mesh::primitives::SphereMeshBuilder::kind( + let output: Val<::bevy_mesh::SphereMeshBuilder> = ::bevy_mesh::SphereMeshBuilder::kind( _self.into_inner(), kind.into_inner(), ) @@ -2295,10 +2395,10 @@ pub(crate) fn register_sphere_mesh_builder_functions(world: &mut World) { ) .register_documented( "new", - |radius: f32, kind: Val<::bevy_mesh::primitives::SphereKind>| { - let output: Val<::bevy_mesh::primitives::SphereMeshBuilder> = { + |radius: f32, kind: Val<::bevy_mesh::SphereKind>| { + let output: Val<::bevy_mesh::SphereMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::SphereMeshBuilder> = ::bevy_mesh::primitives::SphereMeshBuilder::new( + let output: Val<::bevy_mesh::SphereMeshBuilder> = ::bevy_mesh::SphereMeshBuilder::new( radius, kind.into_inner(), ) @@ -2313,14 +2413,10 @@ pub(crate) fn register_sphere_mesh_builder_functions(world: &mut World) { ) .register_documented( "uv", - | - _self: Ref<::bevy_mesh::primitives::SphereMeshBuilder>, - sectors: u32, - stacks: u32| - { - let output: Val<::bevy_mesh::prelude::Mesh> = { + |_self: Ref<::bevy_mesh::SphereMeshBuilder>, sectors: u32, stacks: u32| { + let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::prelude::Mesh> = ::bevy_mesh::primitives::SphereMeshBuilder::uv( + let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::SphereMeshBuilder::uv( &_self, sectors, stacks, @@ -2338,22 +2434,20 @@ pub(crate) fn register_sphere_mesh_builder_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::SphereMeshBuilder, + ::bevy_mesh::SphereMeshBuilder, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_tetrahedron_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::TetrahedronMeshBuilder, + ::bevy_mesh::TetrahedronMeshBuilder, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_mesh::primitives::TetrahedronMeshBuilder>| { - let output: Val<::bevy_mesh::primitives::TetrahedronMeshBuilder> = { + |_self: Ref<::bevy_mesh::TetrahedronMeshBuilder>| { + let output: Val<::bevy_mesh::TetrahedronMeshBuilder> = { { - let output: Val< - ::bevy_mesh::primitives::TetrahedronMeshBuilder, - > = <::bevy_mesh::primitives::TetrahedronMeshBuilder as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::TetrahedronMeshBuilder> = <::bevy_mesh::TetrahedronMeshBuilder as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -2369,20 +2463,20 @@ pub(crate) fn register_tetrahedron_mesh_builder_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::TetrahedronMeshBuilder, + ::bevy_mesh::TetrahedronMeshBuilder, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_torus_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::TorusMeshBuilder, + ::bevy_mesh::TorusMeshBuilder, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_mesh::primitives::TorusMeshBuilder>| { - let output: Val<::bevy_mesh::primitives::TorusMeshBuilder> = { + |_self: Ref<::bevy_mesh::TorusMeshBuilder>| { + let output: Val<::bevy_mesh::TorusMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::TorusMeshBuilder> = <::bevy_mesh::primitives::TorusMeshBuilder as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::TorusMeshBuilder> = <::bevy_mesh::TorusMeshBuilder as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -2396,10 +2490,10 @@ pub(crate) fn register_torus_mesh_builder_functions(world: &mut World) { ) .register_documented( "major_resolution", - |_self: Val<::bevy_mesh::primitives::TorusMeshBuilder>, resolution: usize| { - let output: Val<::bevy_mesh::primitives::TorusMeshBuilder> = { + |_self: Val<::bevy_mesh::TorusMeshBuilder>, resolution: usize| { + let output: Val<::bevy_mesh::TorusMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::TorusMeshBuilder> = ::bevy_mesh::primitives::TorusMeshBuilder::major_resolution( + let output: Val<::bevy_mesh::TorusMeshBuilder> = ::bevy_mesh::TorusMeshBuilder::major_resolution( _self.into_inner(), resolution, ) @@ -2414,10 +2508,10 @@ pub(crate) fn register_torus_mesh_builder_functions(world: &mut World) { ) .register_documented( "minor_resolution", - |_self: Val<::bevy_mesh::primitives::TorusMeshBuilder>, resolution: usize| { - let output: Val<::bevy_mesh::primitives::TorusMeshBuilder> = { + |_self: Val<::bevy_mesh::TorusMeshBuilder>, resolution: usize| { + let output: Val<::bevy_mesh::TorusMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::TorusMeshBuilder> = ::bevy_mesh::primitives::TorusMeshBuilder::minor_resolution( + let output: Val<::bevy_mesh::TorusMeshBuilder> = ::bevy_mesh::TorusMeshBuilder::minor_resolution( _self.into_inner(), resolution, ) @@ -2433,9 +2527,9 @@ pub(crate) fn register_torus_mesh_builder_functions(world: &mut World) { .register_documented( "new", |inner_radius: f32, outer_radius: f32| { - let output: Val<::bevy_mesh::primitives::TorusMeshBuilder> = { + let output: Val<::bevy_mesh::TorusMeshBuilder> = { { - let output: Val<::bevy_mesh::primitives::TorusMeshBuilder> = ::bevy_mesh::primitives::TorusMeshBuilder::new( + let output: Val<::bevy_mesh::TorusMeshBuilder> = ::bevy_mesh::TorusMeshBuilder::new( inner_radius, outer_radius, ) @@ -2452,22 +2546,20 @@ pub(crate) fn register_torus_mesh_builder_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::TorusMeshBuilder, + ::bevy_mesh::TorusMeshBuilder, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_triangle_3_d_mesh_builder_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_mesh::primitives::Triangle3dMeshBuilder, + ::bevy_mesh::Triangle3dMeshBuilder, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_mesh::primitives::Triangle3dMeshBuilder>| { - let output: Val<::bevy_mesh::primitives::Triangle3dMeshBuilder> = { + |_self: Ref<::bevy_mesh::Triangle3dMeshBuilder>| { + let output: Val<::bevy_mesh::Triangle3dMeshBuilder> = { { - let output: Val< - ::bevy_mesh::primitives::Triangle3dMeshBuilder, - > = <::bevy_mesh::primitives::Triangle3dMeshBuilder as ::std::clone::Clone>::clone( + let output: Val<::bevy_mesh::Triangle3dMeshBuilder> = <::bevy_mesh::Triangle3dMeshBuilder as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -2483,7 +2575,7 @@ pub(crate) fn register_triangle_3_d_mesh_builder_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_mesh::primitives::Triangle3dMeshBuilder, + ::bevy_mesh::Triangle3dMeshBuilder, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -2491,22 +2583,23 @@ pub(crate) fn register_skinned_mesh_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_mesh::skinning::SkinnedMesh, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_mesh::skinning::SkinnedMesh>| { - let output: Val<::bevy_mesh::skinning::SkinnedMesh> = { - { - let output: Val<::bevy_mesh::skinning::SkinnedMesh> = - <::bevy_mesh::skinning::SkinnedMesh as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_mesh::skinning::SkinnedMesh>| { + let output: Val<::bevy_mesh::skinning::SkinnedMesh> = { + { + let output: Val<::bevy_mesh::skinning::SkinnedMesh> = <::bevy_mesh::skinning::SkinnedMesh as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry diff --git a/crates/bindings/bevy_pbr_bms_bindings/src/lib.rs b/crates/bindings/bevy_pbr_bms_bindings/src/lib.rs index e15c7d247f..fd19d4469a 100644 --- a/crates/bindings/bevy_pbr_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_pbr_bms_bindings/src/lib.rs @@ -1,55 +1,59 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyPbrScriptingPlugin; pub(crate) fn register_distance_fog_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::prelude::DistanceFog, + ::bevy_pbr::DistanceFog, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::prelude::DistanceFog>| { - let output: Val<::bevy_pbr::prelude::DistanceFog> = { - { - let output: Val<::bevy_pbr::prelude::DistanceFog> = - <::bevy_pbr::prelude::DistanceFog as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_pbr::DistanceFog>| { + let output: Val<::bevy_pbr::DistanceFog> = { + { + let output: Val<::bevy_pbr::DistanceFog> = <::bevy_pbr::DistanceFog as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_pbr::prelude::DistanceFog, + ::bevy_pbr::DistanceFog, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_fog_falloff_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::prelude::FogFalloff, + ::bevy_pbr::FogFalloff, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_pbr::prelude::FogFalloff>| { - let output: Val<::bevy_pbr::prelude::FogFalloff> = { + |_self: Ref<::bevy_pbr::FogFalloff>| { + let output: Val<::bevy_pbr::FogFalloff> = { { - let output: Val<::bevy_pbr::prelude::FogFalloff> = <::bevy_pbr::prelude::FogFalloff as ::std::clone::Clone>::clone( + let output: Val<::bevy_pbr::FogFalloff> = <::bevy_pbr::FogFalloff as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -64,9 +68,9 @@ pub(crate) fn register_fog_falloff_functions(world: &mut World) { .register_documented( "from_visibility", |visibility: f32| { - let output: Val<::bevy_pbr::prelude::FogFalloff> = { + let output: Val<::bevy_pbr::FogFalloff> = { { - let output: Val<::bevy_pbr::prelude::FogFalloff> = ::bevy_pbr::prelude::FogFalloff::from_visibility( + let output: Val<::bevy_pbr::FogFalloff> = ::bevy_pbr::FogFalloff::from_visibility( visibility, ) .into(); @@ -81,9 +85,9 @@ pub(crate) fn register_fog_falloff_functions(world: &mut World) { .register_documented( "from_visibility_color", |visibility: f32, extinction_inscattering_color: Val<::bevy_color::Color>| { - let output: Val<::bevy_pbr::prelude::FogFalloff> = { + let output: Val<::bevy_pbr::FogFalloff> = { { - let output: Val<::bevy_pbr::prelude::FogFalloff> = ::bevy_pbr::prelude::FogFalloff::from_visibility_color( + let output: Val<::bevy_pbr::FogFalloff> = ::bevy_pbr::FogFalloff::from_visibility_color( visibility, extinction_inscattering_color.into_inner(), ) @@ -103,9 +107,9 @@ pub(crate) fn register_fog_falloff_functions(world: &mut World) { extinction_color: Val<::bevy_color::Color>, inscattering_color: Val<::bevy_color::Color>| { - let output: Val<::bevy_pbr::prelude::FogFalloff> = { + let output: Val<::bevy_pbr::FogFalloff> = { { - let output: Val<::bevy_pbr::prelude::FogFalloff> = ::bevy_pbr::prelude::FogFalloff::from_visibility_colors( + let output: Val<::bevy_pbr::FogFalloff> = ::bevy_pbr::FogFalloff::from_visibility_colors( visibility, extinction_color.into_inner(), inscattering_color.into_inner(), @@ -122,9 +126,9 @@ pub(crate) fn register_fog_falloff_functions(world: &mut World) { .register_documented( "from_visibility_contrast", |visibility: f32, contrast_threshold: f32| { - let output: Val<::bevy_pbr::prelude::FogFalloff> = { + let output: Val<::bevy_pbr::FogFalloff> = { { - let output: Val<::bevy_pbr::prelude::FogFalloff> = ::bevy_pbr::prelude::FogFalloff::from_visibility_contrast( + let output: Val<::bevy_pbr::FogFalloff> = ::bevy_pbr::FogFalloff::from_visibility_contrast( visibility, contrast_threshold, ) @@ -144,9 +148,9 @@ pub(crate) fn register_fog_falloff_functions(world: &mut World) { contrast_threshold: f32, extinction_inscattering_color: Val<::bevy_color::Color>| { - let output: Val<::bevy_pbr::prelude::FogFalloff> = { + let output: Val<::bevy_pbr::FogFalloff> = { { - let output: Val<::bevy_pbr::prelude::FogFalloff> = ::bevy_pbr::prelude::FogFalloff::from_visibility_contrast_color( + let output: Val<::bevy_pbr::FogFalloff> = ::bevy_pbr::FogFalloff::from_visibility_contrast_color( visibility, contrast_threshold, extinction_inscattering_color.into_inner(), @@ -168,9 +172,9 @@ pub(crate) fn register_fog_falloff_functions(world: &mut World) { extinction_color: Val<::bevy_color::Color>, inscattering_color: Val<::bevy_color::Color>| { - let output: Val<::bevy_pbr::prelude::FogFalloff> = { + let output: Val<::bevy_pbr::FogFalloff> = { { - let output: Val<::bevy_pbr::prelude::FogFalloff> = ::bevy_pbr::prelude::FogFalloff::from_visibility_contrast_colors( + let output: Val<::bevy_pbr::FogFalloff> = ::bevy_pbr::FogFalloff::from_visibility_contrast_colors( visibility, contrast_threshold, extinction_color.into_inner(), @@ -193,9 +197,9 @@ pub(crate) fn register_fog_falloff_functions(world: &mut World) { .register_documented( "from_visibility_contrast_squared", |visibility: f32, contrast_threshold: f32| { - let output: Val<::bevy_pbr::prelude::FogFalloff> = { + let output: Val<::bevy_pbr::FogFalloff> = { { - let output: Val<::bevy_pbr::prelude::FogFalloff> = ::bevy_pbr::prelude::FogFalloff::from_visibility_contrast_squared( + let output: Val<::bevy_pbr::FogFalloff> = ::bevy_pbr::FogFalloff::from_visibility_contrast_squared( visibility, contrast_threshold, ) @@ -211,9 +215,9 @@ pub(crate) fn register_fog_falloff_functions(world: &mut World) { .register_documented( "from_visibility_squared", |visibility: f32| { - let output: Val<::bevy_pbr::prelude::FogFalloff> = { + let output: Val<::bevy_pbr::FogFalloff> = { { - let output: Val<::bevy_pbr::prelude::FogFalloff> = ::bevy_pbr::prelude::FogFalloff::from_visibility_squared( + let output: Val<::bevy_pbr::FogFalloff> = ::bevy_pbr::FogFalloff::from_visibility_squared( visibility, ) .into(); @@ -230,10 +234,7 @@ pub(crate) fn register_fog_falloff_functions(world: &mut World) { |v: f32, c_t: f32| { let output: f32 = { { - let output: f32 = ::bevy_pbr::prelude::FogFalloff::koschmieder( - v, - c_t, - ) + let output: f32 = ::bevy_pbr::FogFalloff::koschmieder(v, c_t) .into(); output } @@ -247,20 +248,20 @@ pub(crate) fn register_fog_falloff_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_pbr::prelude::FogFalloff, + ::bevy_pbr::FogFalloff, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_parallax_mapping_method_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::prelude::ParallaxMappingMethod, + ::bevy_pbr::ParallaxMappingMethod, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_pbr::prelude::ParallaxMappingMethod>| { + |_self: Ref<::bevy_pbr::ParallaxMappingMethod>| { let output: () = { { - let output: () = <::bevy_pbr::prelude::ParallaxMappingMethod as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_pbr::ParallaxMappingMethod as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -274,10 +275,10 @@ pub(crate) fn register_parallax_mapping_method_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_pbr::prelude::ParallaxMappingMethod>| { - let output: Val<::bevy_pbr::prelude::ParallaxMappingMethod> = { + |_self: Ref<::bevy_pbr::ParallaxMappingMethod>| { + let output: Val<::bevy_pbr::ParallaxMappingMethod> = { { - let output: Val<::bevy_pbr::prelude::ParallaxMappingMethod> = <::bevy_pbr::prelude::ParallaxMappingMethod as ::std::clone::Clone>::clone( + let output: Val<::bevy_pbr::ParallaxMappingMethod> = <::bevy_pbr::ParallaxMappingMethod as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -292,13 +293,13 @@ pub(crate) fn register_parallax_mapping_method_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_pbr::prelude::ParallaxMappingMethod>, - other: Ref<::bevy_pbr::prelude::ParallaxMappingMethod>| + _self: Ref<::bevy_pbr::ParallaxMappingMethod>, + other: Ref<::bevy_pbr::ParallaxMappingMethod>| { let output: bool = { { - let output: bool = <::bevy_pbr::prelude::ParallaxMappingMethod as ::std::cmp::PartialEq< - ::bevy_pbr::prelude::ParallaxMappingMethod, + let output: bool = <::bevy_pbr::ParallaxMappingMethod as ::std::cmp::PartialEq< + ::bevy_pbr::ParallaxMappingMethod, >>::eq(&_self, &other) .into(); output @@ -313,76 +314,78 @@ pub(crate) fn register_parallax_mapping_method_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_pbr::prelude::ParallaxMappingMethod, + ::bevy_pbr::ParallaxMappingMethod, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_standard_material_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_pbr::prelude::StandardMaterial, + ::bevy_pbr::StandardMaterial, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::prelude::StandardMaterial>| { - let output: Val<::bevy_pbr::prelude::StandardMaterial> = { - { - let output: Val<::bevy_pbr::prelude::StandardMaterial> = - <::bevy_pbr::prelude::StandardMaterial as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "flip", - |mut _self: Mut<::bevy_pbr::prelude::StandardMaterial>, - horizontal: bool, - vertical: bool| { - let output: () = { - { - let output: () = ::bevy_pbr::prelude::StandardMaterial::flip( - &mut _self, horizontal, vertical, - ) - .into(); - output - } - }; - output - }, - " Flip the texture coordinates of the material.", - &["_self", "horizontal", "vertical"], - ) - .register_documented( - "flipped", - |_self: Val<::bevy_pbr::prelude::StandardMaterial>, horizontal: bool, vertical: bool| { - let output: Val<::bevy_pbr::prelude::StandardMaterial> = { - { - let output: Val<::bevy_pbr::prelude::StandardMaterial> = - ::bevy_pbr::prelude::StandardMaterial::flipped( - _self.into_inner(), - horizontal, - vertical, - ) - .into(); - output - } - }; - output - }, - " Consumes the material and returns a material with flipped texture coordinates", - &["_self", "horizontal", "vertical"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_pbr::StandardMaterial>| { + let output: Val<::bevy_pbr::StandardMaterial> = { + { + let output: Val<::bevy_pbr::StandardMaterial> = <::bevy_pbr::StandardMaterial as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "flip", + | + mut _self: Mut<::bevy_pbr::StandardMaterial>, + horizontal: bool, + vertical: bool| + { + let output: () = { + { + let output: () = ::bevy_pbr::StandardMaterial::flip( + &mut _self, + horizontal, + vertical, + ) + .into(); + output + } + }; + output + }, + " Flip the texture coordinates of the material.", + &["_self", "horizontal", "vertical"], + ) + .register_documented( + "flipped", + |_self: Val<::bevy_pbr::StandardMaterial>, horizontal: bool, vertical: bool| { + let output: Val<::bevy_pbr::StandardMaterial> = { + { + let output: Val<::bevy_pbr::StandardMaterial> = ::bevy_pbr::StandardMaterial::flipped( + _self.into_inner(), + horizontal, + vertical, + ) + .into(); + output + } + }; + output + }, + " Consumes the material and returns a material with flipped texture coordinates", + &["_self", "horizontal", "vertical"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_pbr::prelude::StandardMaterial, + ::bevy_pbr::StandardMaterial, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -390,43 +393,43 @@ pub(crate) fn register_screen_space_ambient_occlusion_functions(world: &mut Worl bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_pbr::ScreenSpaceAmbientOcclusion, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::ScreenSpaceAmbientOcclusion>| { - let output: Val<::bevy_pbr::ScreenSpaceAmbientOcclusion> = { - { - let output: Val<::bevy_pbr::ScreenSpaceAmbientOcclusion> = - <::bevy_pbr::ScreenSpaceAmbientOcclusion as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_pbr::ScreenSpaceAmbientOcclusion>, - other: Ref<::bevy_pbr::ScreenSpaceAmbientOcclusion>| { - let output: bool = { - { - let output: bool = - <::bevy_pbr::ScreenSpaceAmbientOcclusion as ::std::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_pbr::ScreenSpaceAmbientOcclusion>| { + let output: Val<::bevy_pbr::ScreenSpaceAmbientOcclusion> = { + { + let output: Val<::bevy_pbr::ScreenSpaceAmbientOcclusion> = <::bevy_pbr::ScreenSpaceAmbientOcclusion as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_pbr::ScreenSpaceAmbientOcclusion>, + other: Ref<::bevy_pbr::ScreenSpaceAmbientOcclusion>| + { + let output: bool = { + { + let output: bool = <::bevy_pbr::ScreenSpaceAmbientOcclusion as ::std::cmp::PartialEq< ::bevy_pbr::ScreenSpaceAmbientOcclusion, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -439,22 +442,23 @@ pub(crate) fn register_screen_space_reflections_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_pbr::ScreenSpaceReflections, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::ScreenSpaceReflections>| { - let output: Val<::bevy_pbr::ScreenSpaceReflections> = { - { - let output: Val<::bevy_pbr::ScreenSpaceReflections> = - <::bevy_pbr::ScreenSpaceReflections as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_pbr::ScreenSpaceReflections>| { + let output: Val<::bevy_pbr::ScreenSpaceReflections> = { + { + let output: Val<::bevy_pbr::ScreenSpaceReflections> = <::bevy_pbr::ScreenSpaceReflections as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -467,84 +471,87 @@ pub(crate) fn register_default_opaque_renderer_method_functions(world: &mut Worl bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_pbr::DefaultOpaqueRendererMethod, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::DefaultOpaqueRendererMethod>| { - let output: Val<::bevy_pbr::DefaultOpaqueRendererMethod> = { - { - let output: Val<::bevy_pbr::DefaultOpaqueRendererMethod> = - <::bevy_pbr::DefaultOpaqueRendererMethod as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "deferred", - || { - let output: Val<::bevy_pbr::DefaultOpaqueRendererMethod> = { - { - let output: Val<::bevy_pbr::DefaultOpaqueRendererMethod> = - ::bevy_pbr::DefaultOpaqueRendererMethod::deferred().into(); - output - } - }; - output - }, - "", - &[], - ) - .register_documented( - "forward", - || { - let output: Val<::bevy_pbr::DefaultOpaqueRendererMethod> = { - { - let output: Val<::bevy_pbr::DefaultOpaqueRendererMethod> = - ::bevy_pbr::DefaultOpaqueRendererMethod::forward().into(); - output - } - }; - output - }, - "", - &[], - ) - .register_documented( - "set_to_deferred", - |mut _self: Mut<::bevy_pbr::DefaultOpaqueRendererMethod>| { - let output: () = { - { - let output: () = - ::bevy_pbr::DefaultOpaqueRendererMethod::set_to_deferred(&mut _self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "set_to_forward", - |mut _self: Mut<::bevy_pbr::DefaultOpaqueRendererMethod>| { - let output: () = { - { - let output: () = - ::bevy_pbr::DefaultOpaqueRendererMethod::set_to_forward(&mut _self).into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_pbr::DefaultOpaqueRendererMethod>| { + let output: Val<::bevy_pbr::DefaultOpaqueRendererMethod> = { + { + let output: Val<::bevy_pbr::DefaultOpaqueRendererMethod> = <::bevy_pbr::DefaultOpaqueRendererMethod as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "deferred", + || { + let output: Val<::bevy_pbr::DefaultOpaqueRendererMethod> = { + { + let output: Val<::bevy_pbr::DefaultOpaqueRendererMethod> = ::bevy_pbr::DefaultOpaqueRendererMethod::deferred() + .into(); + output + } + }; + output + }, + "", + &[], + ) + .register_documented( + "forward", + || { + let output: Val<::bevy_pbr::DefaultOpaqueRendererMethod> = { + { + let output: Val<::bevy_pbr::DefaultOpaqueRendererMethod> = ::bevy_pbr::DefaultOpaqueRendererMethod::forward() + .into(); + output + } + }; + output + }, + "", + &[], + ) + .register_documented( + "set_to_deferred", + |mut _self: Mut<::bevy_pbr::DefaultOpaqueRendererMethod>| { + let output: () = { + { + let output: () = ::bevy_pbr::DefaultOpaqueRendererMethod::set_to_deferred( + &mut _self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "set_to_forward", + |mut _self: Mut<::bevy_pbr::DefaultOpaqueRendererMethod>| { + let output: () = { + { + let output: () = ::bevy_pbr::DefaultOpaqueRendererMethod::set_to_forward( + &mut _self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -557,24 +564,23 @@ pub(crate) fn register_wireframe_material_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_pbr::wireframe::WireframeMaterial, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::wireframe::WireframeMaterial>| { - let output: Val<::bevy_pbr::wireframe::WireframeMaterial> = { - { - let output: Val<::bevy_pbr::wireframe::WireframeMaterial> = - <::bevy_pbr::wireframe::WireframeMaterial as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_pbr::wireframe::WireframeMaterial>| { + let output: Val<::bevy_pbr::wireframe::WireframeMaterial> = { + { + let output: Val<::bevy_pbr::wireframe::WireframeMaterial> = <::bevy_pbr::wireframe::WireframeMaterial as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -587,24 +593,23 @@ pub(crate) fn register_wireframe_config_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_pbr::wireframe::WireframeConfig, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::wireframe::WireframeConfig>| { - let output: Val<::bevy_pbr::wireframe::WireframeConfig> = { - { - let output: Val<::bevy_pbr::wireframe::WireframeConfig> = - <::bevy_pbr::wireframe::WireframeConfig as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_pbr::wireframe::WireframeConfig>| { + let output: Val<::bevy_pbr::wireframe::WireframeConfig> = { + { + let output: Val<::bevy_pbr::wireframe::WireframeConfig> = <::bevy_pbr::wireframe::WireframeConfig as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -683,24 +688,23 @@ pub(crate) fn register_wireframe_color_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_pbr::wireframe::WireframeColor, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::wireframe::WireframeColor>| { - let output: Val<::bevy_pbr::wireframe::WireframeColor> = { - { - let output: Val<::bevy_pbr::wireframe::WireframeColor> = - <::bevy_pbr::wireframe::WireframeColor as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_pbr::wireframe::WireframeColor>| { + let output: Val<::bevy_pbr::wireframe::WireframeColor> = { + { + let output: Val<::bevy_pbr::wireframe::WireframeColor> = <::bevy_pbr::wireframe::WireframeColor as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -883,29 +887,32 @@ pub(crate) fn register_atmosphere_functions(world: &mut World) { let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::bevy_pbr::Atmosphere, bevy_mod_scripting_bindings::MarkAsGenerated>( - ); + .register_type_data::< + ::bevy_pbr::Atmosphere, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_gpu_atmosphere_settings_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_pbr::GpuAtmosphereSettings, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::GpuAtmosphereSettings>| { - let output: Val<::bevy_pbr::GpuAtmosphereSettings> = { - { - let output: Val<::bevy_pbr::GpuAtmosphereSettings> = - <::bevy_pbr::GpuAtmosphereSettings as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_pbr::GpuAtmosphereSettings>| { + let output: Val<::bevy_pbr::GpuAtmosphereSettings> = { + { + let output: Val<::bevy_pbr::GpuAtmosphereSettings> = <::bevy_pbr::GpuAtmosphereSettings as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -918,22 +925,23 @@ pub(crate) fn register_atmosphere_settings_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_pbr::AtmosphereSettings, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::AtmosphereSettings>| { - let output: Val<::bevy_pbr::AtmosphereSettings> = { - { - let output: Val<::bevy_pbr::AtmosphereSettings> = - <::bevy_pbr::AtmosphereSettings as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_pbr::AtmosphereSettings>| { + let output: Val<::bevy_pbr::AtmosphereSettings> = { + { + let output: Val<::bevy_pbr::AtmosphereSettings> = <::bevy_pbr::AtmosphereSettings as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -975,24 +983,23 @@ pub(crate) fn register_render_visible_mesh_entities_functions(world: &mut World) bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_pbr::RenderVisibleMeshEntities, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::RenderVisibleMeshEntities>| { - let output: Val<::bevy_pbr::RenderVisibleMeshEntities> = { - { - let output: Val<::bevy_pbr::RenderVisibleMeshEntities> = - <::bevy_pbr::RenderVisibleMeshEntities as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_pbr::RenderVisibleMeshEntities>| { + let output: Val<::bevy_pbr::RenderVisibleMeshEntities> = { + { + let output: Val<::bevy_pbr::RenderVisibleMeshEntities> = <::bevy_pbr::RenderVisibleMeshEntities as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1005,24 +1012,23 @@ pub(crate) fn register_render_cubemap_visible_entities_functions(world: &mut Wor bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_pbr::RenderCubemapVisibleEntities, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::RenderCubemapVisibleEntities>| { - let output: Val<::bevy_pbr::RenderCubemapVisibleEntities> = { - { - let output: Val<::bevy_pbr::RenderCubemapVisibleEntities> = - <::bevy_pbr::RenderCubemapVisibleEntities as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_pbr::RenderCubemapVisibleEntities>| { + let output: Val<::bevy_pbr::RenderCubemapVisibleEntities> = { + { + let output: Val<::bevy_pbr::RenderCubemapVisibleEntities> = <::bevy_pbr::RenderCubemapVisibleEntities as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1035,24 +1041,23 @@ pub(crate) fn register_render_cascades_visible_entities_functions(world: &mut Wo bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_pbr::RenderCascadesVisibleEntities, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::RenderCascadesVisibleEntities>| { - let output: Val<::bevy_pbr::RenderCascadesVisibleEntities> = { - { - let output: Val<::bevy_pbr::RenderCascadesVisibleEntities> = - <::bevy_pbr::RenderCascadesVisibleEntities as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_pbr::RenderCascadesVisibleEntities>| { + let output: Val<::bevy_pbr::RenderCascadesVisibleEntities> = { + { + let output: Val<::bevy_pbr::RenderCascadesVisibleEntities> = <::bevy_pbr::RenderCascadesVisibleEntities as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1077,41 +1082,43 @@ pub(crate) fn register_opaque_renderer_method_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_pbr::OpaqueRendererMethod, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::OpaqueRendererMethod>| { - let output: Val<::bevy_pbr::OpaqueRendererMethod> = { - { - let output: Val<::bevy_pbr::OpaqueRendererMethod> = - <::bevy_pbr::OpaqueRendererMethod as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_pbr::OpaqueRendererMethod>| { + let output: Val<::bevy_pbr::OpaqueRendererMethod> = { + { + let output: Val<::bevy_pbr::OpaqueRendererMethod> = <::bevy_pbr::OpaqueRendererMethod as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_pbr::OpaqueRendererMethod>, - other: Ref<::bevy_pbr::OpaqueRendererMethod>| { - let output: bool = { - { - let output: bool = - <::bevy_pbr::OpaqueRendererMethod as ::std::cmp::PartialEq< + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_pbr::OpaqueRendererMethod>, + other: Ref<::bevy_pbr::OpaqueRendererMethod>| + { + let output: bool = { + { + let output: bool = <::bevy_pbr::OpaqueRendererMethod as ::std::cmp::PartialEq< ::bevy_pbr::OpaqueRendererMethod, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1144,28 +1151,32 @@ pub(crate) fn register_lightmap_functions(world: &mut World) { let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::bevy_pbr::Lightmap, bevy_mod_scripting_bindings::MarkAsGenerated>(); + .register_type_data::< + ::bevy_pbr::Lightmap, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_material_binding_id_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_pbr::MaterialBindingId, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::MaterialBindingId>| { - let output: Val<::bevy_pbr::MaterialBindingId> = { - { - let output: Val<::bevy_pbr::MaterialBindingId> = - <::bevy_pbr::MaterialBindingId as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_pbr::MaterialBindingId>| { + let output: Val<::bevy_pbr::MaterialBindingId> = { + { + let output: Val<::bevy_pbr::MaterialBindingId> = <::bevy_pbr::MaterialBindingId as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1178,41 +1189,43 @@ pub(crate) fn register_material_bind_group_slot_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_pbr::MaterialBindGroupSlot, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_pbr::MaterialBindGroupSlot>| { - let output: Val<::bevy_pbr::MaterialBindGroupSlot> = { - { - let output: Val<::bevy_pbr::MaterialBindGroupSlot> = - <::bevy_pbr::MaterialBindGroupSlot as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_pbr::MaterialBindGroupSlot>| { + let output: Val<::bevy_pbr::MaterialBindGroupSlot> = { + { + let output: Val<::bevy_pbr::MaterialBindGroupSlot> = <::bevy_pbr::MaterialBindGroupSlot as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_pbr::MaterialBindGroupSlot>, - other: Ref<::bevy_pbr::MaterialBindGroupSlot>| { - let output: bool = { - { - let output: bool = - <::bevy_pbr::MaterialBindGroupSlot as ::std::cmp::PartialEq< + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_pbr::MaterialBindGroupSlot>, + other: Ref<::bevy_pbr::MaterialBindGroupSlot>| + { + let output: bool = { + { + let output: bool = <::bevy_pbr::MaterialBindGroupSlot as ::std::cmp::PartialEq< ::bevy_pbr::MaterialBindGroupSlot, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1345,10 +1358,14 @@ pub(crate) fn register_uv_channel_functions(world: &mut World) { let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::bevy_pbr::UvChannel, bevy_mod_scripting_bindings::MarkAsGenerated>( - ); + .register_type_data::< + ::bevy_pbr::UvChannel, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } -pub(crate) fn register_screen_space_ambient_occlusion_quality_level_functions(world: &mut World) { +pub(crate) fn register_screen_space_ambient_occlusion_quality_level_functions( + world: &mut World, +) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_pbr::ScreenSpaceAmbientOcclusionQualityLevel, >::new(world) diff --git a/crates/bindings/bevy_picking_bms_bindings/src/lib.rs b/crates/bindings/bevy_picking_bms_bindings/src/lib.rs index 185673486c..8cbcbc17b1 100644 --- a/crates/bindings/bevy_picking_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_picking_bms_bindings/src/lib.rs @@ -1,55 +1,61 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyPickingScriptingPlugin; pub(crate) fn register_release_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_picking::events::Release, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::events::Release>| { - let output: Val<::bevy_picking::events::Release> = { - { - let output: Val<::bevy_picking::events::Release> = - <::bevy_picking::events::Release as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_picking::events::Release>, - other: Ref<::bevy_picking::events::Release>| { - let output: bool = { - { - let output: bool = <::bevy_picking::events::Release as ::std::cmp::PartialEq< - ::bevy_picking::events::Release, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_picking::events::Release>| { + let output: Val<::bevy_picking::events::Release> = { + { + let output: Val<::bevy_picking::events::Release> = <::bevy_picking::events::Release as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::events::Release>, + other: Ref<::bevy_picking::events::Release>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::events::Release as ::std::cmp::PartialEq< + ::bevy_picking::events::Release, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -60,18 +66,14 @@ pub(crate) fn register_release_functions(world: &mut World) { } pub(crate) fn register_ray_cast_backfaces_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::mesh_picking::ray_cast::RayCastBackfaces, + ::bevy_picking::prelude::RayCastBackfaces, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_picking::mesh_picking::ray_cast::RayCastBackfaces>| { - let output: Val< - ::bevy_picking::mesh_picking::ray_cast::RayCastBackfaces, - > = { + |_self: Ref<::bevy_picking::prelude::RayCastBackfaces>| { + let output: Val<::bevy_picking::prelude::RayCastBackfaces> = { { - let output: Val< - ::bevy_picking::mesh_picking::ray_cast::RayCastBackfaces, - > = <::bevy_picking::mesh_picking::ray_cast::RayCastBackfaces as ::std::clone::Clone>::clone( + let output: Val<::bevy_picking::prelude::RayCastBackfaces> = <::bevy_picking::prelude::RayCastBackfaces as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -87,24 +89,20 @@ pub(crate) fn register_ray_cast_backfaces_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::mesh_picking::ray_cast::RayCastBackfaces, + ::bevy_picking::prelude::RayCastBackfaces, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_ray_cast_visibility_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::mesh_picking::ray_cast::RayCastVisibility, + ::bevy_picking::prelude::RayCastVisibility, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_picking::mesh_picking::ray_cast::RayCastVisibility>| { - let output: Val< - ::bevy_picking::mesh_picking::ray_cast::RayCastVisibility, - > = { + |_self: Ref<::bevy_picking::prelude::RayCastVisibility>| { + let output: Val<::bevy_picking::prelude::RayCastVisibility> = { { - let output: Val< - ::bevy_picking::mesh_picking::ray_cast::RayCastVisibility, - > = <::bevy_picking::mesh_picking::ray_cast::RayCastVisibility as ::std::clone::Clone>::clone( + let output: Val<::bevy_picking::prelude::RayCastVisibility> = <::bevy_picking::prelude::RayCastVisibility as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -120,7 +118,7 @@ pub(crate) fn register_ray_cast_visibility_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::mesh_picking::ray_cast::RayCastVisibility, + ::bevy_picking::prelude::RayCastVisibility, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -235,14 +233,14 @@ pub(crate) fn register_pointer_button_functions(world: &mut World) { } pub(crate) fn register_pickable_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::backend::prelude::Pickable, + ::bevy_picking::Pickable, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_picking::backend::prelude::Pickable>| { + |_self: Ref<::bevy_picking::Pickable>| { let output: () = { { - let output: () = <::bevy_picking::backend::prelude::Pickable as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_picking::Pickable as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -256,10 +254,10 @@ pub(crate) fn register_pickable_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_picking::backend::prelude::Pickable>| { - let output: Val<::bevy_picking::backend::prelude::Pickable> = { + |_self: Ref<::bevy_picking::Pickable>| { + let output: Val<::bevy_picking::Pickable> = { { - let output: Val<::bevy_picking::backend::prelude::Pickable> = <::bevy_picking::backend::prelude::Pickable as ::std::clone::Clone>::clone( + let output: Val<::bevy_picking::Pickable> = <::bevy_picking::Pickable as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -273,14 +271,11 @@ pub(crate) fn register_pickable_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_picking::backend::prelude::Pickable>, - other: Ref<::bevy_picking::backend::prelude::Pickable>| - { + |_self: Ref<::bevy_picking::Pickable>, other: Ref<::bevy_picking::Pickable>| { let output: bool = { { - let output: bool = <::bevy_picking::backend::prelude::Pickable as ::std::cmp::PartialEq< - ::bevy_picking::backend::prelude::Pickable, + let output: bool = <::bevy_picking::Pickable as ::std::cmp::PartialEq< + ::bevy_picking::Pickable, >>::eq(&_self, &other) .into(); output @@ -295,7 +290,7 @@ pub(crate) fn register_pickable_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::backend::prelude::Pickable, + ::bevy_picking::Pickable, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -303,22 +298,23 @@ pub(crate) fn register_picking_settings_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_picking::PickingSettings, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::PickingSettings>| { - let output: Val<::bevy_picking::PickingSettings> = { - { - let output: Val<::bevy_picking::PickingSettings> = - <::bevy_picking::PickingSettings as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_picking::PickingSettings>| { + let output: Val<::bevy_picking::PickingSettings> = { + { + let output: Val<::bevy_picking::PickingSettings> = <::bevy_picking::PickingSettings as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -393,7 +389,7 @@ pub(crate) fn register_pointer_input_functions(world: &mut World) { .register_documented( "new", | - pointer_id: Val<::bevy_picking::backend::prelude::PointerId>, + pointer_id: Val<::bevy_picking::pointer::PointerId>, location: Val<::bevy_picking::pointer::Location>, action: Val<::bevy_picking::pointer::PointerAction>| { @@ -423,14 +419,14 @@ pub(crate) fn register_pointer_input_functions(world: &mut World) { } pub(crate) fn register_pointer_hits_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::backend::prelude::PointerHits, + ::bevy_picking::backend::PointerHits, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_picking::backend::prelude::PointerHits>| { - let output: Val<::bevy_picking::backend::prelude::PointerHits> = { + |_self: Ref<::bevy_picking::backend::PointerHits>| { + let output: Val<::bevy_picking::backend::PointerHits> = { { - let output: Val<::bevy_picking::backend::prelude::PointerHits> = <::bevy_picking::backend::prelude::PointerHits as ::std::clone::Clone>::clone( + let output: Val<::bevy_picking::backend::PointerHits> = <::bevy_picking::backend::PointerHits as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -446,7 +442,7 @@ pub(crate) fn register_pointer_hits_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::backend::prelude::PointerHits, + ::bevy_picking::backend::PointerHits, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -454,39 +450,43 @@ pub(crate) fn register_cancel_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_picking::events::Cancel, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::events::Cancel>| { - let output: Val<::bevy_picking::events::Cancel> = { - { - let output: Val<::bevy_picking::events::Cancel> = - <::bevy_picking::events::Cancel as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_picking::events::Cancel>, other: Ref<::bevy_picking::events::Cancel>| { - let output: bool = { - { - let output: bool = <::bevy_picking::events::Cancel as ::std::cmp::PartialEq< - ::bevy_picking::events::Cancel, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_picking::events::Cancel>| { + let output: Val<::bevy_picking::events::Cancel> = { + { + let output: Val<::bevy_picking::events::Cancel> = <::bevy_picking::events::Cancel as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::events::Cancel>, + other: Ref<::bevy_picking::events::Cancel>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::events::Cancel as ::std::cmp::PartialEq< + ::bevy_picking::events::Cancel, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -499,39 +499,43 @@ pub(crate) fn register_click_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_picking::events::Click, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::events::Click>| { - let output: Val<::bevy_picking::events::Click> = { - { - let output: Val<::bevy_picking::events::Click> = - <::bevy_picking::events::Click as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_picking::events::Click>, other: Ref<::bevy_picking::events::Click>| { - let output: bool = { - { - let output: bool = <::bevy_picking::events::Click as ::std::cmp::PartialEq< - ::bevy_picking::events::Click, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_picking::events::Click>| { + let output: Val<::bevy_picking::events::Click> = { + { + let output: Val<::bevy_picking::events::Click> = <::bevy_picking::events::Click as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::events::Click>, + other: Ref<::bevy_picking::events::Click>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::events::Click as ::std::cmp::PartialEq< + ::bevy_picking::events::Click, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -544,39 +548,43 @@ pub(crate) fn register_press_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_picking::events::Press, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::events::Press>| { - let output: Val<::bevy_picking::events::Press> = { - { - let output: Val<::bevy_picking::events::Press> = - <::bevy_picking::events::Press as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_picking::events::Press>, other: Ref<::bevy_picking::events::Press>| { - let output: bool = { - { - let output: bool = <::bevy_picking::events::Press as ::std::cmp::PartialEq< - ::bevy_picking::events::Press, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_picking::events::Press>| { + let output: Val<::bevy_picking::events::Press> = { + { + let output: Val<::bevy_picking::events::Press> = <::bevy_picking::events::Press as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::events::Press>, + other: Ref<::bevy_picking::events::Press>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::events::Press as ::std::cmp::PartialEq< + ::bevy_picking::events::Press, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -589,41 +597,43 @@ pub(crate) fn register_drag_drop_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_picking::events::DragDrop, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::events::DragDrop>| { - let output: Val<::bevy_picking::events::DragDrop> = { - { - let output: Val<::bevy_picking::events::DragDrop> = - <::bevy_picking::events::DragDrop as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_picking::events::DragDrop>, - other: Ref<::bevy_picking::events::DragDrop>| { - let output: bool = { - { - let output: bool = - <::bevy_picking::events::DragDrop as ::std::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_picking::events::DragDrop>| { + let output: Val<::bevy_picking::events::DragDrop> = { + { + let output: Val<::bevy_picking::events::DragDrop> = <::bevy_picking::events::DragDrop as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::events::DragDrop>, + other: Ref<::bevy_picking::events::DragDrop>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::events::DragDrop as ::std::cmp::PartialEq< ::bevy_picking::events::DragDrop, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -636,40 +646,43 @@ pub(crate) fn register_drag_end_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_picking::events::DragEnd, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::events::DragEnd>| { - let output: Val<::bevy_picking::events::DragEnd> = { - { - let output: Val<::bevy_picking::events::DragEnd> = - <::bevy_picking::events::DragEnd as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_picking::events::DragEnd>, - other: Ref<::bevy_picking::events::DragEnd>| { - let output: bool = { - { - let output: bool = <::bevy_picking::events::DragEnd as ::std::cmp::PartialEq< - ::bevy_picking::events::DragEnd, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_picking::events::DragEnd>| { + let output: Val<::bevy_picking::events::DragEnd> = { + { + let output: Val<::bevy_picking::events::DragEnd> = <::bevy_picking::events::DragEnd as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::events::DragEnd>, + other: Ref<::bevy_picking::events::DragEnd>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::events::DragEnd as ::std::cmp::PartialEq< + ::bevy_picking::events::DragEnd, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -682,41 +695,43 @@ pub(crate) fn register_drag_enter_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_picking::events::DragEnter, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::events::DragEnter>| { - let output: Val<::bevy_picking::events::DragEnter> = { - { - let output: Val<::bevy_picking::events::DragEnter> = - <::bevy_picking::events::DragEnter as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_picking::events::DragEnter>, - other: Ref<::bevy_picking::events::DragEnter>| { - let output: bool = { - { - let output: bool = - <::bevy_picking::events::DragEnter as ::std::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_picking::events::DragEnter>| { + let output: Val<::bevy_picking::events::DragEnter> = { + { + let output: Val<::bevy_picking::events::DragEnter> = <::bevy_picking::events::DragEnter as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::events::DragEnter>, + other: Ref<::bevy_picking::events::DragEnter>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::events::DragEnter as ::std::cmp::PartialEq< ::bevy_picking::events::DragEnter, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -729,90 +744,97 @@ pub(crate) fn register_drag_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_picking::events::Drag, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::events::Drag>| { - let output: Val<::bevy_picking::events::Drag> = { - { - let output: Val<::bevy_picking::events::Drag> = - <::bevy_picking::events::Drag as ::std::clone::Clone>::clone(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_picking::events::Drag>, other: Ref<::bevy_picking::events::Drag>| { - let output: bool = { - { - let output: bool = <::bevy_picking::events::Drag as ::std::cmp::PartialEq< - ::bevy_picking::events::Drag, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_picking::events::Drag, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_drag_leave_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::events::DragLeave, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::events::DragLeave>| { - let output: Val<::bevy_picking::events::DragLeave> = { - { - let output: Val<::bevy_picking::events::DragLeave> = - <::bevy_picking::events::DragLeave as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_picking::events::DragLeave>, - other: Ref<::bevy_picking::events::DragLeave>| { - let output: bool = { - { - let output: bool = - <::bevy_picking::events::DragLeave as ::std::cmp::PartialEq< - ::bevy_picking::events::DragLeave, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_picking::events::DragLeave, + .register_documented( + "clone", + |_self: Ref<::bevy_picking::events::Drag>| { + let output: Val<::bevy_picking::events::Drag> = { + { + let output: Val<::bevy_picking::events::Drag> = <::bevy_picking::events::Drag as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::events::Drag>, + other: Ref<::bevy_picking::events::Drag>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::events::Drag as ::std::cmp::PartialEq< + ::bevy_picking::events::Drag, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_picking::events::Drag, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_drag_leave_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_picking::events::DragLeave, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_picking::events::DragLeave>| { + let output: Val<::bevy_picking::events::DragLeave> = { + { + let output: Val<::bevy_picking::events::DragLeave> = <::bevy_picking::events::DragLeave as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::events::DragLeave>, + other: Ref<::bevy_picking::events::DragLeave>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::events::DragLeave as ::std::cmp::PartialEq< + ::bevy_picking::events::DragLeave, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_picking::events::DragLeave, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -820,41 +842,43 @@ pub(crate) fn register_drag_over_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_picking::events::DragOver, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::events::DragOver>| { - let output: Val<::bevy_picking::events::DragOver> = { - { - let output: Val<::bevy_picking::events::DragOver> = - <::bevy_picking::events::DragOver as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_picking::events::DragOver>, - other: Ref<::bevy_picking::events::DragOver>| { - let output: bool = { - { - let output: bool = - <::bevy_picking::events::DragOver as ::std::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_picking::events::DragOver>| { + let output: Val<::bevy_picking::events::DragOver> = { + { + let output: Val<::bevy_picking::events::DragOver> = <::bevy_picking::events::DragOver as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::events::DragOver>, + other: Ref<::bevy_picking::events::DragOver>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::events::DragOver as ::std::cmp::PartialEq< ::bevy_picking::events::DragOver, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -867,41 +891,43 @@ pub(crate) fn register_drag_start_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_picking::events::DragStart, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::events::DragStart>| { - let output: Val<::bevy_picking::events::DragStart> = { - { - let output: Val<::bevy_picking::events::DragStart> = - <::bevy_picking::events::DragStart as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_picking::events::DragStart>, - other: Ref<::bevy_picking::events::DragStart>| { - let output: bool = { - { - let output: bool = - <::bevy_picking::events::DragStart as ::std::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_picking::events::DragStart>| { + let output: Val<::bevy_picking::events::DragStart> = { + { + let output: Val<::bevy_picking::events::DragStart> = <::bevy_picking::events::DragStart as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::events::DragStart>, + other: Ref<::bevy_picking::events::DragStart>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::events::DragStart as ::std::cmp::PartialEq< ::bevy_picking::events::DragStart, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -914,38 +940,43 @@ pub(crate) fn register_move_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_picking::events::Move, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::events::Move>| { - let output: Val<::bevy_picking::events::Move> = { - { - let output: Val<::bevy_picking::events::Move> = - <::bevy_picking::events::Move as ::std::clone::Clone>::clone(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_picking::events::Move>, other: Ref<::bevy_picking::events::Move>| { - let output: bool = { - { - let output: bool = <::bevy_picking::events::Move as ::std::cmp::PartialEq< - ::bevy_picking::events::Move, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_picking::events::Move>| { + let output: Val<::bevy_picking::events::Move> = { + { + let output: Val<::bevy_picking::events::Move> = <::bevy_picking::events::Move as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::events::Move>, + other: Ref<::bevy_picking::events::Move>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::events::Move as ::std::cmp::PartialEq< + ::bevy_picking::events::Move, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1007,38 +1038,43 @@ pub(crate) fn register_over_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_picking::events::Over, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::events::Over>| { - let output: Val<::bevy_picking::events::Over> = { - { - let output: Val<::bevy_picking::events::Over> = - <::bevy_picking::events::Over as ::std::clone::Clone>::clone(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_picking::events::Over>, other: Ref<::bevy_picking::events::Over>| { - let output: bool = { - { - let output: bool = <::bevy_picking::events::Over as ::std::cmp::PartialEq< - ::bevy_picking::events::Over, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_picking::events::Over>| { + let output: Val<::bevy_picking::events::Over> = { + { + let output: Val<::bevy_picking::events::Over> = <::bevy_picking::events::Over as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::events::Over>, + other: Ref<::bevy_picking::events::Over>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::events::Over as ::std::cmp::PartialEq< + ::bevy_picking::events::Over, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1051,39 +1087,43 @@ pub(crate) fn register_scroll_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_picking::events::Scroll, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::events::Scroll>| { - let output: Val<::bevy_picking::events::Scroll> = { - { - let output: Val<::bevy_picking::events::Scroll> = - <::bevy_picking::events::Scroll as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_picking::events::Scroll>, other: Ref<::bevy_picking::events::Scroll>| { - let output: bool = { - { - let output: bool = <::bevy_picking::events::Scroll as ::std::cmp::PartialEq< - ::bevy_picking::events::Scroll, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_picking::events::Scroll>| { + let output: Val<::bevy_picking::events::Scroll> = { + { + let output: Val<::bevy_picking::events::Scroll> = <::bevy_picking::events::Scroll as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::events::Scroll>, + other: Ref<::bevy_picking::events::Scroll>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::events::Scroll as ::std::cmp::PartialEq< + ::bevy_picking::events::Scroll, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1094,63 +1134,63 @@ pub(crate) fn register_scroll_functions(world: &mut World) { } pub(crate) fn register_hit_data_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::backend::prelude::HitData, + ::bevy_picking::backend::HitData, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::backend::prelude::HitData>| { - let output: Val<::bevy_picking::backend::prelude::HitData> = { - { - let output: Val<::bevy_picking::backend::prelude::HitData> = - <::bevy_picking::backend::prelude::HitData as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_picking::backend::prelude::HitData>, - other: Ref<::bevy_picking::backend::prelude::HitData>| { - let output: bool = { - { - let output: bool = - <::bevy_picking::backend::prelude::HitData as ::std::cmp::PartialEq< - ::bevy_picking::backend::prelude::HitData, + .register_documented( + "clone", + |_self: Ref<::bevy_picking::backend::HitData>| { + let output: Val<::bevy_picking::backend::HitData> = { + { + let output: Val<::bevy_picking::backend::HitData> = <::bevy_picking::backend::HitData as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::backend::HitData>, + other: Ref<::bevy_picking::backend::HitData>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::backend::HitData as ::std::cmp::PartialEq< + ::bevy_picking::backend::HitData, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::backend::prelude::HitData, + ::bevy_picking::backend::HitData, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_pointer_id_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::backend::prelude::PointerId, + ::bevy_picking::pointer::PointerId, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_picking::backend::prelude::PointerId>| { + |_self: Ref<::bevy_picking::pointer::PointerId>| { let output: () = { { - let output: () = <::bevy_picking::backend::prelude::PointerId as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_picking::pointer::PointerId as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -1164,10 +1204,10 @@ pub(crate) fn register_pointer_id_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_picking::backend::prelude::PointerId>| { - let output: Val<::bevy_picking::backend::prelude::PointerId> = { + |_self: Ref<::bevy_picking::pointer::PointerId>| { + let output: Val<::bevy_picking::pointer::PointerId> = { { - let output: Val<::bevy_picking::backend::prelude::PointerId> = <::bevy_picking::backend::prelude::PointerId as ::std::clone::Clone>::clone( + let output: Val<::bevy_picking::pointer::PointerId> = <::bevy_picking::pointer::PointerId as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1182,13 +1222,13 @@ pub(crate) fn register_pointer_id_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_picking::backend::prelude::PointerId>, - other: Ref<::bevy_picking::backend::prelude::PointerId>| + _self: Ref<::bevy_picking::pointer::PointerId>, + other: Ref<::bevy_picking::pointer::PointerId>| { let output: bool = { { - let output: bool = <::bevy_picking::backend::prelude::PointerId as ::std::cmp::PartialEq< - ::bevy_picking::backend::prelude::PointerId, + let output: bool = <::bevy_picking::pointer::PointerId as ::std::cmp::PartialEq< + ::bevy_picking::pointer::PointerId, >>::eq(&_self, &other) .into(); output @@ -1201,10 +1241,10 @@ pub(crate) fn register_pointer_id_functions(world: &mut World) { ) .register_documented( "get_touch_id", - |_self: Ref<::bevy_picking::backend::prelude::PointerId>| { + |_self: Ref<::bevy_picking::pointer::PointerId>| { let output: ::std::option::Option = { { - let output: ::std::option::Option = ::bevy_picking::backend::prelude::PointerId::get_touch_id( + let output: ::std::option::Option = ::bevy_picking::pointer::PointerId::get_touch_id( &_self, ) .into(); @@ -1218,10 +1258,10 @@ pub(crate) fn register_pointer_id_functions(world: &mut World) { ) .register_documented( "is_custom", - |_self: Ref<::bevy_picking::backend::prelude::PointerId>| { + |_self: Ref<::bevy_picking::pointer::PointerId>| { let output: bool = { { - let output: bool = ::bevy_picking::backend::prelude::PointerId::is_custom( + let output: bool = ::bevy_picking::pointer::PointerId::is_custom( &_self, ) .into(); @@ -1235,10 +1275,10 @@ pub(crate) fn register_pointer_id_functions(world: &mut World) { ) .register_documented( "is_mouse", - |_self: Ref<::bevy_picking::backend::prelude::PointerId>| { + |_self: Ref<::bevy_picking::pointer::PointerId>| { let output: bool = { { - let output: bool = ::bevy_picking::backend::prelude::PointerId::is_mouse( + let output: bool = ::bevy_picking::pointer::PointerId::is_mouse( &_self, ) .into(); @@ -1252,10 +1292,10 @@ pub(crate) fn register_pointer_id_functions(world: &mut World) { ) .register_documented( "is_touch", - |_self: Ref<::bevy_picking::backend::prelude::PointerId>| { + |_self: Ref<::bevy_picking::pointer::PointerId>| { let output: bool = { { - let output: bool = ::bevy_picking::backend::prelude::PointerId::is_touch( + let output: bool = ::bevy_picking::pointer::PointerId::is_touch( &_self, ) .into(); @@ -1271,22 +1311,20 @@ pub(crate) fn register_pointer_id_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::backend::prelude::PointerId, + ::bevy_picking::pointer::PointerId, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_pointer_location_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_picking::backend::prelude::PointerLocation, + ::bevy_picking::pointer::PointerLocation, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_picking::backend::prelude::PointerLocation>| { - let output: Val<::bevy_picking::backend::prelude::PointerLocation> = { + |_self: Ref<::bevy_picking::pointer::PointerLocation>| { + let output: Val<::bevy_picking::pointer::PointerLocation> = { { - let output: Val< - ::bevy_picking::backend::prelude::PointerLocation, - > = <::bevy_picking::backend::prelude::PointerLocation as ::std::clone::Clone>::clone( + let output: Val<::bevy_picking::pointer::PointerLocation> = <::bevy_picking::pointer::PointerLocation as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1301,13 +1339,13 @@ pub(crate) fn register_pointer_location_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_picking::backend::prelude::PointerLocation>, - other: Ref<::bevy_picking::backend::prelude::PointerLocation>| + _self: Ref<::bevy_picking::pointer::PointerLocation>, + other: Ref<::bevy_picking::pointer::PointerLocation>| { let output: bool = { { - let output: bool = <::bevy_picking::backend::prelude::PointerLocation as ::std::cmp::PartialEq< - ::bevy_picking::backend::prelude::PointerLocation, + let output: bool = <::bevy_picking::pointer::PointerLocation as ::std::cmp::PartialEq< + ::bevy_picking::pointer::PointerLocation, >>::eq(&_self, &other) .into(); output @@ -1321,11 +1359,9 @@ pub(crate) fn register_pointer_location_functions(world: &mut World) { .register_documented( "new", |location: Val<::bevy_picking::pointer::Location>| { - let output: Val<::bevy_picking::backend::prelude::PointerLocation> = { + let output: Val<::bevy_picking::pointer::PointerLocation> = { { - let output: Val< - ::bevy_picking::backend::prelude::PointerLocation, - > = ::bevy_picking::backend::prelude::PointerLocation::new( + let output: Val<::bevy_picking::pointer::PointerLocation> = ::bevy_picking::pointer::PointerLocation::new( location.into_inner(), ) .into(); @@ -1341,7 +1377,7 @@ pub(crate) fn register_pointer_location_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_picking::backend::prelude::PointerLocation, + ::bevy_picking::pointer::PointerLocation, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -1407,7 +1443,7 @@ pub(crate) fn register_ray_id_functions(world: &mut World) { "new", | camera: Val<::bevy_ecs::entity::Entity>, - pointer: Val<::bevy_picking::backend::prelude::PointerId>| + pointer: Val<::bevy_picking::pointer::PointerId>| { let output: Val<::bevy_picking::backend::ray::RayId> = { { @@ -1436,41 +1472,43 @@ pub(crate) fn register_location_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_picking::pointer::Location, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::pointer::Location>| { - let output: Val<::bevy_picking::pointer::Location> = { - { - let output: Val<::bevy_picking::pointer::Location> = - <::bevy_picking::pointer::Location as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_picking::pointer::Location>, - other: Ref<::bevy_picking::pointer::Location>| { - let output: bool = { - { - let output: bool = - <::bevy_picking::pointer::Location as ::std::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_picking::pointer::Location>| { + let output: Val<::bevy_picking::pointer::Location> = { + { + let output: Val<::bevy_picking::pointer::Location> = <::bevy_picking::pointer::Location as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::pointer::Location>, + other: Ref<::bevy_picking::pointer::Location>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::pointer::Location as ::std::cmp::PartialEq< ::bevy_picking::pointer::Location, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1483,24 +1521,23 @@ pub(crate) fn register_pointer_action_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_picking::pointer::PointerAction, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::pointer::PointerAction>| { - let output: Val<::bevy_picking::pointer::PointerAction> = { - { - let output: Val<::bevy_picking::pointer::PointerAction> = - <::bevy_picking::pointer::PointerAction as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_picking::pointer::PointerAction>| { + let output: Val<::bevy_picking::pointer::PointerAction> = { + { + let output: Val<::bevy_picking::pointer::PointerAction> = <::bevy_picking::pointer::PointerAction as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1513,41 +1550,43 @@ pub(crate) fn register_drag_entry_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_picking::events::DragEntry, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_picking::events::DragEntry>| { - let output: Val<::bevy_picking::events::DragEntry> = { - { - let output: Val<::bevy_picking::events::DragEntry> = - <::bevy_picking::events::DragEntry as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_picking::events::DragEntry>, - other: Ref<::bevy_picking::events::DragEntry>| { - let output: bool = { - { - let output: bool = - <::bevy_picking::events::DragEntry as ::std::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_picking::events::DragEntry>| { + let output: Val<::bevy_picking::events::DragEntry> = { + { + let output: Val<::bevy_picking::events::DragEntry> = <::bevy_picking::events::DragEntry as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_picking::events::DragEntry>, + other: Ref<::bevy_picking::events::DragEntry>| + { + let output: bool = { + { + let output: bool = <::bevy_picking::events::DragEntry as ::std::cmp::PartialEq< ::bevy_picking::events::DragEntry, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry diff --git a/crates/bindings/bevy_post_process_bms_bindings/src/lib.rs b/crates/bindings/bevy_post_process_bms_bindings/src/lib.rs index ac0cb0ad90..676f86d74b 100644 --- a/crates/bindings/bevy_post_process_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_post_process_bms_bindings/src/lib.rs @@ -1,15 +1,18 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyPostProcessScriptingPlugin; pub(crate) fn register_auto_exposure_compensation_curve_functions(world: &mut World) { @@ -84,22 +87,23 @@ pub(crate) fn register_bloom_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_post_process::bloom::Bloom, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_post_process::bloom::Bloom>| { - let output: Val<::bevy_post_process::bloom::Bloom> = { - { - let output: Val<::bevy_post_process::bloom::Bloom> = - <::bevy_post_process::bloom::Bloom as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_post_process::bloom::Bloom>| { + let output: Val<::bevy_post_process::bloom::Bloom> = { + { + let output: Val<::bevy_post_process::bloom::Bloom> = <::bevy_post_process::bloom::Bloom as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -180,24 +184,23 @@ pub(crate) fn register_bloom_prefilter_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_post_process::bloom::BloomPrefilter, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_post_process::bloom::BloomPrefilter>| { - let output: Val<::bevy_post_process::bloom::BloomPrefilter> = { - { - let output: Val<::bevy_post_process::bloom::BloomPrefilter> = - <::bevy_post_process::bloom::BloomPrefilter as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_post_process::bloom::BloomPrefilter>| { + let output: Val<::bevy_post_process::bloom::BloomPrefilter> = { + { + let output: Val<::bevy_post_process::bloom::BloomPrefilter> = <::bevy_post_process::bloom::BloomPrefilter as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -210,24 +213,23 @@ pub(crate) fn register_depth_of_field_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_post_process::dof::DepthOfField, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_post_process::dof::DepthOfField>| { - let output: Val<::bevy_post_process::dof::DepthOfField> = { - { - let output: Val<::bevy_post_process::dof::DepthOfField> = - <::bevy_post_process::dof::DepthOfField as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_post_process::dof::DepthOfField>| { + let output: Val<::bevy_post_process::dof::DepthOfField> = { + { + let output: Val<::bevy_post_process::dof::DepthOfField> = <::bevy_post_process::dof::DepthOfField as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -240,43 +242,43 @@ pub(crate) fn register_depth_of_field_mode_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_post_process::dof::DepthOfFieldMode, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_post_process::dof::DepthOfFieldMode>| { - let output: Val<::bevy_post_process::dof::DepthOfFieldMode> = { - { - let output: Val<::bevy_post_process::dof::DepthOfFieldMode> = - <::bevy_post_process::dof::DepthOfFieldMode as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_post_process::dof::DepthOfFieldMode>, - other: Ref<::bevy_post_process::dof::DepthOfFieldMode>| { - let output: bool = { - { - let output: bool = - <::bevy_post_process::dof::DepthOfFieldMode as ::std::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_post_process::dof::DepthOfFieldMode>| { + let output: Val<::bevy_post_process::dof::DepthOfFieldMode> = { + { + let output: Val<::bevy_post_process::dof::DepthOfFieldMode> = <::bevy_post_process::dof::DepthOfFieldMode as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_post_process::dof::DepthOfFieldMode>, + other: Ref<::bevy_post_process::dof::DepthOfFieldMode>| + { + let output: bool = { + { + let output: bool = <::bevy_post_process::dof::DepthOfFieldMode as ::std::cmp::PartialEq< ::bevy_post_process::dof::DepthOfFieldMode, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry diff --git a/crates/bindings/bevy_reflect_bms_bindings/Cargo.toml b/crates/bindings/bevy_reflect_bms_bindings/Cargo.toml index 3c7eeb6b2a..825d0daa6c 100644 --- a/crates/bindings/bevy_reflect_bms_bindings/Cargo.toml +++ b/crates/bindings/bevy_reflect_bms_bindings/Cargo.toml @@ -17,16 +17,16 @@ bevy_app = { workspace = true, features = ["std"] } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_bindings = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -bevy_reflect = { version = "0.17.2", features = ["glam", "uuid", "smol_str", "std", "smallvec", "debug", "auto_register_inventory", "debug_stack", "auto_register"], default-features = true} +bevy_reflect = { version = "0.17.2", features = ["auto_register", "auto_register_inventory", "debug", "debug_stack", "glam", "smallvec", "smol_str", "std", "uuid"], default-features = true} assert_type_match = { version = "^0.1.1", features = [], default-features = true} -bevy_platform = { version = "^0.17.2", features = ["std", "alloc", "serialize"], default-features = true} +bevy_platform = { version = "^0.17.2", features = ["alloc", "serialize", "std"], default-features = true} bevy_ptr = { version = "^0.17.2", features = [], default-features = true} -bevy_reflect_derive = { version = "^0.17.2", features = ["auto_register_inventory", "auto_register"], default-features = true} +bevy_reflect_derive = { version = "^0.17.2", features = ["auto_register", "auto_register_inventory"], default-features = true} downcast-rs = { version = "^2", features = ["std"], default-features = false} diff --git a/crates/bindings/bevy_render_bms_bindings/src/lib.rs b/crates/bindings/bevy_render_bms_bindings/src/lib.rs index 2fdb6b509d..646fc37c29 100644 --- a/crates/bindings/bevy_render_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_render_bms_bindings/src/lib.rs @@ -1,55 +1,61 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyRenderScriptingPlugin; pub(crate) fn register_alpha_mode_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_render::alpha::AlphaMode, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::alpha::AlphaMode>| { - let output: Val<::bevy_render::alpha::AlphaMode> = { - { - let output: Val<::bevy_render::alpha::AlphaMode> = - <::bevy_render::alpha::AlphaMode as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_render::alpha::AlphaMode>, - other: Ref<::bevy_render::alpha::AlphaMode>| { - let output: bool = { - { - let output: bool = <::bevy_render::alpha::AlphaMode as ::std::cmp::PartialEq< - ::bevy_render::alpha::AlphaMode, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_render::alpha::AlphaMode>| { + let output: Val<::bevy_render::alpha::AlphaMode> = { + { + let output: Val<::bevy_render::alpha::AlphaMode> = <::bevy_render::alpha::AlphaMode as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_render::alpha::AlphaMode>, + other: Ref<::bevy_render::alpha::AlphaMode>| + { + let output: bool = { + { + let output: bool = <::bevy_render::alpha::AlphaMode as ::std::cmp::PartialEq< + ::bevy_render::alpha::AlphaMode, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -503,18 +509,14 @@ pub(crate) fn register_hdr_functions(world: &mut World) { } pub(crate) fn register_render_visible_entities_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::view::visibility::RenderVisibleEntities, + ::bevy_render::view::RenderVisibleEntities, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_render::view::visibility::RenderVisibleEntities>| { - let output: Val< - ::bevy_render::view::visibility::RenderVisibleEntities, - > = { + |_self: Ref<::bevy_render::view::RenderVisibleEntities>| { + let output: Val<::bevy_render::view::RenderVisibleEntities> = { { - let output: Val< - ::bevy_render::view::visibility::RenderVisibleEntities, - > = <::bevy_render::view::visibility::RenderVisibleEntities as ::std::clone::Clone>::clone( + let output: Val<::bevy_render::view::RenderVisibleEntities> = <::bevy_render::view::RenderVisibleEntities as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -530,7 +532,7 @@ pub(crate) fn register_render_visible_entities_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_render::view::visibility::RenderVisibleEntities, + ::bevy_render::view::RenderVisibleEntities, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -538,24 +540,23 @@ pub(crate) fn register_camera_render_graph_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_render::camera::CameraRenderGraph, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::camera::CameraRenderGraph>| { - let output: Val<::bevy_render::camera::CameraRenderGraph> = { - { - let output: Val<::bevy_render::camera::CameraRenderGraph> = - <::bevy_render::camera::CameraRenderGraph as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_render::camera::CameraRenderGraph>| { + let output: Val<::bevy_render::camera::CameraRenderGraph> = { + { + let output: Val<::bevy_render::camera::CameraRenderGraph> = <::bevy_render::camera::CameraRenderGraph as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -568,24 +569,46 @@ pub(crate) fn register_temporal_jitter_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_render::camera::TemporalJitter, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::camera::TemporalJitter>| { - let output: Val<::bevy_render::camera::TemporalJitter> = { - { - let output: Val<::bevy_render::camera::TemporalJitter> = - <::bevy_render::camera::TemporalJitter as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_render::camera::TemporalJitter>| { + let output: Val<::bevy_render::camera::TemporalJitter> = { + { + let output: Val<::bevy_render::camera::TemporalJitter> = <::bevy_render::camera::TemporalJitter as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "jitter_projection", + | + _self: Ref<::bevy_render::camera::TemporalJitter>, + mut clip_from_view: Mut<::glam::Mat4>, + view_size: Val<::glam::Vec2>| + { + let output: () = { + { + let output: () = ::bevy_render::camera::TemporalJitter::jitter_projection( + &_self, + &mut clip_from_view, + view_size.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "clip_from_view", "view_size"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -598,22 +621,23 @@ pub(crate) fn register_mip_bias_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_render::camera::MipBias, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::camera::MipBias>| { - let output: Val<::bevy_render::camera::MipBias> = { - { - let output: Val<::bevy_render::camera::MipBias> = - <::bevy_render::camera::MipBias as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_render::camera::MipBias>| { + let output: Val<::bevy_render::camera::MipBias> = { + { + let output: Val<::bevy_render::camera::MipBias> = <::bevy_render::camera::MipBias as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -626,24 +650,23 @@ pub(crate) fn register_globals_uniform_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_render::globals::GlobalsUniform, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::globals::GlobalsUniform>| { - let output: Val<::bevy_render::globals::GlobalsUniform> = { - { - let output: Val<::bevy_render::globals::GlobalsUniform> = - <::bevy_render::globals::GlobalsUniform as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_render::globals::GlobalsUniform>| { + let output: Val<::bevy_render::globals::GlobalsUniform> = { + { + let output: Val<::bevy_render::globals::GlobalsUniform> = <::bevy_render::globals::GlobalsUniform as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -746,24 +769,23 @@ pub(crate) fn register_color_grading_global_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_render::view::ColorGradingGlobal, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::view::ColorGradingGlobal>| { - let output: Val<::bevy_render::view::ColorGradingGlobal> = { - { - let output: Val<::bevy_render::view::ColorGradingGlobal> = - <::bevy_render::view::ColorGradingGlobal as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_render::view::ColorGradingGlobal>| { + let output: Val<::bevy_render::view::ColorGradingGlobal> = { + { + let output: Val<::bevy_render::view::ColorGradingGlobal> = <::bevy_render::view::ColorGradingGlobal as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -776,43 +798,43 @@ pub(crate) fn register_color_grading_section_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_render::view::ColorGradingSection, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_render::view::ColorGradingSection>| { - let output: Val<::bevy_render::view::ColorGradingSection> = { - { - let output: Val<::bevy_render::view::ColorGradingSection> = - <::bevy_render::view::ColorGradingSection as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_render::view::ColorGradingSection>, - other: Ref<::bevy_render::view::ColorGradingSection>| { - let output: bool = { - { - let output: bool = - <::bevy_render::view::ColorGradingSection as ::std::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_render::view::ColorGradingSection>| { + let output: Val<::bevy_render::view::ColorGradingSection> = { + { + let output: Val<::bevy_render::view::ColorGradingSection> = <::bevy_render::view::ColorGradingSection as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_render::view::ColorGradingSection>, + other: Ref<::bevy_render::view::ColorGradingSection>| + { + let output: bool = { + { + let output: bool = <::bevy_render::view::ColorGradingSection as ::std::cmp::PartialEq< ::bevy_render::view::ColorGradingSection, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -823,77 +845,74 @@ pub(crate) fn register_color_grading_section_functions(world: &mut World) { } pub(crate) fn register_screenshot_captured_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::view::window::screenshot::ScreenshotCaptured, + ::bevy_render::view::screenshot::ScreenshotCaptured, >::new(world); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_render::view::window::screenshot::ScreenshotCaptured, + ::bevy_render::view::screenshot::ScreenshotCaptured, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_screenshot_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_render::view::window::screenshot::Screenshot, + ::bevy_render::view::screenshot::Screenshot, >::new(world) - .register_documented( - "primary_window", - || { - let output: Val<::bevy_render::view::window::screenshot::Screenshot> = { - { - let output: Val<::bevy_render::view::window::screenshot::Screenshot> = - ::bevy_render::view::window::screenshot::Screenshot::primary_window() - .into(); - output - } - }; - output - }, - " Capture a screenshot of the primary window, if one exists.", - &[], - ) - .register_documented( - "texture_view", - |texture_view: Val<::bevy_camera::ManualTextureViewHandle>| { - let output: Val<::bevy_render::view::window::screenshot::Screenshot> = { - { - let output: Val<::bevy_render::view::window::screenshot::Screenshot> = - ::bevy_render::view::window::screenshot::Screenshot::texture_view( - texture_view.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Capture a screenshot of the provided manual texture view.", - &["texture_view"], - ) - .register_documented( - "window", - |window: Val<::bevy_ecs::entity::Entity>| { - let output: Val<::bevy_render::view::window::screenshot::Screenshot> = { - { - let output: Val<::bevy_render::view::window::screenshot::Screenshot> = - ::bevy_render::view::window::screenshot::Screenshot::window( - window.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Capture a screenshot of the provided window entity.", - &["window"], - ); + .register_documented( + "primary_window", + || { + let output: Val<::bevy_render::view::screenshot::Screenshot> = { + { + let output: Val<::bevy_render::view::screenshot::Screenshot> = ::bevy_render::view::screenshot::Screenshot::primary_window() + .into(); + output + } + }; + output + }, + " Capture a screenshot of the primary window, if one exists.", + &[], + ) + .register_documented( + "texture_view", + |texture_view: Val<::bevy_camera::ManualTextureViewHandle>| { + let output: Val<::bevy_render::view::screenshot::Screenshot> = { + { + let output: Val<::bevy_render::view::screenshot::Screenshot> = ::bevy_render::view::screenshot::Screenshot::texture_view( + texture_view.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Capture a screenshot of the provided manual texture view.", + &["texture_view"], + ) + .register_documented( + "window", + |window: Val<::bevy_ecs::entity::Entity>| { + let output: Val<::bevy_render::view::screenshot::Screenshot> = { + { + let output: Val<::bevy_render::view::screenshot::Screenshot> = ::bevy_render::view::screenshot::Screenshot::window( + window.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Capture a screenshot of the provided window entity.", + &["window"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_render::view::window::screenshot::Screenshot, + ::bevy_render::view::screenshot::Screenshot, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } diff --git a/crates/bindings/bevy_scene_bms_bindings/src/lib.rs b/crates/bindings/bevy_scene_bms_bindings/src/lib.rs index 3ca1da2c6e..20fa0b4e58 100644 --- a/crates/bindings/bevy_scene_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_scene_bms_bindings/src/lib.rs @@ -1,27 +1,30 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevySceneScriptingPlugin; pub(crate) fn register_dynamic_scene_root_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_scene::prelude::DynamicSceneRoot, + ::bevy_scene::DynamicSceneRoot, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_scene::prelude::DynamicSceneRoot>| { + |_self: Ref<::bevy_scene::DynamicSceneRoot>| { let output: () = { { - let output: () = <::bevy_scene::prelude::DynamicSceneRoot as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_scene::DynamicSceneRoot as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -35,10 +38,10 @@ pub(crate) fn register_dynamic_scene_root_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_scene::prelude::DynamicSceneRoot>| { - let output: Val<::bevy_scene::prelude::DynamicSceneRoot> = { + |_self: Ref<::bevy_scene::DynamicSceneRoot>| { + let output: Val<::bevy_scene::DynamicSceneRoot> = { { - let output: Val<::bevy_scene::prelude::DynamicSceneRoot> = <::bevy_scene::prelude::DynamicSceneRoot as ::std::clone::Clone>::clone( + let output: Val<::bevy_scene::DynamicSceneRoot> = <::bevy_scene::DynamicSceneRoot as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -53,13 +56,13 @@ pub(crate) fn register_dynamic_scene_root_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_scene::prelude::DynamicSceneRoot>, - other: Ref<::bevy_scene::prelude::DynamicSceneRoot>| + _self: Ref<::bevy_scene::DynamicSceneRoot>, + other: Ref<::bevy_scene::DynamicSceneRoot>| { let output: bool = { { - let output: bool = <::bevy_scene::prelude::DynamicSceneRoot as ::std::cmp::PartialEq< - ::bevy_scene::prelude::DynamicSceneRoot, + let output: bool = <::bevy_scene::DynamicSceneRoot as ::std::cmp::PartialEq< + ::bevy_scene::DynamicSceneRoot, >>::eq(&_self, &other) .into(); output @@ -74,20 +77,20 @@ pub(crate) fn register_dynamic_scene_root_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_scene::prelude::DynamicSceneRoot, + ::bevy_scene::DynamicSceneRoot, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_scene_root_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_scene::prelude::SceneRoot, + ::bevy_scene::SceneRoot, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_scene::prelude::SceneRoot>| { + |_self: Ref<::bevy_scene::SceneRoot>| { let output: () = { { - let output: () = <::bevy_scene::prelude::SceneRoot as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_scene::SceneRoot as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -101,10 +104,10 @@ pub(crate) fn register_scene_root_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_scene::prelude::SceneRoot>| { - let output: Val<::bevy_scene::prelude::SceneRoot> = { + |_self: Ref<::bevy_scene::SceneRoot>| { + let output: Val<::bevy_scene::SceneRoot> = { { - let output: Val<::bevy_scene::prelude::SceneRoot> = <::bevy_scene::prelude::SceneRoot as ::std::clone::Clone>::clone( + let output: Val<::bevy_scene::SceneRoot> = <::bevy_scene::SceneRoot as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -118,14 +121,11 @@ pub(crate) fn register_scene_root_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_scene::prelude::SceneRoot>, - other: Ref<::bevy_scene::prelude::SceneRoot>| - { + |_self: Ref<::bevy_scene::SceneRoot>, other: Ref<::bevy_scene::SceneRoot>| { let output: bool = { { - let output: bool = <::bevy_scene::prelude::SceneRoot as ::std::cmp::PartialEq< - ::bevy_scene::prelude::SceneRoot, + let output: bool = <::bevy_scene::SceneRoot as ::std::cmp::PartialEq< + ::bevy_scene::SceneRoot, >>::eq(&_self, &other) .into(); output @@ -140,7 +140,7 @@ pub(crate) fn register_scene_root_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_scene::prelude::SceneRoot, + ::bevy_scene::SceneRoot, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } diff --git a/crates/bindings/bevy_sprite_bms_bindings/src/lib.rs b/crates/bindings/bevy_sprite_bms_bindings/src/lib.rs index 03c8955388..a6fddab100 100644 --- a/crates/bindings/bevy_sprite_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_sprite_bms_bindings/src/lib.rs @@ -1,27 +1,30 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevySpriteScriptingPlugin; pub(crate) fn register_sprite_picking_camera_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_sprite::prelude::SpritePickingCamera, + ::bevy_sprite::SpritePickingCamera, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_sprite::prelude::SpritePickingCamera>| { - let output: Val<::bevy_sprite::prelude::SpritePickingCamera> = { + |_self: Ref<::bevy_sprite::SpritePickingCamera>| { + let output: Val<::bevy_sprite::SpritePickingCamera> = { { - let output: Val<::bevy_sprite::prelude::SpritePickingCamera> = <::bevy_sprite::prelude::SpritePickingCamera as ::std::clone::Clone>::clone( + let output: Val<::bevy_sprite::SpritePickingCamera> = <::bevy_sprite::SpritePickingCamera as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -37,118 +40,136 @@ pub(crate) fn register_sprite_picking_camera_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_sprite::prelude::SpritePickingCamera, + ::bevy_sprite::SpritePickingCamera, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_sprite_picking_mode_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_sprite::prelude::SpritePickingMode, + ::bevy_sprite::SpritePickingMode, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_sprite::prelude::SpritePickingMode>| { - let output: Val<::bevy_sprite::prelude::SpritePickingMode> = { - { - let output: Val<::bevy_sprite::prelude::SpritePickingMode> = - <::bevy_sprite::prelude::SpritePickingMode as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_sprite::SpritePickingMode>| { + let output: Val<::bevy_sprite::SpritePickingMode> = { + { + let output: Val<::bevy_sprite::SpritePickingMode> = <::bevy_sprite::SpritePickingMode as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_sprite::prelude::SpritePickingMode, + ::bevy_sprite::SpritePickingMode, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_sprite_picking_settings_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_sprite::prelude::SpritePickingSettings, + ::bevy_sprite::SpritePickingSettings, >::new(world); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_sprite::prelude::SpritePickingSettings, + ::bevy_sprite::SpritePickingSettings, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_text_2_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_sprite::prelude::Text2d, + ::bevy_sprite::Text2d, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_sprite::prelude::Text2d>| { - let output: Val<::bevy_sprite::prelude::Text2d> = { - { - let output: Val<::bevy_sprite::prelude::Text2d> = - <::bevy_sprite::prelude::Text2d as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_sprite::Text2d>| { + let output: Val<::bevy_sprite::Text2d> = { + { + let output: Val<::bevy_sprite::Text2d> = <::bevy_sprite::Text2d as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_sprite::prelude::Text2d, + ::bevy_sprite::Text2d, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_sprite_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_sprite::prelude::Sprite, + ::bevy_sprite::Sprite, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_sprite::prelude::Sprite>| { - let output: Val<::bevy_sprite::prelude::Sprite> = { - { - let output: Val<::bevy_sprite::prelude::Sprite> = - <::bevy_sprite::prelude::Sprite as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_sprite::Sprite>| { + let output: Val<::bevy_sprite::Sprite> = { + { + let output: Val<::bevy_sprite::Sprite> = <::bevy_sprite::Sprite as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "sized", + |custom_size: Val<::glam::Vec2>| { + let output: Val<::bevy_sprite::Sprite> = { + { + let output: Val<::bevy_sprite::Sprite> = ::bevy_sprite::Sprite::sized( + custom_size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a Sprite with a custom size", + &["custom_size"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_sprite::prelude::Sprite, + ::bevy_sprite::Sprite, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_sprite_image_mode_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_sprite::prelude::SpriteImageMode, + ::bevy_sprite::SpriteImageMode, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_sprite::prelude::SpriteImageMode>| { - let output: Val<::bevy_sprite::prelude::SpriteImageMode> = { + |_self: Ref<::bevy_sprite::SpriteImageMode>| { + let output: Val<::bevy_sprite::SpriteImageMode> = { { - let output: Val<::bevy_sprite::prelude::SpriteImageMode> = <::bevy_sprite::prelude::SpriteImageMode as ::std::clone::Clone>::clone( + let output: Val<::bevy_sprite::SpriteImageMode> = <::bevy_sprite::SpriteImageMode as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -163,13 +184,13 @@ pub(crate) fn register_sprite_image_mode_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_sprite::prelude::SpriteImageMode>, - other: Ref<::bevy_sprite::prelude::SpriteImageMode>| + _self: Ref<::bevy_sprite::SpriteImageMode>, + other: Ref<::bevy_sprite::SpriteImageMode>| { let output: bool = { { - let output: bool = <::bevy_sprite::prelude::SpriteImageMode as ::std::cmp::PartialEq< - ::bevy_sprite::prelude::SpriteImageMode, + let output: bool = <::bevy_sprite::SpriteImageMode as ::std::cmp::PartialEq< + ::bevy_sprite::SpriteImageMode, >>::eq(&_self, &other) .into(); output @@ -182,10 +203,10 @@ pub(crate) fn register_sprite_image_mode_functions(world: &mut World) { ) .register_documented( "uses_slices", - |_self: Ref<::bevy_sprite::prelude::SpriteImageMode>| { + |_self: Ref<::bevy_sprite::SpriteImageMode>| { let output: bool = { { - let output: bool = ::bevy_sprite::prelude::SpriteImageMode::uses_slices( + let output: bool = ::bevy_sprite::SpriteImageMode::uses_slices( &_self, ) .into(); @@ -201,24 +222,21 @@ pub(crate) fn register_sprite_image_mode_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_sprite::prelude::SpriteImageMode, + ::bevy_sprite::SpriteImageMode, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_border_rect_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_sprite::prelude::BorderRect, + ::bevy_sprite::BorderRect, >::new(world) .register_documented( "add", - | - _self: Val<::bevy_sprite::prelude::BorderRect>, - rhs: Val<::bevy_sprite::prelude::BorderRect>| - { - let output: Val<::bevy_sprite::prelude::BorderRect> = { + |_self: Val<::bevy_sprite::BorderRect>, rhs: Val<::bevy_sprite::BorderRect>| { + let output: Val<::bevy_sprite::BorderRect> = { { - let output: Val<::bevy_sprite::prelude::BorderRect> = <::bevy_sprite::prelude::BorderRect as ::std::ops::Add< - ::bevy_sprite::prelude::BorderRect, + let output: Val<::bevy_sprite::BorderRect> = <::bevy_sprite::BorderRect as ::std::ops::Add< + ::bevy_sprite::BorderRect, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output @@ -232,9 +250,9 @@ pub(crate) fn register_border_rect_functions(world: &mut World) { .register_documented( "all", |extent: f32| { - let output: Val<::bevy_sprite::prelude::BorderRect> = { + let output: Val<::bevy_sprite::BorderRect> = { { - let output: Val<::bevy_sprite::prelude::BorderRect> = ::bevy_sprite::prelude::BorderRect::all( + let output: Val<::bevy_sprite::BorderRect> = ::bevy_sprite::BorderRect::all( extent, ) .into(); @@ -249,9 +267,9 @@ pub(crate) fn register_border_rect_functions(world: &mut World) { .register_documented( "axes", |horizontal: f32, vertical: f32| { - let output: Val<::bevy_sprite::prelude::BorderRect> = { + let output: Val<::bevy_sprite::BorderRect> = { { - let output: Val<::bevy_sprite::prelude::BorderRect> = ::bevy_sprite::prelude::BorderRect::axes( + let output: Val<::bevy_sprite::BorderRect> = ::bevy_sprite::BorderRect::axes( horizontal, vertical, ) @@ -266,10 +284,10 @@ pub(crate) fn register_border_rect_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_sprite::prelude::BorderRect>| { - let output: Val<::bevy_sprite::prelude::BorderRect> = { + |_self: Ref<::bevy_sprite::BorderRect>| { + let output: Val<::bevy_sprite::BorderRect> = { { - let output: Val<::bevy_sprite::prelude::BorderRect> = <::bevy_sprite::prelude::BorderRect as ::std::clone::Clone>::clone( + let output: Val<::bevy_sprite::BorderRect> = <::bevy_sprite::BorderRect as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -283,10 +301,10 @@ pub(crate) fn register_border_rect_functions(world: &mut World) { ) .register_documented( "div", - |_self: Val<::bevy_sprite::prelude::BorderRect>, rhs: f32| { - let output: Val<::bevy_sprite::prelude::BorderRect> = { + |_self: Val<::bevy_sprite::BorderRect>, rhs: f32| { + let output: Val<::bevy_sprite::BorderRect> = { { - let output: Val<::bevy_sprite::prelude::BorderRect> = <::bevy_sprite::prelude::BorderRect as ::std::ops::Div< + let output: Val<::bevy_sprite::BorderRect> = <::bevy_sprite::BorderRect as ::std::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -301,13 +319,13 @@ pub(crate) fn register_border_rect_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_sprite::prelude::BorderRect>, - other: Ref<::bevy_sprite::prelude::BorderRect>| + _self: Ref<::bevy_sprite::BorderRect>, + other: Ref<::bevy_sprite::BorderRect>| { let output: bool = { { - let output: bool = <::bevy_sprite::prelude::BorderRect as ::std::cmp::PartialEq< - ::bevy_sprite::prelude::BorderRect, + let output: bool = <::bevy_sprite::BorderRect as ::std::cmp::PartialEq< + ::bevy_sprite::BorderRect, >>::eq(&_self, &other) .into(); output @@ -320,10 +338,10 @@ pub(crate) fn register_border_rect_functions(world: &mut World) { ) .register_documented( "mul", - |_self: Val<::bevy_sprite::prelude::BorderRect>, rhs: f32| { - let output: Val<::bevy_sprite::prelude::BorderRect> = { + |_self: Val<::bevy_sprite::BorderRect>, rhs: f32| { + let output: Val<::bevy_sprite::BorderRect> = { { - let output: Val<::bevy_sprite::prelude::BorderRect> = <::bevy_sprite::prelude::BorderRect as ::std::ops::Mul< + let output: Val<::bevy_sprite::BorderRect> = <::bevy_sprite::BorderRect as ::std::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -337,14 +355,11 @@ pub(crate) fn register_border_rect_functions(world: &mut World) { ) .register_documented( "sub", - | - _self: Val<::bevy_sprite::prelude::BorderRect>, - rhs: Val<::bevy_sprite::prelude::BorderRect>| - { - let output: Val<::bevy_sprite::prelude::BorderRect> = { + |_self: Val<::bevy_sprite::BorderRect>, rhs: Val<::bevy_sprite::BorderRect>| { + let output: Val<::bevy_sprite::BorderRect> = { { - let output: Val<::bevy_sprite::prelude::BorderRect> = <::bevy_sprite::prelude::BorderRect as ::std::ops::Sub< - ::bevy_sprite::prelude::BorderRect, + let output: Val<::bevy_sprite::BorderRect> = <::bevy_sprite::BorderRect as ::std::ops::Sub< + ::bevy_sprite::BorderRect, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output @@ -359,152 +374,154 @@ pub(crate) fn register_border_rect_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_sprite::prelude::BorderRect, + ::bevy_sprite::BorderRect, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_slice_scale_mode_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_sprite::prelude::SliceScaleMode, + ::bevy_sprite::SliceScaleMode, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_sprite::prelude::SliceScaleMode>| { - let output: Val<::bevy_sprite::prelude::SliceScaleMode> = { - { - let output: Val<::bevy_sprite::prelude::SliceScaleMode> = - <::bevy_sprite::prelude::SliceScaleMode as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_sprite::prelude::SliceScaleMode>, - other: Ref<::bevy_sprite::prelude::SliceScaleMode>| { - let output: bool = { - { - let output: bool = - <::bevy_sprite::prelude::SliceScaleMode as ::std::cmp::PartialEq< - ::bevy_sprite::prelude::SliceScaleMode, + .register_documented( + "clone", + |_self: Ref<::bevy_sprite::SliceScaleMode>| { + let output: Val<::bevy_sprite::SliceScaleMode> = { + { + let output: Val<::bevy_sprite::SliceScaleMode> = <::bevy_sprite::SliceScaleMode as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_sprite::SliceScaleMode>, + other: Ref<::bevy_sprite::SliceScaleMode>| + { + let output: bool = { + { + let output: bool = <::bevy_sprite::SliceScaleMode as ::std::cmp::PartialEq< + ::bevy_sprite::SliceScaleMode, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_sprite::prelude::SliceScaleMode, + ::bevy_sprite::SliceScaleMode, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_texture_slicer_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_sprite::prelude::TextureSlicer, + ::bevy_sprite::TextureSlicer, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_sprite::prelude::TextureSlicer>| { - let output: Val<::bevy_sprite::prelude::TextureSlicer> = { - { - let output: Val<::bevy_sprite::prelude::TextureSlicer> = - <::bevy_sprite::prelude::TextureSlicer as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_sprite::prelude::TextureSlicer>, - other: Ref<::bevy_sprite::prelude::TextureSlicer>| { - let output: bool = { - { - let output: bool = - <::bevy_sprite::prelude::TextureSlicer as ::std::cmp::PartialEq< - ::bevy_sprite::prelude::TextureSlicer, + .register_documented( + "clone", + |_self: Ref<::bevy_sprite::TextureSlicer>| { + let output: Val<::bevy_sprite::TextureSlicer> = { + { + let output: Val<::bevy_sprite::TextureSlicer> = <::bevy_sprite::TextureSlicer as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_sprite::TextureSlicer>, + other: Ref<::bevy_sprite::TextureSlicer>| + { + let output: bool = { + { + let output: bool = <::bevy_sprite::TextureSlicer as ::std::cmp::PartialEq< + ::bevy_sprite::TextureSlicer, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_sprite::prelude::TextureSlicer, + ::bevy_sprite::TextureSlicer, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_scaling_mode_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_sprite::prelude::ScalingMode, + ::bevy_sprite::ScalingMode, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_sprite::prelude::ScalingMode>| { - let output: Val<::bevy_sprite::prelude::ScalingMode> = { - { - let output: Val<::bevy_sprite::prelude::ScalingMode> = - <::bevy_sprite::prelude::ScalingMode as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_sprite::ScalingMode>| { + let output: Val<::bevy_sprite::ScalingMode> = { + { + let output: Val<::bevy_sprite::ScalingMode> = <::bevy_sprite::ScalingMode as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_sprite::prelude::ScalingMode>, - other: Ref<::bevy_sprite::prelude::ScalingMode>| { - let output: bool = { - { - let output: bool = - <::bevy_sprite::prelude::ScalingMode as ::std::cmp::PartialEq< - ::bevy_sprite::prelude::ScalingMode, + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_sprite::ScalingMode>, + other: Ref<::bevy_sprite::ScalingMode>| + { + let output: bool = { + { + let output: bool = <::bevy_sprite::ScalingMode as ::std::cmp::PartialEq< + ::bevy_sprite::ScalingMode, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_sprite::prelude::ScalingMode, + ::bevy_sprite::ScalingMode, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -512,6 +529,23 @@ pub(crate) fn register_anchor_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_sprite::Anchor, >::new(world) + .register_documented( + "as_vec", + |_self: Ref<::bevy_sprite::Anchor>| { + let output: Val<::glam::Vec2> = { + { + let output: Val<::glam::Vec2> = ::bevy_sprite::Anchor::as_vec( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) .register_documented( "clone", |_self: Ref<::bevy_sprite::Anchor>| { @@ -549,8 +583,10 @@ pub(crate) fn register_anchor_functions(world: &mut World) { let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::bevy_sprite::Anchor, bevy_mod_scripting_bindings::MarkAsGenerated>( - ); + .register_type_data::< + ::bevy_sprite::Anchor, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_text_2_d_shadow_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< diff --git a/crates/bindings/bevy_sprite_render_bms_bindings/src/lib.rs b/crates/bindings/bevy_sprite_render_bms_bindings/src/lib.rs index d4be6265be..fa23fd1250 100644 --- a/crates/bindings/bevy_sprite_render_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_sprite_render_bms_bindings/src/lib.rs @@ -1,27 +1,30 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevySpriteRenderScriptingPlugin; pub(crate) fn register_color_material_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_sprite_render::prelude::ColorMaterial, + ::bevy_sprite_render::ColorMaterial, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_sprite_render::prelude::ColorMaterial>| { - let output: Val<::bevy_sprite_render::prelude::ColorMaterial> = { + |_self: Ref<::bevy_sprite_render::ColorMaterial>| { + let output: Val<::bevy_sprite_render::ColorMaterial> = { { - let output: Val<::bevy_sprite_render::prelude::ColorMaterial> = <::bevy_sprite_render::prelude::ColorMaterial as ::std::clone::Clone>::clone( + let output: Val<::bevy_sprite_render::ColorMaterial> = <::bevy_sprite_render::ColorMaterial as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -37,7 +40,7 @@ pub(crate) fn register_color_material_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_sprite_render::prelude::ColorMaterial, + ::bevy_sprite_render::ColorMaterial, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -45,41 +48,43 @@ pub(crate) fn register_alpha_mode_2_d_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_sprite_render::AlphaMode2d, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_sprite_render::AlphaMode2d>| { - let output: Val<::bevy_sprite_render::AlphaMode2d> = { - { - let output: Val<::bevy_sprite_render::AlphaMode2d> = - <::bevy_sprite_render::AlphaMode2d as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_sprite_render::AlphaMode2d>| { + let output: Val<::bevy_sprite_render::AlphaMode2d> = { + { + let output: Val<::bevy_sprite_render::AlphaMode2d> = <::bevy_sprite_render::AlphaMode2d as ::std::clone::Clone>::clone( + &_self, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_sprite_render::AlphaMode2d>, - other: Ref<::bevy_sprite_render::AlphaMode2d>| { - let output: bool = { - { - let output: bool = - <::bevy_sprite_render::AlphaMode2d as ::std::cmp::PartialEq< + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_sprite_render::AlphaMode2d>, + other: Ref<::bevy_sprite_render::AlphaMode2d>| + { + let output: bool = { + { + let output: bool = <::bevy_sprite_render::AlphaMode2d as ::std::cmp::PartialEq< ::bevy_sprite_render::AlphaMode2d, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -92,24 +97,23 @@ pub(crate) fn register_wireframe_2_d_material_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_sprite_render::Wireframe2dMaterial, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_sprite_render::Wireframe2dMaterial>| { - let output: Val<::bevy_sprite_render::Wireframe2dMaterial> = { - { - let output: Val<::bevy_sprite_render::Wireframe2dMaterial> = - <::bevy_sprite_render::Wireframe2dMaterial as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_sprite_render::Wireframe2dMaterial>| { + let output: Val<::bevy_sprite_render::Wireframe2dMaterial> = { + { + let output: Val<::bevy_sprite_render::Wireframe2dMaterial> = <::bevy_sprite_render::Wireframe2dMaterial as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -122,24 +126,23 @@ pub(crate) fn register_wireframe_2_d_config_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_sprite_render::Wireframe2dConfig, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_sprite_render::Wireframe2dConfig>| { - let output: Val<::bevy_sprite_render::Wireframe2dConfig> = { - { - let output: Val<::bevy_sprite_render::Wireframe2dConfig> = - <::bevy_sprite_render::Wireframe2dConfig as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_sprite_render::Wireframe2dConfig>| { + let output: Val<::bevy_sprite_render::Wireframe2dConfig> = { + { + let output: Val<::bevy_sprite_render::Wireframe2dConfig> = <::bevy_sprite_render::Wireframe2dConfig as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -218,24 +221,23 @@ pub(crate) fn register_wireframe_2_d_color_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_sprite_render::Wireframe2dColor, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_sprite_render::Wireframe2dColor>| { - let output: Val<::bevy_sprite_render::Wireframe2dColor> = { - { - let output: Val<::bevy_sprite_render::Wireframe2dColor> = - <::bevy_sprite_render::Wireframe2dColor as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_sprite_render::Wireframe2dColor>| { + let output: Val<::bevy_sprite_render::Wireframe2dColor> = { + { + let output: Val<::bevy_sprite_render::Wireframe2dColor> = <::bevy_sprite_render::Wireframe2dColor as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -392,22 +394,44 @@ pub(crate) fn register_tilemap_chunk_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_sprite_render::TilemapChunk, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_sprite_render::TilemapChunk>| { - let output: Val<::bevy_sprite_render::TilemapChunk> = { - { - let output: Val<::bevy_sprite_render::TilemapChunk> = - <::bevy_sprite_render::TilemapChunk as ::std::clone::Clone>::clone(&_self) + .register_documented( + "calculate_tile_transform", + | + _self: Ref<::bevy_sprite_render::TilemapChunk>, + position: Val<::glam::UVec2>| + { + let output: Val<::bevy_transform::components::Transform> = { + { + let output: Val<::bevy_transform::components::Transform> = ::bevy_sprite_render::TilemapChunk::calculate_tile_transform( + &_self, + position.into_inner(), + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + output + } + }; + output + }, + "", + &["_self", "position"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_sprite_render::TilemapChunk>| { + let output: Val<::bevy_sprite_render::TilemapChunk> = { + { + let output: Val<::bevy_sprite_render::TilemapChunk> = <::bevy_sprite_render::TilemapChunk as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -420,37 +444,40 @@ pub(crate) fn register_tile_data_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_sprite_render::TileData, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_sprite_render::TileData>| { - let output: Val<::bevy_sprite_render::TileData> = { - { - let output: Val<::bevy_sprite_render::TileData> = - <::bevy_sprite_render::TileData as ::std::clone::Clone>::clone(&_self) + .register_documented( + "clone", + |_self: Ref<::bevy_sprite_render::TileData>| { + let output: Val<::bevy_sprite_render::TileData> = { + { + let output: Val<::bevy_sprite_render::TileData> = <::bevy_sprite_render::TileData as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "from_tileset_index", + |tileset_index: u16| { + let output: Val<::bevy_sprite_render::TileData> = { + { + let output: Val<::bevy_sprite_render::TileData> = ::bevy_sprite_render::TileData::from_tileset_index( + tileset_index, + ) .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "from_tileset_index", - |tileset_index: u16| { - let output: Val<::bevy_sprite_render::TileData> = { - { - let output: Val<::bevy_sprite_render::TileData> = - ::bevy_sprite_render::TileData::from_tileset_index(tileset_index).into(); - output - } - }; - output - }, - " Creates a new `TileData` with the given tileset index and default values.", - &["tileset_index"], - ); + output + } + }; + output + }, + " Creates a new `TileData` with the given tileset index and default values.", + &["tileset_index"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -463,24 +490,23 @@ pub(crate) fn register_tilemap_chunk_tile_data_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_sprite_render::TilemapChunkTileData, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_sprite_render::TilemapChunkTileData>| { - let output: Val<::bevy_sprite_render::TilemapChunkTileData> = { - { - let output: Val<::bevy_sprite_render::TilemapChunkTileData> = - <::bevy_sprite_render::TilemapChunkTileData as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_sprite_render::TilemapChunkTileData>| { + let output: Val<::bevy_sprite_render::TilemapChunkTileData> = { + { + let output: Val<::bevy_sprite_render::TilemapChunkTileData> = <::bevy_sprite_render::TilemapChunkTileData as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry diff --git a/crates/bindings/bevy_text_bms_bindings/src/lib.rs b/crates/bindings/bevy_text_bms_bindings/src/lib.rs index b31aa09f96..ea0f7a8b7d 100644 --- a/crates/bindings/bevy_text_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_text_bms_bindings/src/lib.rs @@ -1,27 +1,30 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyTextScriptingPlugin; pub(crate) fn register_justify_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_text::prelude::Justify, + ::bevy_text::Justify, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_text::prelude::Justify>| { + |_self: Ref<::bevy_text::Justify>| { let output: () = { { - let output: () = <::bevy_text::prelude::Justify as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_text::Justify as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -35,10 +38,10 @@ pub(crate) fn register_justify_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_text::prelude::Justify>| { - let output: Val<::bevy_text::prelude::Justify> = { + |_self: Ref<::bevy_text::Justify>| { + let output: Val<::bevy_text::Justify> = { { - let output: Val<::bevy_text::prelude::Justify> = <::bevy_text::prelude::Justify as ::std::clone::Clone>::clone( + let output: Val<::bevy_text::Justify> = <::bevy_text::Justify as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -52,14 +55,11 @@ pub(crate) fn register_justify_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_text::prelude::Justify>, - other: Ref<::bevy_text::prelude::Justify>| - { + |_self: Ref<::bevy_text::Justify>, other: Ref<::bevy_text::Justify>| { let output: bool = { { - let output: bool = <::bevy_text::prelude::Justify as ::std::cmp::PartialEq< - ::bevy_text::prelude::Justify, + let output: bool = <::bevy_text::Justify as ::std::cmp::PartialEq< + ::bevy_text::Justify, >>::eq(&_self, &other) .into(); output @@ -74,20 +74,20 @@ pub(crate) fn register_justify_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_text::prelude::Justify, + ::bevy_text::Justify, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_line_break_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_text::prelude::LineBreak, + ::bevy_text::LineBreak, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_text::prelude::LineBreak>| { + |_self: Ref<::bevy_text::LineBreak>| { let output: () = { { - let output: () = <::bevy_text::prelude::LineBreak as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_text::LineBreak as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -101,10 +101,10 @@ pub(crate) fn register_line_break_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_text::prelude::LineBreak>| { - let output: Val<::bevy_text::prelude::LineBreak> = { + |_self: Ref<::bevy_text::LineBreak>| { + let output: Val<::bevy_text::LineBreak> = { { - let output: Val<::bevy_text::prelude::LineBreak> = <::bevy_text::prelude::LineBreak as ::std::clone::Clone>::clone( + let output: Val<::bevy_text::LineBreak> = <::bevy_text::LineBreak as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -118,14 +118,11 @@ pub(crate) fn register_line_break_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_text::prelude::LineBreak>, - other: Ref<::bevy_text::prelude::LineBreak>| - { + |_self: Ref<::bevy_text::LineBreak>, other: Ref<::bevy_text::LineBreak>| { let output: bool = { { - let output: bool = <::bevy_text::prelude::LineBreak as ::std::cmp::PartialEq< - ::bevy_text::prelude::LineBreak, + let output: bool = <::bevy_text::LineBreak as ::std::cmp::PartialEq< + ::bevy_text::LineBreak, >>::eq(&_self, &other) .into(); output @@ -140,184 +137,189 @@ pub(crate) fn register_line_break_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_text::prelude::LineBreak, + ::bevy_text::LineBreak, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_text_color_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_text::prelude::TextColor, + ::bevy_text::TextColor, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_text::prelude::TextColor>| { - let output: Val<::bevy_text::prelude::TextColor> = { - { - let output: Val<::bevy_text::prelude::TextColor> = - <::bevy_text::prelude::TextColor as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_text::prelude::TextColor>, - other: Ref<::bevy_text::prelude::TextColor>| { - let output: bool = { - { - let output: bool = <::bevy_text::prelude::TextColor as ::std::cmp::PartialEq< - ::bevy_text::prelude::TextColor, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_text::TextColor>| { + let output: Val<::bevy_text::TextColor> = { + { + let output: Val<::bevy_text::TextColor> = <::bevy_text::TextColor as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_text::TextColor>, other: Ref<::bevy_text::TextColor>| { + let output: bool = { + { + let output: bool = <::bevy_text::TextColor as ::std::cmp::PartialEq< + ::bevy_text::TextColor, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_text::prelude::TextColor, + ::bevy_text::TextColor, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_text_font_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_text::prelude::TextFont, + ::bevy_text::TextFont, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_text::prelude::TextFont>| { - let output: Val<::bevy_text::prelude::TextFont> = { - { - let output: Val<::bevy_text::prelude::TextFont> = - <::bevy_text::prelude::TextFont as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_text::prelude::TextFont>, other: Ref<::bevy_text::prelude::TextFont>| { - let output: bool = { - { - let output: bool = <::bevy_text::prelude::TextFont as ::std::cmp::PartialEq< - ::bevy_text::prelude::TextFont, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "from_font_size", - |font_size: f32| { - let output: Val<::bevy_text::prelude::TextFont> = { - { - let output: Val<::bevy_text::prelude::TextFont> = - ::bevy_text::prelude::TextFont::from_font_size(font_size).into(); - output - } - }; - output - }, - " Returns a new [`TextFont`] with the specified font size.", - &["font_size"], - ) - .register_documented( - "with_font_size", - |_self: Val<::bevy_text::prelude::TextFont>, font_size: f32| { - let output: Val<::bevy_text::prelude::TextFont> = { - { - let output: Val<::bevy_text::prelude::TextFont> = - ::bevy_text::prelude::TextFont::with_font_size( - _self.into_inner(), - font_size, - ) - .into(); - output - } - }; - output - }, - " Returns this [`TextFont`] with the specified font size.", - &["_self", "font_size"], - ) - .register_documented( - "with_font_smoothing", - |_self: Val<::bevy_text::prelude::TextFont>, - font_smoothing: Val<::bevy_text::FontSmoothing>| { - let output: Val<::bevy_text::prelude::TextFont> = { - { - let output: Val<::bevy_text::prelude::TextFont> = - ::bevy_text::prelude::TextFont::with_font_smoothing( - _self.into_inner(), - font_smoothing.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Returns this [`TextFont`] with the specified [`FontSmoothing`].", - &["_self", "font_smoothing"], - ) - .register_documented( - "with_line_height", - |_self: Val<::bevy_text::prelude::TextFont>, line_height: Val<::bevy_text::LineHeight>| { - let output: Val<::bevy_text::prelude::TextFont> = { - { - let output: Val<::bevy_text::prelude::TextFont> = - ::bevy_text::prelude::TextFont::with_line_height( - _self.into_inner(), - line_height.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Returns this [`TextFont`] with the specified [`LineHeight`].", - &["_self", "line_height"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_text::TextFont>| { + let output: Val<::bevy_text::TextFont> = { + { + let output: Val<::bevy_text::TextFont> = <::bevy_text::TextFont as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_text::TextFont>, other: Ref<::bevy_text::TextFont>| { + let output: bool = { + { + let output: bool = <::bevy_text::TextFont as ::std::cmp::PartialEq< + ::bevy_text::TextFont, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "from_font_size", + |font_size: f32| { + let output: Val<::bevy_text::TextFont> = { + { + let output: Val<::bevy_text::TextFont> = ::bevy_text::TextFont::from_font_size( + font_size, + ) + .into(); + output + } + }; + output + }, + " Returns a new [`TextFont`] with the specified font size.", + &["font_size"], + ) + .register_documented( + "with_font_size", + |_self: Val<::bevy_text::TextFont>, font_size: f32| { + let output: Val<::bevy_text::TextFont> = { + { + let output: Val<::bevy_text::TextFont> = ::bevy_text::TextFont::with_font_size( + _self.into_inner(), + font_size, + ) + .into(); + output + } + }; + output + }, + " Returns this [`TextFont`] with the specified font size.", + &["_self", "font_size"], + ) + .register_documented( + "with_font_smoothing", + | + _self: Val<::bevy_text::TextFont>, + font_smoothing: Val<::bevy_text::FontSmoothing>| + { + let output: Val<::bevy_text::TextFont> = { + { + let output: Val<::bevy_text::TextFont> = ::bevy_text::TextFont::with_font_smoothing( + _self.into_inner(), + font_smoothing.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns this [`TextFont`] with the specified [`FontSmoothing`].", + &["_self", "font_smoothing"], + ) + .register_documented( + "with_line_height", + | + _self: Val<::bevy_text::TextFont>, + line_height: Val<::bevy_text::LineHeight>| + { + let output: Val<::bevy_text::TextFont> = { + { + let output: Val<::bevy_text::TextFont> = ::bevy_text::TextFont::with_line_height( + _self.into_inner(), + line_height.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns this [`TextFont`] with the specified [`LineHeight`].", + &["_self", "line_height"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_text::prelude::TextFont, + ::bevy_text::TextFont, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_text_layout_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_text::prelude::TextLayout, + ::bevy_text::TextLayout, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_text::prelude::TextLayout>| { - let output: Val<::bevy_text::prelude::TextLayout> = { + |_self: Ref<::bevy_text::TextLayout>| { + let output: Val<::bevy_text::TextLayout> = { { - let output: Val<::bevy_text::prelude::TextLayout> = <::bevy_text::prelude::TextLayout as ::std::clone::Clone>::clone( + let output: Val<::bevy_text::TextLayout> = <::bevy_text::TextLayout as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -331,13 +333,10 @@ pub(crate) fn register_text_layout_functions(world: &mut World) { ) .register_documented( "new", - | - justify: Val<::bevy_text::prelude::Justify>, - linebreak: Val<::bevy_text::prelude::LineBreak>| - { - let output: Val<::bevy_text::prelude::TextLayout> = { + |justify: Val<::bevy_text::Justify>, linebreak: Val<::bevy_text::LineBreak>| { + let output: Val<::bevy_text::TextLayout> = { { - let output: Val<::bevy_text::prelude::TextLayout> = ::bevy_text::prelude::TextLayout::new( + let output: Val<::bevy_text::TextLayout> = ::bevy_text::TextLayout::new( justify.into_inner(), linebreak.into_inner(), ) @@ -352,10 +351,10 @@ pub(crate) fn register_text_layout_functions(world: &mut World) { ) .register_documented( "new_with_justify", - |justify: Val<::bevy_text::prelude::Justify>| { - let output: Val<::bevy_text::prelude::TextLayout> = { + |justify: Val<::bevy_text::Justify>| { + let output: Val<::bevy_text::TextLayout> = { { - let output: Val<::bevy_text::prelude::TextLayout> = ::bevy_text::prelude::TextLayout::new_with_justify( + let output: Val<::bevy_text::TextLayout> = ::bevy_text::TextLayout::new_with_justify( justify.into_inner(), ) .into(); @@ -369,10 +368,10 @@ pub(crate) fn register_text_layout_functions(world: &mut World) { ) .register_documented( "new_with_linebreak", - |linebreak: Val<::bevy_text::prelude::LineBreak>| { - let output: Val<::bevy_text::prelude::TextLayout> = { + |linebreak: Val<::bevy_text::LineBreak>| { + let output: Val<::bevy_text::TextLayout> = { { - let output: Val<::bevy_text::prelude::TextLayout> = ::bevy_text::prelude::TextLayout::new_with_linebreak( + let output: Val<::bevy_text::TextLayout> = ::bevy_text::TextLayout::new_with_linebreak( linebreak.into_inner(), ) .into(); @@ -387,9 +386,9 @@ pub(crate) fn register_text_layout_functions(world: &mut World) { .register_documented( "new_with_no_wrap", || { - let output: Val<::bevy_text::prelude::TextLayout> = { + let output: Val<::bevy_text::TextLayout> = { { - let output: Val<::bevy_text::prelude::TextLayout> = ::bevy_text::prelude::TextLayout::new_with_no_wrap() + let output: Val<::bevy_text::TextLayout> = ::bevy_text::TextLayout::new_with_no_wrap() .into(); output } @@ -401,13 +400,10 @@ pub(crate) fn register_text_layout_functions(world: &mut World) { ) .register_documented( "with_justify", - | - _self: Val<::bevy_text::prelude::TextLayout>, - justify: Val<::bevy_text::prelude::Justify>| - { - let output: Val<::bevy_text::prelude::TextLayout> = { + |_self: Val<::bevy_text::TextLayout>, justify: Val<::bevy_text::Justify>| { + let output: Val<::bevy_text::TextLayout> = { { - let output: Val<::bevy_text::prelude::TextLayout> = ::bevy_text::prelude::TextLayout::with_justify( + let output: Val<::bevy_text::TextLayout> = ::bevy_text::TextLayout::with_justify( _self.into_inner(), justify.into_inner(), ) @@ -423,12 +419,12 @@ pub(crate) fn register_text_layout_functions(world: &mut World) { .register_documented( "with_linebreak", | - _self: Val<::bevy_text::prelude::TextLayout>, - linebreak: Val<::bevy_text::prelude::LineBreak>| + _self: Val<::bevy_text::TextLayout>, + linebreak: Val<::bevy_text::LineBreak>| { - let output: Val<::bevy_text::prelude::TextLayout> = { + let output: Val<::bevy_text::TextLayout> = { { - let output: Val<::bevy_text::prelude::TextLayout> = ::bevy_text::prelude::TextLayout::with_linebreak( + let output: Val<::bevy_text::TextLayout> = ::bevy_text::TextLayout::with_linebreak( _self.into_inner(), linebreak.into_inner(), ) @@ -443,10 +439,10 @@ pub(crate) fn register_text_layout_functions(world: &mut World) { ) .register_documented( "with_no_wrap", - |_self: Val<::bevy_text::prelude::TextLayout>| { - let output: Val<::bevy_text::prelude::TextLayout> = { + |_self: Val<::bevy_text::TextLayout>| { + let output: Val<::bevy_text::TextLayout> = { { - let output: Val<::bevy_text::prelude::TextLayout> = ::bevy_text::prelude::TextLayout::with_no_wrap( + let output: Val<::bevy_text::TextLayout> = ::bevy_text::TextLayout::with_no_wrap( _self.into_inner(), ) .into(); @@ -462,35 +458,36 @@ pub(crate) fn register_text_layout_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_text::prelude::TextLayout, + ::bevy_text::TextLayout, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_text_span_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_text::prelude::TextSpan, + ::bevy_text::TextSpan, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_text::prelude::TextSpan>| { - let output: Val<::bevy_text::prelude::TextSpan> = { - { - let output: Val<::bevy_text::prelude::TextSpan> = - <::bevy_text::prelude::TextSpan as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_text::TextSpan>| { + let output: Val<::bevy_text::TextSpan> = { + { + let output: Val<::bevy_text::TextSpan> = <::bevy_text::TextSpan as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_text::prelude::TextSpan, + ::bevy_text::TextSpan, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -645,22 +642,23 @@ pub(crate) fn register_glyph_atlas_location_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_text::GlyphAtlasLocation, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_text::GlyphAtlasLocation>| { - let output: Val<::bevy_text::GlyphAtlasLocation> = { - { - let output: Val<::bevy_text::GlyphAtlasLocation> = - <::bevy_text::GlyphAtlasLocation as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_text::GlyphAtlasLocation>| { + let output: Val<::bevy_text::GlyphAtlasLocation> = { + { + let output: Val<::bevy_text::GlyphAtlasLocation> = <::bevy_text::GlyphAtlasLocation as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -702,21 +700,23 @@ pub(crate) fn register_positioned_glyph_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_text::PositionedGlyph, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_text::PositionedGlyph>| { - let output: Val<::bevy_text::PositionedGlyph> = { - { - let output: Val<::bevy_text::PositionedGlyph> = - <::bevy_text::PositionedGlyph as ::std::clone::Clone>::clone(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_text::PositionedGlyph>| { + let output: Val<::bevy_text::PositionedGlyph> = { + { + let output: Val<::bevy_text::PositionedGlyph> = <::bevy_text::PositionedGlyph as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -879,41 +879,43 @@ pub(crate) fn register_text_background_color_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_text::TextBackgroundColor, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_text::TextBackgroundColor>| { - let output: Val<::bevy_text::TextBackgroundColor> = { - { - let output: Val<::bevy_text::TextBackgroundColor> = - <::bevy_text::TextBackgroundColor as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_text::TextBackgroundColor>, - other: Ref<::bevy_text::TextBackgroundColor>| { - let output: bool = { - { - let output: bool = - <::bevy_text::TextBackgroundColor as ::std::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_text::TextBackgroundColor>| { + let output: Val<::bevy_text::TextBackgroundColor> = { + { + let output: Val<::bevy_text::TextBackgroundColor> = <::bevy_text::TextBackgroundColor as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_text::TextBackgroundColor>, + other: Ref<::bevy_text::TextBackgroundColor>| + { + let output: bool = { + { + let output: bool = <::bevy_text::TextBackgroundColor as ::std::cmp::PartialEq< ::bevy_text::TextBackgroundColor, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry diff --git a/crates/bindings/bevy_time_bms_bindings/src/lib.rs b/crates/bindings/bevy_time_bms_bindings/src/lib.rs index c9aa40bb85..bfeb9fd13f 100644 --- a/crates/bindings/bevy_time_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_time_bms_bindings/src/lib.rs @@ -1,27 +1,30 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyTimeScriptingPlugin; pub(crate) fn register_fixed_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_time::prelude::Fixed, + ::bevy_time::Fixed, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_time::prelude::Fixed>| { - let output: Val<::bevy_time::prelude::Fixed> = { + |_self: Ref<::bevy_time::Fixed>| { + let output: Val<::bevy_time::Fixed> = { { - let output: Val<::bevy_time::prelude::Fixed> = <::bevy_time::prelude::Fixed as ::core::clone::Clone>::clone( + let output: Val<::bevy_time::Fixed> = <::bevy_time::Fixed as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -37,20 +40,20 @@ pub(crate) fn register_fixed_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_time::prelude::Fixed, + ::bevy_time::Fixed, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_real_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_time::prelude::Real, + ::bevy_time::Real, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_time::prelude::Real>| { - let output: Val<::bevy_time::prelude::Real> = { + |_self: Ref<::bevy_time::Real>| { + let output: Val<::bevy_time::Real> = { { - let output: Val<::bevy_time::prelude::Real> = <::bevy_time::prelude::Real as ::core::clone::Clone>::clone( + let output: Val<::bevy_time::Real> = <::bevy_time::Real as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -66,20 +69,20 @@ pub(crate) fn register_real_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_time::prelude::Real, + ::bevy_time::Real, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_timer_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_time::prelude::Timer, + ::bevy_time::Timer, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_time::prelude::Timer>| { + |_self: Ref<::bevy_time::Timer>| { let output: () = { { - let output: () = <::bevy_time::prelude::Timer as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_time::Timer as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -93,10 +96,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_time::prelude::Timer>| { - let output: Val<::bevy_time::prelude::Timer> = { + |_self: Ref<::bevy_time::Timer>| { + let output: Val<::bevy_time::Timer> = { { - let output: Val<::bevy_time::prelude::Timer> = <::bevy_time::prelude::Timer as ::core::clone::Clone>::clone( + let output: Val<::bevy_time::Timer> = <::bevy_time::Timer as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -109,11 +112,28 @@ pub(crate) fn register_timer_functions(world: &mut World) { &["_self"], ) .register_documented( - "elapsed_secs", - |_self: Ref<::bevy_time::prelude::Timer>| { - let output: f32 = { + "duration", + |_self: Ref<::bevy_time::Timer>| { + let output: Val<::core::time::Duration> = { + { + let output: Val<::core::time::Duration> = ::bevy_time::Timer::duration( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the duration of the timer.\n # Examples\n ```\n # use bevy_time::*;\n use std::time::Duration;\n let timer = Timer::new(Duration::from_secs(1), TimerMode::Once);\n assert_eq!(timer.duration(), Duration::from_secs(1));\n ```", + &["_self"], + ) + .register_documented( + "elapsed", + |_self: Ref<::bevy_time::Timer>| { + let output: Val<::core::time::Duration> = { { - let output: f32 = ::bevy_time::prelude::Timer::elapsed_secs( + let output: Val<::core::time::Duration> = ::bevy_time::Timer::elapsed( &_self, ) .into(); @@ -122,17 +142,30 @@ pub(crate) fn register_timer_functions(world: &mut World) { }; output }, + " Returns the time elapsed on the timer. Guaranteed to be between 0.0 and `duration`.\n Will only equal `duration` when the timer is finished and non repeating.\n See also [`Stopwatch::elapsed`](Stopwatch::elapsed).\n # Examples\n ```\n # use bevy_time::*;\n use std::time::Duration;\n let mut timer = Timer::from_seconds(1.0, TimerMode::Once);\n timer.tick(Duration::from_secs_f32(0.5));\n assert_eq!(timer.elapsed(), Duration::from_secs_f32(0.5));\n ```", + &["_self"], + ) + .register_documented( + "elapsed_secs", + |_self: Ref<::bevy_time::Timer>| { + let output: f32 = { + { + let output: f32 = ::bevy_time::Timer::elapsed_secs(&_self) + .into(); + output + } + }; + output + }, " Returns the time elapsed on the timer as an `f32`.\n See also [`Timer::elapsed`](Timer::elapsed).", &["_self"], ) .register_documented( "elapsed_secs_f64", - |_self: Ref<::bevy_time::prelude::Timer>| { + |_self: Ref<::bevy_time::Timer>| { let output: f64 = { { - let output: f64 = ::bevy_time::prelude::Timer::elapsed_secs_f64( - &_self, - ) + let output: f64 = ::bevy_time::Timer::elapsed_secs_f64(&_self) .into(); output } @@ -144,14 +177,11 @@ pub(crate) fn register_timer_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_time::prelude::Timer>, - other: Ref<::bevy_time::prelude::Timer>| - { + |_self: Ref<::bevy_time::Timer>, other: Ref<::bevy_time::Timer>| { let output: bool = { { - let output: bool = <::bevy_time::prelude::Timer as ::core::cmp::PartialEq< - ::bevy_time::prelude::Timer, + let output: bool = <::bevy_time::Timer as ::core::cmp::PartialEq< + ::bevy_time::Timer, >>::eq(&_self, &other) .into(); output @@ -164,11 +194,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { ) .register_documented( "finish", - |mut _self: Mut<::bevy_time::prelude::Timer>| { + |mut _self: Mut<::bevy_time::Timer>| { let output: () = { { - let output: () = ::bevy_time::prelude::Timer::finish(&mut _self) - .into(); + let output: () = ::bevy_time::Timer::finish(&mut _self).into(); output } }; @@ -179,11 +208,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { ) .register_documented( "finished", - |_self: Ref<::bevy_time::prelude::Timer>| { + |_self: Ref<::bevy_time::Timer>| { let output: bool = { { - let output: bool = ::bevy_time::prelude::Timer::finished(&_self) - .into(); + let output: bool = ::bevy_time::Timer::finished(&_self).into(); output } }; @@ -194,11 +222,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { ) .register_documented( "fraction", - |_self: Ref<::bevy_time::prelude::Timer>| { + |_self: Ref<::bevy_time::Timer>| { let output: f32 = { { - let output: f32 = ::bevy_time::prelude::Timer::fraction(&_self) - .into(); + let output: f32 = ::bevy_time::Timer::fraction(&_self).into(); output } }; @@ -209,12 +236,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { ) .register_documented( "fraction_remaining", - |_self: Ref<::bevy_time::prelude::Timer>| { + |_self: Ref<::bevy_time::Timer>| { let output: f32 = { { - let output: f32 = ::bevy_time::prelude::Timer::fraction_remaining( - &_self, - ) + let output: f32 = ::bevy_time::Timer::fraction_remaining(&_self) .into(); output } @@ -226,10 +251,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { ) .register_documented( "from_seconds", - |duration: f32, mode: Val<::bevy_time::prelude::TimerMode>| { - let output: Val<::bevy_time::prelude::Timer> = { + |duration: f32, mode: Val<::bevy_time::TimerMode>| { + let output: Val<::bevy_time::Timer> = { { - let output: Val<::bevy_time::prelude::Timer> = ::bevy_time::prelude::Timer::from_seconds( + let output: Val<::bevy_time::Timer> = ::bevy_time::Timer::from_seconds( duration, mode.into_inner(), ) @@ -244,12 +269,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { ) .register_documented( "is_finished", - |_self: Ref<::bevy_time::prelude::Timer>| { + |_self: Ref<::bevy_time::Timer>| { let output: bool = { { - let output: bool = ::bevy_time::prelude::Timer::is_finished( - &_self, - ) + let output: bool = ::bevy_time::Timer::is_finished(&_self) .into(); output } @@ -261,11 +284,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { ) .register_documented( "is_paused", - |_self: Ref<::bevy_time::prelude::Timer>| { + |_self: Ref<::bevy_time::Timer>| { let output: bool = { { - let output: bool = ::bevy_time::prelude::Timer::is_paused(&_self) - .into(); + let output: bool = ::bevy_time::Timer::is_paused(&_self).into(); output } }; @@ -276,12 +298,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { ) .register_documented( "just_finished", - |_self: Ref<::bevy_time::prelude::Timer>| { + |_self: Ref<::bevy_time::Timer>| { let output: bool = { { - let output: bool = ::bevy_time::prelude::Timer::just_finished( - &_self, - ) + let output: bool = ::bevy_time::Timer::just_finished(&_self) .into(); output } @@ -293,10 +313,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { ) .register_documented( "mode", - |_self: Ref<::bevy_time::prelude::Timer>| { - let output: Val<::bevy_time::prelude::TimerMode> = { + |_self: Ref<::bevy_time::Timer>| { + let output: Val<::bevy_time::TimerMode> = { { - let output: Val<::bevy_time::prelude::TimerMode> = ::bevy_time::prelude::Timer::mode( + let output: Val<::bevy_time::TimerMode> = ::bevy_time::Timer::mode( &_self, ) .into(); @@ -308,13 +328,30 @@ pub(crate) fn register_timer_functions(world: &mut World) { " Returns the mode of the timer.\n # Examples\n ```\n # use bevy_time::*;\n let mut timer = Timer::from_seconds(1.0, TimerMode::Repeating);\n assert_eq!(timer.mode(), TimerMode::Repeating);\n ```", &["_self"], ) + .register_documented( + "new", + |duration: Val<::core::time::Duration>, mode: Val<::bevy_time::TimerMode>| { + let output: Val<::bevy_time::Timer> = { + { + let output: Val<::bevy_time::Timer> = ::bevy_time::Timer::new( + duration.into_inner(), + mode.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a new timer with a given duration.\n See also [`Timer::from_seconds`](Timer::from_seconds).", + &["duration", "mode"], + ) .register_documented( "pause", - |mut _self: Mut<::bevy_time::prelude::Timer>| { + |mut _self: Mut<::bevy_time::Timer>| { let output: () = { { - let output: () = ::bevy_time::prelude::Timer::pause(&mut _self) - .into(); + let output: () = ::bevy_time::Timer::pause(&mut _self).into(); output } }; @@ -325,11 +362,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { ) .register_documented( "paused", - |_self: Ref<::bevy_time::prelude::Timer>| { + |_self: Ref<::bevy_time::Timer>| { let output: bool = { { - let output: bool = ::bevy_time::prelude::Timer::paused(&_self) - .into(); + let output: bool = ::bevy_time::Timer::paused(&_self).into(); output } }; @@ -339,11 +375,11 @@ pub(crate) fn register_timer_functions(world: &mut World) { &["_self"], ) .register_documented( - "remaining_secs", - |_self: Ref<::bevy_time::prelude::Timer>| { - let output: f32 = { + "remaining", + |_self: Ref<::bevy_time::Timer>| { + let output: Val<::core::time::Duration> = { { - let output: f32 = ::bevy_time::prelude::Timer::remaining_secs( + let output: Val<::core::time::Duration> = ::bevy_time::Timer::remaining( &_self, ) .into(); @@ -352,16 +388,30 @@ pub(crate) fn register_timer_functions(world: &mut World) { }; output }, + " Returns the remaining time using Duration\n # Examples\n ```\n # use bevy_time::*;\n use std::time::Duration;\n let mut timer = Timer::from_seconds(2.0, TimerMode::Once);\n timer.tick(Duration::from_secs_f32(0.5));\n assert_eq!(timer.remaining(), Duration::from_secs_f32(1.5));\n ```", + &["_self"], + ) + .register_documented( + "remaining_secs", + |_self: Ref<::bevy_time::Timer>| { + let output: f32 = { + { + let output: f32 = ::bevy_time::Timer::remaining_secs(&_self) + .into(); + output + } + }; + output + }, " Returns the remaining time in seconds\n # Examples\n ```\n # use bevy_time::*;\n use std::cmp::Ordering;\n use std::time::Duration;\n let mut timer = Timer::from_seconds(2.0, TimerMode::Once);\n timer.tick(Duration::from_secs_f32(0.5));\n let result = timer.remaining_secs().total_cmp(&1.5);\n assert_eq!(Ordering::Equal, result);\n ```", &["_self"], ) .register_documented( "reset", - |mut _self: Mut<::bevy_time::prelude::Timer>| { + |mut _self: Mut<::bevy_time::Timer>| { let output: () = { { - let output: () = ::bevy_time::prelude::Timer::reset(&mut _self) - .into(); + let output: () = ::bevy_time::Timer::reset(&mut _self).into(); output } }; @@ -370,15 +420,48 @@ pub(crate) fn register_timer_functions(world: &mut World) { " Resets the timer. The reset doesn't affect the `paused` state of the timer.\n See also [`Stopwatch::reset`](Stopwatch::reset).\n Examples\n ```\n # use bevy_time::*;\n use std::time::Duration;\n let mut timer = Timer::from_seconds(1.0, TimerMode::Once);\n timer.tick(Duration::from_secs_f32(1.5));\n timer.reset();\n assert!(!timer.is_finished());\n assert!(!timer.just_finished());\n assert_eq!(timer.elapsed_secs(), 0.0);\n ```", &["_self"], ) + .register_documented( + "set_duration", + |mut _self: Mut<::bevy_time::Timer>, duration: Val<::core::time::Duration>| { + let output: () = { + { + let output: () = ::bevy_time::Timer::set_duration( + &mut _self, + duration.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Sets the duration of the timer.\n # Examples\n ```\n # use bevy_time::*;\n use std::time::Duration;\n let mut timer = Timer::from_seconds(1.5, TimerMode::Once);\n timer.set_duration(Duration::from_secs(1));\n assert_eq!(timer.duration(), Duration::from_secs(1));\n ```", + &["_self", "duration"], + ) + .register_documented( + "set_elapsed", + |mut _self: Mut<::bevy_time::Timer>, time: Val<::core::time::Duration>| { + let output: () = { + { + let output: () = ::bevy_time::Timer::set_elapsed( + &mut _self, + time.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Sets the elapsed time of the timer without any other considerations.\n See also [`Stopwatch::set`](Stopwatch::set).\n #\n ```\n # use bevy_time::*;\n use std::time::Duration;\n let mut timer = Timer::from_seconds(1.0, TimerMode::Once);\n timer.set_elapsed(Duration::from_secs(2));\n assert_eq!(timer.elapsed(), Duration::from_secs(2));\n // the timer is not finished even if the elapsed time is greater than the duration.\n assert!(!timer.is_finished());\n ```", + &["_self", "time"], + ) .register_documented( "set_mode", - | - mut _self: Mut<::bevy_time::prelude::Timer>, - mode: Val<::bevy_time::prelude::TimerMode>| - { + |mut _self: Mut<::bevy_time::Timer>, mode: Val<::bevy_time::TimerMode>| { let output: () = { { - let output: () = ::bevy_time::prelude::Timer::set_mode( + let output: () = ::bevy_time::Timer::set_mode( &mut _self, mode.into_inner(), ) @@ -393,10 +476,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { ) .register_documented( "times_finished_this_tick", - |_self: Ref<::bevy_time::prelude::Timer>| { + |_self: Ref<::bevy_time::Timer>| { let output: u32 = { { - let output: u32 = ::bevy_time::prelude::Timer::times_finished_this_tick( + let output: u32 = ::bevy_time::Timer::times_finished_this_tick( &_self, ) .into(); @@ -410,11 +493,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { ) .register_documented( "unpause", - |mut _self: Mut<::bevy_time::prelude::Timer>| { + |mut _self: Mut<::bevy_time::Timer>| { let output: () = { { - let output: () = ::bevy_time::prelude::Timer::unpause(&mut _self) - .into(); + let output: () = ::bevy_time::Timer::unpause(&mut _self).into(); output } }; @@ -427,20 +509,20 @@ pub(crate) fn register_timer_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_time::prelude::Timer, + ::bevy_time::Timer, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_timer_mode_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_time::prelude::TimerMode, + ::bevy_time::TimerMode, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_time::prelude::TimerMode>| { + |_self: Ref<::bevy_time::TimerMode>| { let output: () = { { - let output: () = <::bevy_time::prelude::TimerMode as ::core::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_time::TimerMode as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -454,10 +536,10 @@ pub(crate) fn register_timer_mode_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_time::prelude::TimerMode>| { - let output: Val<::bevy_time::prelude::TimerMode> = { + |_self: Ref<::bevy_time::TimerMode>| { + let output: Val<::bevy_time::TimerMode> = { { - let output: Val<::bevy_time::prelude::TimerMode> = <::bevy_time::prelude::TimerMode as ::core::clone::Clone>::clone( + let output: Val<::bevy_time::TimerMode> = <::bevy_time::TimerMode as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -471,14 +553,11 @@ pub(crate) fn register_timer_mode_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_time::prelude::TimerMode>, - other: Ref<::bevy_time::prelude::TimerMode>| - { + |_self: Ref<::bevy_time::TimerMode>, other: Ref<::bevy_time::TimerMode>| { let output: bool = { { - let output: bool = <::bevy_time::prelude::TimerMode as ::core::cmp::PartialEq< - ::bevy_time::prelude::TimerMode, + let output: bool = <::bevy_time::TimerMode as ::core::cmp::PartialEq< + ::bevy_time::TimerMode, >>::eq(&_self, &other) .into(); output @@ -493,35 +572,36 @@ pub(crate) fn register_timer_mode_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_time::prelude::TimerMode, + ::bevy_time::TimerMode, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_virtual_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_time::prelude::Virtual, + ::bevy_time::Virtual, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_time::prelude::Virtual>| { - let output: Val<::bevy_time::prelude::Virtual> = { - { - let output: Val<::bevy_time::prelude::Virtual> = - <::bevy_time::prelude::Virtual as ::core::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_time::Virtual>| { + let output: Val<::bevy_time::Virtual> = { + { + let output: Val<::bevy_time::Virtual> = <::bevy_time::Virtual as ::core::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_time::prelude::Virtual, + ::bevy_time::Virtual, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -563,6 +643,23 @@ pub(crate) fn register_stopwatch_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "elapsed", + |_self: Ref<::bevy_time::Stopwatch>| { + let output: Val<::core::time::Duration> = { + { + let output: Val<::core::time::Duration> = ::bevy_time::Stopwatch::elapsed( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the elapsed time since the last [`reset`](Stopwatch::reset)\n of the stopwatch.\n # Examples\n ```\n # use bevy_time::*;\n use std::time::Duration;\n let mut stopwatch = Stopwatch::new();\n stopwatch.tick(Duration::from_secs(1));\n assert_eq!(stopwatch.elapsed(), Duration::from_secs(1));\n ```\n # See Also\n [`elapsed_secs`](Stopwatch::elapsed_secs) - if an `f32` value is desirable instead.\n [`elapsed_secs_f64`](Stopwatch::elapsed_secs_f64) - if an `f64` is desirable instead.", + &["_self"], + ) .register_documented( "elapsed_secs", |_self: Ref<::bevy_time::Stopwatch>| { @@ -672,6 +769,24 @@ pub(crate) fn register_stopwatch_functions(world: &mut World) { " Resets the stopwatch. The reset doesn't affect the paused state of the stopwatch.\n # Examples\n ```\n # use bevy_time::*;\n use std::time::Duration;\n let mut stopwatch = Stopwatch::new();\n stopwatch.tick(Duration::from_secs_f32(1.5));\n stopwatch.reset();\n assert_eq!(stopwatch.elapsed_secs(), 0.0);\n ```", &["_self"], ) + .register_documented( + "set_elapsed", + |mut _self: Mut<::bevy_time::Stopwatch>, time: Val<::core::time::Duration>| { + let output: () = { + { + let output: () = ::bevy_time::Stopwatch::set_elapsed( + &mut _self, + time.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Sets the elapsed time of the stopwatch.\n # Examples\n ```\n # use bevy_time::*;\n use std::time::Duration;\n let mut stopwatch = Stopwatch::new();\n stopwatch.set_elapsed(Duration::from_secs_f32(1.0));\n assert_eq!(stopwatch.elapsed_secs(), 1.0);\n ```", + &["_self", "time"], + ) .register_documented( "unpause", |mut _self: Mut<::bevy_time::Stopwatch>| { @@ -690,8 +805,10 @@ pub(crate) fn register_stopwatch_functions(world: &mut World) { let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::bevy_time::Stopwatch, bevy_mod_scripting_bindings::MarkAsGenerated>( - ); + .register_type_data::< + ::bevy_time::Stopwatch, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } impl Plugin for BevyTimeScriptingPlugin { fn build(&self, app: &mut App) { diff --git a/crates/bindings/bevy_transform_bms_bindings/src/lib.rs b/crates/bindings/bevy_transform_bms_bindings/src/lib.rs index 63b3cc064c..429839d86c 100644 --- a/crates/bindings/bevy_transform_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_transform_bms_bindings/src/lib.rs @@ -1,21 +1,41 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyTransformScriptingPlugin; pub(crate) fn register_global_transform_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_transform::components::GlobalTransform, >::new(world) + .register_documented( + "affine", + |_self: Ref<::bevy_transform::components::GlobalTransform>| { + let output: Val<::glam::Affine3A> = { + { + let output: Val<::glam::Affine3A> = ::bevy_transform::components::GlobalTransform::affine( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the 3d affine transformation matrix as an [`Affine3A`].", + &["_self"], + ) .register_documented( "back", |_self: Ref<::bevy_transform::components::GlobalTransform>| { @@ -138,6 +158,57 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { "", &["iso"], ) + .register_documented( + "from_rotation", + |rotation: Val<::glam::Quat>| { + let output: Val<::bevy_transform::components::GlobalTransform> = { + { + let output: Val<::bevy_transform::components::GlobalTransform> = ::bevy_transform::components::GlobalTransform::from_rotation( + rotation.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["rotation"], + ) + .register_documented( + "from_scale", + |scale: Val<::glam::Vec3>| { + let output: Val<::bevy_transform::components::GlobalTransform> = { + { + let output: Val<::bevy_transform::components::GlobalTransform> = ::bevy_transform::components::GlobalTransform::from_scale( + scale.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["scale"], + ) + .register_documented( + "from_translation", + |translation: Val<::glam::Vec3>| { + let output: Val<::bevy_transform::components::GlobalTransform> = { + { + let output: Val<::bevy_transform::components::GlobalTransform> = ::bevy_transform::components::GlobalTransform::from_translation( + translation.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["translation"], + ) .register_documented( "from_xyz", |x: f32, y: f32, z: f32| { @@ -214,6 +285,26 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { "", &["_self", "transform"], ) + .register_documented( + "mul", + | + _self: Val<::bevy_transform::components::GlobalTransform>, + value: Val<::glam::Vec3>| + { + let output: Val<::glam::Vec3> = { + { + let output: Val<::glam::Vec3> = <::bevy_transform::components::GlobalTransform as ::core::ops::Mul< + ::glam::Vec3, + >>::mul(_self.into_inner(), value.into_inner()) + .into(); + output + } + }; + output + }, + "", + &["_self", "value"], + ) .register_documented( "mul_transform", | @@ -235,6 +326,27 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { " Multiplies `self` with `transform` component by component, returning the\n resulting [`GlobalTransform`]", &["_self", "transform"], ) + .register_documented( + "radius_vec3a", + | + _self: Ref<::bevy_transform::components::GlobalTransform>, + extents: Val<::glam::Vec3A>| + { + let output: f32 = { + { + let output: f32 = ::bevy_transform::components::GlobalTransform::radius_vec3a( + &_self, + extents.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Get an upper bound of the radius from the given `extents`.", + &["_self", "extents"], + ) .register_documented( "reparented_to", | @@ -273,6 +385,40 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { "Return the local right vector (X).", &["_self"], ) + .register_documented( + "rotation", + |_self: Ref<::bevy_transform::components::GlobalTransform>| { + let output: Val<::glam::Quat> = { + { + let output: Val<::glam::Quat> = ::bevy_transform::components::GlobalTransform::rotation( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the rotation as a [`Quat`].\n The transform is expected to be non-degenerate and without shearing, or the output will be invalid.\n # Warning\n This is calculated using `to_scale_rotation_translation`, meaning that you\n should probably use it directly if you also need translation or scale.", + &["_self"], + ) + .register_documented( + "scale", + |_self: Ref<::bevy_transform::components::GlobalTransform>| { + let output: Val<::glam::Vec3> = { + { + let output: Val<::glam::Vec3> = ::bevy_transform::components::GlobalTransform::scale( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the scale as a [`Vec3`].\n The transform is expected to be non-degenerate and without shearing, or the output will be invalid.\n Some of the computations overlap with `to_scale_rotation_translation`, which means you should use\n it instead if you also need rotation.", + &["_self"], + ) .register_documented( "to_isometry", |_self: Ref<::bevy_transform::components::GlobalTransform>| { @@ -290,6 +436,78 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { " Computes a Scale-Rotation-Translation decomposition of the transformation and returns\n the isometric part as an [isometry]. Any scaling done by the transformation will be ignored.\n Note: this is a somewhat costly and lossy conversion.\n The transform is expected to be non-degenerate and without shearing, or the output\n will be invalid.\n [isometry]: Isometry3d", &["_self"], ) + .register_documented( + "to_matrix", + |_self: Ref<::bevy_transform::components::GlobalTransform>| { + let output: Val<::glam::Mat4> = { + { + let output: Val<::glam::Mat4> = ::bevy_transform::components::GlobalTransform::to_matrix( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the 3d affine transformation matrix as a [`Mat4`].", + &["_self"], + ) + .register_documented( + "transform_point", + | + _self: Ref<::bevy_transform::components::GlobalTransform>, + point: Val<::glam::Vec3>| + { + let output: Val<::glam::Vec3> = { + { + let output: Val<::glam::Vec3> = ::bevy_transform::components::GlobalTransform::transform_point( + &_self, + point.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Transforms the given point from local space to global space, applying shear, scale, rotation and translation.\n It can be used like this:\n ```\n # use bevy_transform::prelude::{GlobalTransform};\n # use bevy_math::prelude::Vec3;\n let global_transform = GlobalTransform::from_xyz(1., 2., 3.);\n let local_point = Vec3::new(1., 2., 3.);\n let global_point = global_transform.transform_point(local_point);\n assert_eq!(global_point, Vec3::new(2., 4., 6.));\n ```\n ```\n # use bevy_transform::prelude::{GlobalTransform};\n # use bevy_math::Vec3;\n let global_point = Vec3::new(2., 4., 6.);\n let global_transform = GlobalTransform::from_xyz(1., 2., 3.);\n let local_point = global_transform.affine().inverse().transform_point3(global_point);\n assert_eq!(local_point, Vec3::new(1., 2., 3.))\n ```\n To apply shear, scale, and rotation *without* applying translation, different functions are available:\n ```\n # use bevy_transform::prelude::{GlobalTransform};\n # use bevy_math::prelude::Vec3;\n let global_transform = GlobalTransform::from_xyz(1., 2., 3.);\n let local_direction = Vec3::new(1., 2., 3.);\n let global_direction = global_transform.affine().transform_vector3(local_direction);\n assert_eq!(global_direction, Vec3::new(1., 2., 3.));\n let roundtripped_local_direction = global_transform.affine().inverse().transform_vector3(global_direction);\n assert_eq!(roundtripped_local_direction, local_direction);\n ```", + &["_self", "point"], + ) + .register_documented( + "translation", + |_self: Ref<::bevy_transform::components::GlobalTransform>| { + let output: Val<::glam::Vec3> = { + { + let output: Val<::glam::Vec3> = ::bevy_transform::components::GlobalTransform::translation( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the translation as a [`Vec3`].", + &["_self"], + ) + .register_documented( + "translation_vec3a", + |_self: Ref<::bevy_transform::components::GlobalTransform>| { + let output: Val<::glam::Vec3A> = { + { + let output: Val<::glam::Vec3A> = ::bevy_transform::components::GlobalTransform::translation_vec3a( + &_self, + ) + .into(); + output + } + }; + output + }, + " Get the translation as a [`Vec3A`].", + &["_self"], + ) .register_documented( "up", |_self: Ref<::bevy_transform::components::GlobalTransform>| { @@ -353,6 +571,23 @@ pub(crate) fn register_transform_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "compute_affine", + |_self: Ref<::bevy_transform::components::Transform>| { + let output: Val<::glam::Affine3A> = { + { + let output: Val<::glam::Affine3A> = ::bevy_transform::components::Transform::compute_affine( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the 3d affine transformation matrix from this transforms translation,\n rotation, and scale.", + &["_self"], + ) .register_documented( "down", |_self: Ref<::bevy_transform::components::Transform>| { @@ -424,6 +659,74 @@ pub(crate) fn register_transform_functions(world: &mut World) { " Creates a new [`Transform`] that is equivalent to the given [isometry].\n [isometry]: Isometry3d", &["iso"], ) + .register_documented( + "from_matrix", + |world_from_local: Val<::glam::Mat4>| { + let output: Val<::bevy_transform::components::Transform> = { + { + let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::from_matrix( + world_from_local.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Extracts the translation, rotation, and scale from `matrix`. It must be a 3d affine\n transformation matrix.", + &["world_from_local"], + ) + .register_documented( + "from_rotation", + |rotation: Val<::glam::Quat>| { + let output: Val<::bevy_transform::components::Transform> = { + { + let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::from_rotation( + rotation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a new [`Transform`], with `rotation`. Translation will be 0 and scale 1 on\n all axes.", + &["rotation"], + ) + .register_documented( + "from_scale", + |scale: Val<::glam::Vec3>| { + let output: Val<::bevy_transform::components::Transform> = { + { + let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::from_scale( + scale.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a new [`Transform`], with `scale`. Translation will be 0 and rotation 0 on\n all axes.", + &["scale"], + ) + .register_documented( + "from_translation", + |translation: Val<::glam::Vec3>| { + let output: Val<::bevy_transform::components::Transform> = { + { + let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::from_translation( + translation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a new [`Transform`], with `translation`. Rotation will be 0 and scale 1 on\n all axes.", + &["translation"], + ) .register_documented( "from_xyz", |x: f32, y: f32, z: f32| { @@ -568,6 +871,26 @@ pub(crate) fn register_transform_functions(world: &mut World) { "", &["_self", "transform"], ) + .register_documented( + "mul", + | + _self: Val<::bevy_transform::components::Transform>, + value: Val<::glam::Vec3>| + { + let output: Val<::glam::Vec3> = { + { + let output: Val<::glam::Vec3> = <::bevy_transform::components::Transform as ::core::ops::Mul< + ::glam::Vec3, + >>::mul(_self.into_inner(), value.into_inner()) + .into(); + output + } + }; + output + }, + "", + &["_self", "value"], + ) .register_documented( "mul_transform", | @@ -606,6 +929,50 @@ pub(crate) fn register_transform_functions(world: &mut World) { " Equivalent to [`local_x()`][Transform::local_x()]", &["_self"], ) + .register_documented( + "rotate", + | + mut _self: Mut<::bevy_transform::components::Transform>, + rotation: Val<::glam::Quat>| + { + let output: () = { + { + let output: () = ::bevy_transform::components::Transform::rotate( + &mut _self, + rotation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Rotates this [`Transform`] by the given rotation.\n If this [`Transform`] has a parent, the `rotation` is relative to the rotation of the parent.\n # Examples\n - [`3d_rotation`]\n [`3d_rotation`]: https://github.com/bevyengine/bevy/blob/latest/examples/transforms/3d_rotation.rs", + &["_self", "rotation"], + ) + .register_documented( + "rotate_around", + | + mut _self: Mut<::bevy_transform::components::Transform>, + point: Val<::glam::Vec3>, + rotation: Val<::glam::Quat>| + { + let output: () = { + { + let output: () = ::bevy_transform::components::Transform::rotate_around( + &mut _self, + point.into_inner(), + rotation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Rotates this [`Transform`] around a `point` in space.\n If this [`Transform`] has a parent, the `point` is relative to the [`Transform`] of the parent.", + &["_self", "point", "rotation"], + ) .register_documented( "rotate_axis", | @@ -629,6 +996,27 @@ pub(crate) fn register_transform_functions(world: &mut World) { " Rotates this [`Transform`] around the given `axis` by `angle` (in radians).\n If this [`Transform`] has a parent, the `axis` is relative to the rotation of the parent.\n # Warning\n If you pass in an `axis` based on the current rotation (e.g. obtained via [`Transform::local_x`]),\n floating point errors can accumulate exponentially when applying rotations repeatedly this way. This will\n result in a denormalized rotation. In this case, it is recommended to normalize the [`Transform::rotation`] after\n each call to this method.", &["_self", "axis", "angle"], ) + .register_documented( + "rotate_local", + | + mut _self: Mut<::bevy_transform::components::Transform>, + rotation: Val<::glam::Quat>| + { + let output: () = { + { + let output: () = ::bevy_transform::components::Transform::rotate_local( + &mut _self, + rotation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Rotates this [`Transform`] by the given `rotation`.\n The `rotation` is relative to this [`Transform`]'s current rotation.", + &["_self", "rotation"], + ) .register_documented( "rotate_local_axis", | @@ -777,6 +1165,67 @@ pub(crate) fn register_transform_functions(world: &mut World) { " Get the [isometry] defined by this transform's rotation and translation, ignoring scale.\n [isometry]: Isometry3d", &["_self"], ) + .register_documented( + "to_matrix", + |_self: Ref<::bevy_transform::components::Transform>| { + let output: Val<::glam::Mat4> = { + { + let output: Val<::glam::Mat4> = ::bevy_transform::components::Transform::to_matrix( + &_self, + ) + .into(); + output + } + }; + output + }, + " Computes the 3d affine transformation matrix from this transform's translation,\n rotation, and scale.", + &["_self"], + ) + .register_documented( + "transform_point", + | + _self: Ref<::bevy_transform::components::Transform>, + point: Val<::glam::Vec3>| + { + let output: Val<::glam::Vec3> = { + { + let output: Val<::glam::Vec3> = ::bevy_transform::components::Transform::transform_point( + &_self, + point.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Transforms the given `point`, applying scale, rotation and translation.\n If this [`Transform`] has an ancestor entity with a [`Transform`] component,\n [`Transform::transform_point`] will transform a point in local space into its\n parent transform's space.\n If this [`Transform`] does not have a parent, [`Transform::transform_point`] will\n transform a point in local space into worldspace coordinates.\n If you always want to transform a point in local space to worldspace, or if you need\n the inverse transformations, see [`GlobalTransform::transform_point()`].", + &["_self", "point"], + ) + .register_documented( + "translate_around", + | + mut _self: Mut<::bevy_transform::components::Transform>, + point: Val<::glam::Vec3>, + rotation: Val<::glam::Quat>| + { + let output: () = { + { + let output: () = ::bevy_transform::components::Transform::translate_around( + &mut _self, + point.into_inner(), + rotation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Translates this [`Transform`] around a `point` in space.\n If this [`Transform`] has a parent, the `point` is relative to the [`Transform`] of the parent.", + &["_self", "point", "rotation"], + ) .register_documented( "up", |_self: Ref<::bevy_transform::components::Transform>| { @@ -793,6 +1242,69 @@ pub(crate) fn register_transform_functions(world: &mut World) { }, " Equivalent to [`local_y()`][Transform::local_y]", &["_self"], + ) + .register_documented( + "with_rotation", + | + _self: Val<::bevy_transform::components::Transform>, + rotation: Val<::glam::Quat>| + { + let output: Val<::bevy_transform::components::Transform> = { + { + let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::with_rotation( + _self.into_inner(), + rotation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns this [`Transform`] with a new rotation.", + &["_self", "rotation"], + ) + .register_documented( + "with_scale", + | + _self: Val<::bevy_transform::components::Transform>, + scale: Val<::glam::Vec3>| + { + let output: Val<::bevy_transform::components::Transform> = { + { + let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::with_scale( + _self.into_inner(), + scale.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns this [`Transform`] with a new scale.", + &["_self", "scale"], + ) + .register_documented( + "with_translation", + | + _self: Val<::bevy_transform::components::Transform>, + translation: Val<::glam::Vec3>| + { + let output: Val<::bevy_transform::components::Transform> = { + { + let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::with_translation( + _self.into_inner(), + translation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns this [`Transform`] with a new translation.", + &["_self", "translation"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); diff --git a/crates/bindings/bevy_ui_bms_bindings/src/lib.rs b/crates/bindings/bevy_ui_bms_bindings/src/lib.rs index c489f86ae0..519a6de1d3 100644 --- a/crates/bindings/bevy_ui_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_ui_bms_bindings/src/lib.rs @@ -1,27 +1,30 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyUiScriptingPlugin; pub(crate) fn register_display_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::Display, + ::bevy_ui::Display, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ui::prelude::Display>| { + |_self: Ref<::bevy_ui::Display>| { let output: () = { { - let output: () = <::bevy_ui::prelude::Display as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_ui::Display as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -35,10 +38,10 @@ pub(crate) fn register_display_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::Display>| { - let output: Val<::bevy_ui::prelude::Display> = { + |_self: Ref<::bevy_ui::Display>| { + let output: Val<::bevy_ui::Display> = { { - let output: Val<::bevy_ui::prelude::Display> = <::bevy_ui::prelude::Display as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::Display> = <::bevy_ui::Display as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -52,14 +55,11 @@ pub(crate) fn register_display_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_ui::prelude::Display>, - other: Ref<::bevy_ui::prelude::Display>| - { + |_self: Ref<::bevy_ui::Display>, other: Ref<::bevy_ui::Display>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::Display as ::std::cmp::PartialEq< - ::bevy_ui::prelude::Display, + let output: bool = <::bevy_ui::Display as ::std::cmp::PartialEq< + ::bevy_ui::Display, >>::eq(&_self, &other) .into(); output @@ -74,7 +74,7 @@ pub(crate) fn register_display_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::Display, + ::bevy_ui::Display, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -169,39 +169,43 @@ pub(crate) fn register_text_shadow_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_ui::widget::TextShadow, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::widget::TextShadow>| { - let output: Val<::bevy_ui::widget::TextShadow> = { - { - let output: Val<::bevy_ui::widget::TextShadow> = - <::bevy_ui::widget::TextShadow as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::widget::TextShadow>, other: Ref<::bevy_ui::widget::TextShadow>| { - let output: bool = { - { - let output: bool = <::bevy_ui::widget::TextShadow as ::std::cmp::PartialEq< - ::bevy_ui::widget::TextShadow, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_ui::widget::TextShadow>| { + let output: Val<::bevy_ui::widget::TextShadow> = { + { + let output: Val<::bevy_ui::widget::TextShadow> = <::bevy_ui::widget::TextShadow as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::widget::TextShadow>, + other: Ref<::bevy_ui::widget::TextShadow>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::widget::TextShadow as ::std::cmp::PartialEq< + ::bevy_ui::widget::TextShadow, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -512,37 +516,40 @@ pub(crate) fn register_viewport_node_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_ui::widget::ViewportNode, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::widget::ViewportNode>| { - let output: Val<::bevy_ui::widget::ViewportNode> = { - { - let output: Val<::bevy_ui::widget::ViewportNode> = - <::bevy_ui::widget::ViewportNode as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "new", - |camera: Val<::bevy_ecs::entity::Entity>| { - let output: Val<::bevy_ui::widget::ViewportNode> = { - { - let output: Val<::bevy_ui::widget::ViewportNode> = - ::bevy_ui::widget::ViewportNode::new(camera.into_inner()).into(); - output - } - }; - output - }, - " Creates a new [`ViewportNode`] with a given `camera`.", - &["camera"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_ui::widget::ViewportNode>| { + let output: Val<::bevy_ui::widget::ViewportNode> = { + { + let output: Val<::bevy_ui::widget::ViewportNode> = <::bevy_ui::widget::ViewportNode as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "new", + |camera: Val<::bevy_ecs::entity::Entity>| { + let output: Val<::bevy_ui::widget::ViewportNode> = { + { + let output: Val<::bevy_ui::widget::ViewportNode> = ::bevy_ui::widget::ViewportNode::new( + camera.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a new [`ViewportNode`] with a given `camera`.", + &["camera"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -553,14 +560,14 @@ pub(crate) fn register_viewport_node_functions(world: &mut World) { } pub(crate) fn register_interaction_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::Interaction, + ::bevy_ui::Interaction, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ui::prelude::Interaction>| { + |_self: Ref<::bevy_ui::Interaction>| { let output: () = { { - let output: () = <::bevy_ui::prelude::Interaction as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_ui::Interaction as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -574,10 +581,10 @@ pub(crate) fn register_interaction_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::Interaction>| { - let output: Val<::bevy_ui::prelude::Interaction> = { + |_self: Ref<::bevy_ui::Interaction>| { + let output: Val<::bevy_ui::Interaction> = { { - let output: Val<::bevy_ui::prelude::Interaction> = <::bevy_ui::prelude::Interaction as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::Interaction> = <::bevy_ui::Interaction as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -591,14 +598,11 @@ pub(crate) fn register_interaction_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_ui::prelude::Interaction>, - other: Ref<::bevy_ui::prelude::Interaction>| - { + |_self: Ref<::bevy_ui::Interaction>, other: Ref<::bevy_ui::Interaction>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::Interaction as ::std::cmp::PartialEq< - ::bevy_ui::prelude::Interaction, + let output: bool = <::bevy_ui::Interaction as ::std::cmp::PartialEq< + ::bevy_ui::Interaction, >>::eq(&_self, &other) .into(); output @@ -613,83 +617,81 @@ pub(crate) fn register_interaction_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::Interaction, + ::bevy_ui::Interaction, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_ui_scale_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::UiScale, + ::bevy_ui::UiScale, >::new(world); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::UiScale, + ::bevy_ui::UiScale, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_computed_ui_target_camera_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::ComputedUiTargetCamera, + ::bevy_ui::ComputedUiTargetCamera, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::prelude::ComputedUiTargetCamera>| { - let output: Val<::bevy_ui::prelude::ComputedUiTargetCamera> = { - { - let output: Val<::bevy_ui::prelude::ComputedUiTargetCamera> = - <::bevy_ui::prelude::ComputedUiTargetCamera as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::prelude::ComputedUiTargetCamera>, - other: Ref<::bevy_ui::prelude::ComputedUiTargetCamera>| { - let output: bool = { - { - let output: bool = - <::bevy_ui::prelude::ComputedUiTargetCamera as ::std::cmp::PartialEq< - ::bevy_ui::prelude::ComputedUiTargetCamera, + .register_documented( + "clone", + |_self: Ref<::bevy_ui::ComputedUiTargetCamera>| { + let output: Val<::bevy_ui::ComputedUiTargetCamera> = { + { + let output: Val<::bevy_ui::ComputedUiTargetCamera> = <::bevy_ui::ComputedUiTargetCamera as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::ComputedUiTargetCamera>, + other: Ref<::bevy_ui::ComputedUiTargetCamera>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::ComputedUiTargetCamera as ::std::cmp::PartialEq< + ::bevy_ui::ComputedUiTargetCamera, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::ComputedUiTargetCamera, + ::bevy_ui::ComputedUiTargetCamera, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_computed_ui_render_target_info_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::ComputedUiRenderTargetInfo, + ::bevy_ui::ComputedUiRenderTargetInfo, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::ComputedUiRenderTargetInfo>| { - let output: Val<::bevy_ui::prelude::ComputedUiRenderTargetInfo> = { + |_self: Ref<::bevy_ui::ComputedUiRenderTargetInfo>| { + let output: Val<::bevy_ui::ComputedUiRenderTargetInfo> = { { - let output: Val< - ::bevy_ui::prelude::ComputedUiRenderTargetInfo, - > = <::bevy_ui::prelude::ComputedUiRenderTargetInfo as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::ComputedUiRenderTargetInfo> = <::bevy_ui::ComputedUiRenderTargetInfo as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -704,13 +706,13 @@ pub(crate) fn register_computed_ui_render_target_info_functions(world: &mut Worl .register_documented( "eq", | - _self: Ref<::bevy_ui::prelude::ComputedUiRenderTargetInfo>, - other: Ref<::bevy_ui::prelude::ComputedUiRenderTargetInfo>| + _self: Ref<::bevy_ui::ComputedUiRenderTargetInfo>, + other: Ref<::bevy_ui::ComputedUiRenderTargetInfo>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::ComputedUiRenderTargetInfo as ::std::cmp::PartialEq< - ::bevy_ui::prelude::ComputedUiRenderTargetInfo, + let output: bool = <::bevy_ui::ComputedUiRenderTargetInfo as ::std::cmp::PartialEq< + ::bevy_ui::ComputedUiRenderTargetInfo, >>::eq(&_self, &other) .into(); output @@ -721,12 +723,46 @@ pub(crate) fn register_computed_ui_render_target_info_functions(world: &mut Worl "", &["_self", "other"], ) + .register_documented( + "logical_size", + |_self: Ref<::bevy_ui::ComputedUiRenderTargetInfo>| { + let output: Val<::glam::Vec2> = { + { + let output: Val<::glam::Vec2> = ::bevy_ui::ComputedUiRenderTargetInfo::logical_size( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the size of the target camera's viewport in logical pixels.", + &["_self"], + ) + .register_documented( + "physical_size", + |_self: Ref<::bevy_ui::ComputedUiRenderTargetInfo>| { + let output: Val<::glam::UVec2> = { + { + let output: Val<::glam::UVec2> = ::bevy_ui::ComputedUiRenderTargetInfo::physical_size( + &_self, + ) + .into(); + output + } + }; + output + }, + " Returns the size of the target camera's viewport in physical pixels.", + &["_self"], + ) .register_documented( "scale_factor", - |_self: Ref<::bevy_ui::prelude::ComputedUiRenderTargetInfo>| { + |_self: Ref<::bevy_ui::ComputedUiRenderTargetInfo>| { let output: f32 = { { - let output: f32 = ::bevy_ui::prelude::ComputedUiRenderTargetInfo::scale_factor( + let output: f32 = ::bevy_ui::ComputedUiRenderTargetInfo::scale_factor( &_self, ) .into(); @@ -742,109 +778,127 @@ pub(crate) fn register_computed_ui_render_target_info_functions(world: &mut Worl let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::ComputedUiRenderTargetInfo, + ::bevy_ui::ComputedUiRenderTargetInfo, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_content_size_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::measurement::ContentSize, - >::new(world); + ::bevy_ui::ContentSize, + >::new(world) + .register_documented( + "fixed_size", + |size: Val<::glam::Vec2>| { + let output: Val<::bevy_ui::ContentSize> = { + { + let output: Val<::bevy_ui::ContentSize> = ::bevy_ui::ContentSize::fixed_size( + size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a `ContentSize` with a `Measure` that always returns given `size` argument, regardless of the UI layout's constraints.", + &["size"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::measurement::ContentSize, + ::bevy_ui::ContentSize, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_ui_global_transform_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::ui_transform::UiGlobalTransform, + ::bevy_ui::UiGlobalTransform, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::ui_transform::UiGlobalTransform>| { - let output: Val<::bevy_ui::ui_transform::UiGlobalTransform> = { - { - let output: Val<::bevy_ui::ui_transform::UiGlobalTransform> = - <::bevy_ui::ui_transform::UiGlobalTransform as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::ui_transform::UiGlobalTransform>, - other: Ref<::bevy_ui::ui_transform::UiGlobalTransform>| { - let output: bool = { - { - let output: bool = - <::bevy_ui::ui_transform::UiGlobalTransform as ::std::cmp::PartialEq< - ::bevy_ui::ui_transform::UiGlobalTransform, + .register_documented( + "clone", + |_self: Ref<::bevy_ui::UiGlobalTransform>| { + let output: Val<::bevy_ui::UiGlobalTransform> = { + { + let output: Val<::bevy_ui::UiGlobalTransform> = <::bevy_ui::UiGlobalTransform as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::UiGlobalTransform>, + other: Ref<::bevy_ui::UiGlobalTransform>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::UiGlobalTransform as ::std::cmp::PartialEq< + ::bevy_ui::UiGlobalTransform, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::ui_transform::UiGlobalTransform, + ::bevy_ui::UiGlobalTransform, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_calculated_clip_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::CalculatedClip, + ::bevy_ui::CalculatedClip, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::prelude::CalculatedClip>| { - let output: Val<::bevy_ui::prelude::CalculatedClip> = { - { - let output: Val<::bevy_ui::prelude::CalculatedClip> = - <::bevy_ui::prelude::CalculatedClip as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_ui::CalculatedClip>| { + let output: Val<::bevy_ui::CalculatedClip> = { + { + let output: Val<::bevy_ui::CalculatedClip> = <::bevy_ui::CalculatedClip as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::CalculatedClip, + ::bevy_ui::CalculatedClip, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_node_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::Node, + ::bevy_ui::Node, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::Node>| { - let output: Val<::bevy_ui::prelude::Node> = { + |_self: Ref<::bevy_ui::Node>| { + let output: Val<::bevy_ui::Node> = { { - let output: Val<::bevy_ui::prelude::Node> = <::bevy_ui::prelude::Node as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::Node> = <::bevy_ui::Node as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -858,11 +912,11 @@ pub(crate) fn register_node_functions(world: &mut World) { ) .register_documented( "eq", - |_self: Ref<::bevy_ui::prelude::Node>, other: Ref<::bevy_ui::prelude::Node>| { + |_self: Ref<::bevy_ui::Node>, other: Ref<::bevy_ui::Node>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::Node as ::std::cmp::PartialEq< - ::bevy_ui::prelude::Node, + let output: bool = <::bevy_ui::Node as ::std::cmp::PartialEq< + ::bevy_ui::Node, >>::eq(&_self, &other) .into(); output @@ -877,20 +931,20 @@ pub(crate) fn register_node_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::Node, + ::bevy_ui::Node, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_overflow_axis_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::OverflowAxis, + ::bevy_ui::OverflowAxis, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ui::prelude::OverflowAxis>| { + |_self: Ref<::bevy_ui::OverflowAxis>| { let output: () = { { - let output: () = <::bevy_ui::prelude::OverflowAxis as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_ui::OverflowAxis as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -904,10 +958,10 @@ pub(crate) fn register_overflow_axis_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::OverflowAxis>| { - let output: Val<::bevy_ui::prelude::OverflowAxis> = { + |_self: Ref<::bevy_ui::OverflowAxis>| { + let output: Val<::bevy_ui::OverflowAxis> = { { - let output: Val<::bevy_ui::prelude::OverflowAxis> = <::bevy_ui::prelude::OverflowAxis as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::OverflowAxis> = <::bevy_ui::OverflowAxis as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -921,14 +975,11 @@ pub(crate) fn register_overflow_axis_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_ui::prelude::OverflowAxis>, - other: Ref<::bevy_ui::prelude::OverflowAxis>| - { + |_self: Ref<::bevy_ui::OverflowAxis>, other: Ref<::bevy_ui::OverflowAxis>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::OverflowAxis as ::std::cmp::PartialEq< - ::bevy_ui::prelude::OverflowAxis, + let output: bool = <::bevy_ui::OverflowAxis as ::std::cmp::PartialEq< + ::bevy_ui::OverflowAxis, >>::eq(&_self, &other) .into(); output @@ -941,12 +992,10 @@ pub(crate) fn register_overflow_axis_functions(world: &mut World) { ) .register_documented( "is_visible", - |_self: Ref<::bevy_ui::prelude::OverflowAxis>| { + |_self: Ref<::bevy_ui::OverflowAxis>| { let output: bool = { { - let output: bool = ::bevy_ui::prelude::OverflowAxis::is_visible( - &_self, - ) + let output: bool = ::bevy_ui::OverflowAxis::is_visible(&_self) .into(); output } @@ -960,20 +1009,20 @@ pub(crate) fn register_overflow_axis_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::OverflowAxis, + ::bevy_ui::OverflowAxis, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_ui_target_camera_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::UiTargetCamera, + ::bevy_ui::UiTargetCamera, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ui::prelude::UiTargetCamera>| { + |_self: Ref<::bevy_ui::UiTargetCamera>| { let output: () = { { - let output: () = <::bevy_ui::prelude::UiTargetCamera as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_ui::UiTargetCamera as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -987,10 +1036,10 @@ pub(crate) fn register_ui_target_camera_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::UiTargetCamera>| { - let output: Val<::bevy_ui::prelude::UiTargetCamera> = { + |_self: Ref<::bevy_ui::UiTargetCamera>| { + let output: Val<::bevy_ui::UiTargetCamera> = { { - let output: Val<::bevy_ui::prelude::UiTargetCamera> = <::bevy_ui::prelude::UiTargetCamera as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::UiTargetCamera> = <::bevy_ui::UiTargetCamera as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1004,10 +1053,10 @@ pub(crate) fn register_ui_target_camera_functions(world: &mut World) { ) .register_documented( "entity", - |_self: Ref<::bevy_ui::prelude::UiTargetCamera>| { + |_self: Ref<::bevy_ui::UiTargetCamera>| { let output: Val<::bevy_ecs::entity::Entity> = { { - let output: Val<::bevy_ecs::entity::Entity> = ::bevy_ui::prelude::UiTargetCamera::entity( + let output: Val<::bevy_ecs::entity::Entity> = ::bevy_ui::UiTargetCamera::entity( &_self, ) .into(); @@ -1022,13 +1071,13 @@ pub(crate) fn register_ui_target_camera_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_ui::prelude::UiTargetCamera>, - other: Ref<::bevy_ui::prelude::UiTargetCamera>| + _self: Ref<::bevy_ui::UiTargetCamera>, + other: Ref<::bevy_ui::UiTargetCamera>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::UiTargetCamera as ::std::cmp::PartialEq< - ::bevy_ui::prelude::UiTargetCamera, + let output: bool = <::bevy_ui::UiTargetCamera as ::std::cmp::PartialEq< + ::bevy_ui::UiTargetCamera, >>::eq(&_self, &other) .into(); output @@ -1043,20 +1092,20 @@ pub(crate) fn register_ui_target_camera_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::UiTargetCamera, + ::bevy_ui::UiTargetCamera, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_computed_node_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::ComputedNode, + ::bevy_ui::ComputedNode, >::new(world) .register_documented( "border", - |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + |_self: Ref<::bevy_ui::ComputedNode>| { let output: Val<::bevy_sprite::BorderRect> = { { - let output: Val<::bevy_sprite::BorderRect> = ::bevy_ui::prelude::ComputedNode::border( + let output: Val<::bevy_sprite::BorderRect> = ::bevy_ui::ComputedNode::border( &_self, ) .into(); @@ -1070,10 +1119,10 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { ) .register_documented( "border_radius", - |_self: Ref<::bevy_ui::prelude::ComputedNode>| { - let output: Val<::bevy_ui::prelude::ResolvedBorderRadius> = { + |_self: Ref<::bevy_ui::ComputedNode>| { + let output: Val<::bevy_ui::ResolvedBorderRadius> = { { - let output: Val<::bevy_ui::prelude::ResolvedBorderRadius> = ::bevy_ui::prelude::ComputedNode::border_radius( + let output: Val<::bevy_ui::ResolvedBorderRadius> = ::bevy_ui::ComputedNode::border_radius( &_self, ) .into(); @@ -1087,10 +1136,10 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::ComputedNode>| { - let output: Val<::bevy_ui::prelude::ComputedNode> = { + |_self: Ref<::bevy_ui::ComputedNode>| { + let output: Val<::bevy_ui::ComputedNode> = { { - let output: Val<::bevy_ui::prelude::ComputedNode> = <::bevy_ui::prelude::ComputedNode as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::ComputedNode> = <::bevy_ui::ComputedNode as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1102,12 +1151,35 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { "", &["_self"], ) + .register_documented( + "contains_point", + | + _self: Ref<::bevy_ui::ComputedNode>, + transform: Val<::bevy_ui::UiGlobalTransform>, + point: Val<::glam::Vec2>| + { + let output: bool = { + { + let output: bool = ::bevy_ui::ComputedNode::contains_point( + &_self, + transform.into_inner(), + point.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "transform", "point"], + ) .register_documented( "content_inset", - |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + |_self: Ref<::bevy_ui::ComputedNode>| { let output: Val<::bevy_sprite::BorderRect> = { { - let output: Val<::bevy_sprite::BorderRect> = ::bevy_ui::prelude::ComputedNode::content_inset( + let output: Val<::bevy_sprite::BorderRect> = ::bevy_ui::ComputedNode::content_inset( &_self, ) .into(); @@ -1119,16 +1191,30 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { " Returns the combined inset on each edge including both padding and border thickness in physical pixels.", &["_self"], ) + .register_documented( + "content_size", + |_self: Ref<::bevy_ui::ComputedNode>| { + let output: Val<::glam::Vec2> = { + { + let output: Val<::glam::Vec2> = ::bevy_ui::ComputedNode::content_size( + &_self, + ) + .into(); + output + } + }; + output + }, + " The calculated node content size as width and height in physical pixels.\n Automatically calculated by [`ui_layout_system`](`super::layout::ui_layout_system`).", + &["_self"], + ) .register_documented( "eq", - | - _self: Ref<::bevy_ui::prelude::ComputedNode>, - other: Ref<::bevy_ui::prelude::ComputedNode>| - { + |_self: Ref<::bevy_ui::ComputedNode>, other: Ref<::bevy_ui::ComputedNode>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::ComputedNode as ::std::cmp::PartialEq< - ::bevy_ui::prelude::ComputedNode, + let output: bool = <::bevy_ui::ComputedNode as ::std::cmp::PartialEq< + ::bevy_ui::ComputedNode, >>::eq(&_self, &other) .into(); output @@ -1141,10 +1227,10 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { ) .register_documented( "inner_radius", - |_self: Ref<::bevy_ui::prelude::ComputedNode>| { - let output: Val<::bevy_ui::prelude::ResolvedBorderRadius> = { + |_self: Ref<::bevy_ui::ComputedNode>| { + let output: Val<::bevy_ui::ResolvedBorderRadius> = { { - let output: Val<::bevy_ui::prelude::ResolvedBorderRadius> = ::bevy_ui::prelude::ComputedNode::inner_radius( + let output: Val<::bevy_ui::ResolvedBorderRadius> = ::bevy_ui::ComputedNode::inner_radius( &_self, ) .into(); @@ -1158,10 +1244,10 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { ) .register_documented( "inverse_scale_factor", - |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + |_self: Ref<::bevy_ui::ComputedNode>| { let output: f32 = { { - let output: f32 = ::bevy_ui::prelude::ComputedNode::inverse_scale_factor( + let output: f32 = ::bevy_ui::ComputedNode::inverse_scale_factor( &_self, ) .into(); @@ -1175,12 +1261,10 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { ) .register_documented( "is_empty", - |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + |_self: Ref<::bevy_ui::ComputedNode>| { let output: bool = { { - let output: bool = ::bevy_ui::prelude::ComputedNode::is_empty( - &_self, - ) + let output: bool = ::bevy_ui::ComputedNode::is_empty(&_self) .into(); output } @@ -1192,12 +1276,10 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { ) .register_documented( "outline_offset", - |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + |_self: Ref<::bevy_ui::ComputedNode>| { let output: f32 = { { - let output: f32 = ::bevy_ui::prelude::ComputedNode::outline_offset( - &_self, - ) + let output: f32 = ::bevy_ui::ComputedNode::outline_offset(&_self) .into(); output } @@ -1209,10 +1291,10 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { ) .register_documented( "outline_radius", - |_self: Ref<::bevy_ui::prelude::ComputedNode>| { - let output: Val<::bevy_ui::prelude::ResolvedBorderRadius> = { + |_self: Ref<::bevy_ui::ComputedNode>| { + let output: Val<::bevy_ui::ResolvedBorderRadius> = { { - let output: Val<::bevy_ui::prelude::ResolvedBorderRadius> = ::bevy_ui::prelude::ComputedNode::outline_radius( + let output: Val<::bevy_ui::ResolvedBorderRadius> = ::bevy_ui::ComputedNode::outline_radius( &_self, ) .into(); @@ -1226,10 +1308,25 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { ) .register_documented( "outline_width", - |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + |_self: Ref<::bevy_ui::ComputedNode>| { let output: f32 = { { - let output: f32 = ::bevy_ui::prelude::ComputedNode::outline_width( + let output: f32 = ::bevy_ui::ComputedNode::outline_width(&_self) + .into(); + output + } + }; + output + }, + " Returns the thickness of the UI node's outline in physical pixels.\n If this value is negative or `0.` then no outline will be rendered.\n Automatically calculated by [`ui_layout_system`](`super::layout::ui_layout_system`).", + &["_self"], + ) + .register_documented( + "outlined_node_size", + |_self: Ref<::bevy_ui::ComputedNode>| { + let output: Val<::glam::Vec2> = { + { + let output: Val<::glam::Vec2> = ::bevy_ui::ComputedNode::outlined_node_size( &_self, ) .into(); @@ -1238,15 +1335,15 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { }; output }, - " Returns the thickness of the UI node's outline in physical pixels.\n If this value is negative or `0.` then no outline will be rendered.\n Automatically calculated by [`ui_layout_system`](`super::layout::ui_layout_system`).", + " Returns the size of the node when including its outline.\n Automatically calculated by [`ui_layout_system`](`super::layout::ui_layout_system`).", &["_self"], ) .register_documented( "padding", - |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + |_self: Ref<::bevy_ui::ComputedNode>| { let output: Val<::bevy_sprite::BorderRect> = { { - let output: Val<::bevy_sprite::BorderRect> = ::bevy_ui::prelude::ComputedNode::padding( + let output: Val<::bevy_sprite::BorderRect> = ::bevy_ui::ComputedNode::padding( &_self, ) .into(); @@ -1261,13 +1358,13 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { .register_documented( "resolve_clip_rect", | - _self: Ref<::bevy_ui::prelude::ComputedNode>, - overflow: Val<::bevy_ui::prelude::Overflow>, - overflow_clip_margin: Val<::bevy_ui::prelude::OverflowClipMargin>| + _self: Ref<::bevy_ui::ComputedNode>, + overflow: Val<::bevy_ui::Overflow>, + overflow_clip_margin: Val<::bevy_ui::OverflowClipMargin>| { let output: Val<::bevy_math::Rect> = { { - let output: Val<::bevy_math::Rect> = ::bevy_ui::prelude::ComputedNode::resolve_clip_rect( + let output: Val<::bevy_math::Rect> = ::bevy_ui::ComputedNode::resolve_clip_rect( &_self, overflow.into_inner(), overflow_clip_margin.into_inner(), @@ -1281,12 +1378,44 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { " Resolve the node's clipping rect in local space", &["_self", "overflow", "overflow_clip_margin"], ) + .register_documented( + "size", + |_self: Ref<::bevy_ui::ComputedNode>| { + let output: Val<::glam::Vec2> = { + { + let output: Val<::glam::Vec2> = ::bevy_ui::ComputedNode::size( + &_self, + ) + .into(); + output + } + }; + output + }, + " The calculated node size as width and height in physical pixels.\n Automatically calculated by [`ui_layout_system`](`super::layout::ui_layout_system`).", + &["_self"], + ) .register_documented( "stack_index", - |_self: Ref<::bevy_ui::prelude::ComputedNode>| { + |_self: Ref<::bevy_ui::ComputedNode>| { let output: u32 = { { - let output: u32 = ::bevy_ui::prelude::ComputedNode::stack_index( + let output: u32 = ::bevy_ui::ComputedNode::stack_index(&_self) + .into(); + output + } + }; + output + }, + " The order of the node in the UI layout.\n Nodes with a higher stack index are drawn on top of and receive interactions before nodes with lower stack indices.\n Automatically calculated in [`UiSystems::Stack`](super::UiSystems::Stack).", + &["_self"], + ) + .register_documented( + "unrounded_size", + |_self: Ref<::bevy_ui::ComputedNode>| { + let output: Val<::glam::Vec2> = { + { + let output: Val<::glam::Vec2> = ::bevy_ui::ComputedNode::unrounded_size( &_self, ) .into(); @@ -1295,27 +1424,27 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { }; output }, - " The order of the node in the UI layout.\n Nodes with a higher stack index are drawn on top of and receive interactions before nodes with lower stack indices.\n Automatically calculated in [`UiSystems::Stack`](super::UiSystems::Stack).", + " The calculated node size as width and height in physical pixels before rounding.\n Automatically calculated by [`ui_layout_system`](`super::layout::ui_layout_system`).", &["_self"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::ComputedNode, + ::bevy_ui::ComputedNode, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_overflow_clip_box_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::OverflowClipBox, + ::bevy_ui::OverflowClipBox, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ui::prelude::OverflowClipBox>| { + |_self: Ref<::bevy_ui::OverflowClipBox>| { let output: () = { { - let output: () = <::bevy_ui::prelude::OverflowClipBox as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_ui::OverflowClipBox as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -1329,10 +1458,10 @@ pub(crate) fn register_overflow_clip_box_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::OverflowClipBox>| { - let output: Val<::bevy_ui::prelude::OverflowClipBox> = { + |_self: Ref<::bevy_ui::OverflowClipBox>| { + let output: Val<::bevy_ui::OverflowClipBox> = { { - let output: Val<::bevy_ui::prelude::OverflowClipBox> = <::bevy_ui::prelude::OverflowClipBox as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::OverflowClipBox> = <::bevy_ui::OverflowClipBox as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -1347,13 +1476,13 @@ pub(crate) fn register_overflow_clip_box_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_ui::prelude::OverflowClipBox>, - other: Ref<::bevy_ui::prelude::OverflowClipBox>| + _self: Ref<::bevy_ui::OverflowClipBox>, + other: Ref<::bevy_ui::OverflowClipBox>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::OverflowClipBox as ::std::cmp::PartialEq< - ::bevy_ui::prelude::OverflowClipBox, + let output: bool = <::bevy_ui::OverflowClipBox as ::std::cmp::PartialEq< + ::bevy_ui::OverflowClipBox, >>::eq(&_self, &other) .into(); output @@ -1368,7 +1497,7 @@ pub(crate) fn register_overflow_clip_box_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::OverflowClipBox, + ::bevy_ui::OverflowClipBox, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -1430,350 +1559,120 @@ pub(crate) fn register_focus_policy_functions(world: &mut World) { let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::bevy_ui::FocusPolicy, bevy_mod_scripting_bindings::MarkAsGenerated>( - ); + .register_type_data::< + ::bevy_ui::FocusPolicy, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_image_node_size_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_ui::widget::ImageNodeSize, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::widget::ImageNodeSize>| { - let output: Val<::bevy_ui::widget::ImageNodeSize> = { - { - let output: Val<::bevy_ui::widget::ImageNodeSize> = - <::bevy_ui::widget::ImageNodeSize as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_ui::widget::ImageNodeSize, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_text_node_flags_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::widget::TextNodeFlags, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::widget::TextNodeFlags>| { - let output: Val<::bevy_ui::widget::TextNodeFlags> = { - { - let output: Val<::bevy_ui::widget::TextNodeFlags> = - <::bevy_ui::widget::TextNodeFlags as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_ui::widget::ImageNodeSize>| { + let output: Val<::bevy_ui::widget::ImageNodeSize> = { + { + let output: Val<::bevy_ui::widget::ImageNodeSize> = <::bevy_ui::widget::ImageNodeSize as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "size", + |_self: Ref<::bevy_ui::widget::ImageNodeSize>| { + let output: Val<::glam::UVec2> = { + { + let output: Val<::glam::UVec2> = ::bevy_ui::widget::ImageNodeSize::size( + &_self, + ) + .into(); + output + } + }; + output + }, + " The size of the image's texture", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::widget::TextNodeFlags, + ::bevy_ui::widget::ImageNodeSize, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_ui_position_functions(world: &mut World) { +pub(crate) fn register_text_node_flags_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::UiPosition, + ::bevy_ui::widget::TextNodeFlags, >::new(world) - .register_documented( - "at", - |_self: Val<::bevy_ui::prelude::UiPosition>, - x: Val<::bevy_ui::prelude::Val>, - y: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiPosition> = { - { - let output: Val<::bevy_ui::prelude::UiPosition> = - ::bevy_ui::prelude::UiPosition::at( - _self.into_inner(), - x.into_inner(), - y.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Creates a position from self with the given `x` and `y` coordinates", - &["_self", "x", "y"], - ) - .register_documented( - "at_percent", - |_self: Val<::bevy_ui::prelude::UiPosition>, x: f32, y: f32| { - let output: Val<::bevy_ui::prelude::UiPosition> = { - { - let output: Val<::bevy_ui::prelude::UiPosition> = - ::bevy_ui::prelude::UiPosition::at_percent(_self.into_inner(), x, y).into(); - output - } - }; - output - }, - " Creates a percentage position from self with the given `x` and `y` coordinates", - &["_self", "x", "y"], - ) - .register_documented( - "at_px", - |_self: Val<::bevy_ui::prelude::UiPosition>, x: f32, y: f32| { - let output: Val<::bevy_ui::prelude::UiPosition> = { - { - let output: Val<::bevy_ui::prelude::UiPosition> = - ::bevy_ui::prelude::UiPosition::at_px(_self.into_inner(), x, y).into(); - output - } - }; - output - }, - " Creates a position in logical pixels from self with the given `x` and `y` coordinates", - &["_self", "x", "y"], - ) - .register_documented( - "at_x", - |_self: Val<::bevy_ui::prelude::UiPosition>, x: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiPosition> = { - { - let output: Val<::bevy_ui::prelude::UiPosition> = - ::bevy_ui::prelude::UiPosition::at_x(_self.into_inner(), x.into_inner()) - .into(); - output - } - }; - output - }, - " Creates a position from self with the given `x` coordinate", - &["_self", "x"], - ) - .register_documented( - "at_y", - |_self: Val<::bevy_ui::prelude::UiPosition>, y: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiPosition> = { - { - let output: Val<::bevy_ui::prelude::UiPosition> = - ::bevy_ui::prelude::UiPosition::at_y(_self.into_inner(), y.into_inner()) - .into(); - output - } - }; - output - }, - " Creates a position from self with the given `y` coordinate", - &["_self", "y"], - ) - .register_documented( - "bottom", - |x: Val<::bevy_ui::prelude::Val>, y: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiPosition> = { - { - let output: Val<::bevy_ui::prelude::UiPosition> = - ::bevy_ui::prelude::UiPosition::bottom(x.into_inner(), y.into_inner()) - .into(); - output - } - }; - output - }, - " Position relative to the bottom edge", - &["x", "y"], - ) - .register_documented( - "bottom_left", - |x: Val<::bevy_ui::prelude::Val>, y: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiPosition> = { - { - let output: Val<::bevy_ui::prelude::UiPosition> = - ::bevy_ui::prelude::UiPosition::bottom_left(x.into_inner(), y.into_inner()) - .into(); - output - } - }; - output - }, - " Position relative to the bottom-left corner", - &["x", "y"], - ) - .register_documented( - "bottom_right", - |x: Val<::bevy_ui::prelude::Val>, y: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiPosition> = { - { - let output: Val<::bevy_ui::prelude::UiPosition> = - ::bevy_ui::prelude::UiPosition::bottom_right( - x.into_inner(), - y.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Position relative to the bottom-right corner", - &["x", "y"], - ) - .register_documented( - "center", - |x: Val<::bevy_ui::prelude::Val>, y: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiPosition> = { - { - let output: Val<::bevy_ui::prelude::UiPosition> = - ::bevy_ui::prelude::UiPosition::center(x.into_inner(), y.into_inner()) - .into(); - output - } - }; - output - }, - " Position relative to the center", - &["x", "y"], - ) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::prelude::UiPosition>| { - let output: Val<::bevy_ui::prelude::UiPosition> = { - { - let output: Val<::bevy_ui::prelude::UiPosition> = - <::bevy_ui::prelude::UiPosition as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::prelude::UiPosition>, other: Ref<::bevy_ui::prelude::UiPosition>| { - let output: bool = { - { - let output: bool = <::bevy_ui::prelude::UiPosition as ::std::cmp::PartialEq< - ::bevy_ui::prelude::UiPosition, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "left", - |x: Val<::bevy_ui::prelude::Val>, y: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiPosition> = { - { - let output: Val<::bevy_ui::prelude::UiPosition> = - ::bevy_ui::prelude::UiPosition::left(x.into_inner(), y.into_inner()).into(); - output - } - }; - output - }, - " Position relative to the left edge", - &["x", "y"], - ) - .register_documented( - "right", - |x: Val<::bevy_ui::prelude::Val>, y: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiPosition> = { - { - let output: Val<::bevy_ui::prelude::UiPosition> = - ::bevy_ui::prelude::UiPosition::right(x.into_inner(), y.into_inner()) - .into(); - output - } - }; - output - }, - " Position relative to the right edge", - &["x", "y"], - ) - .register_documented( - "top", - |x: Val<::bevy_ui::prelude::Val>, y: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiPosition> = { - { - let output: Val<::bevy_ui::prelude::UiPosition> = - ::bevy_ui::prelude::UiPosition::top(x.into_inner(), y.into_inner()).into(); - output - } - }; - output - }, - " Position relative to the top edge", - &["x", "y"], - ) - .register_documented( - "top_left", - |x: Val<::bevy_ui::prelude::Val>, y: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiPosition> = { - { - let output: Val<::bevy_ui::prelude::UiPosition> = - ::bevy_ui::prelude::UiPosition::top_left(x.into_inner(), y.into_inner()) - .into(); - output - } - }; - output - }, - " Position relative to the top-left corner", - &["x", "y"], - ) - .register_documented( - "top_right", - |x: Val<::bevy_ui::prelude::Val>, y: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiPosition> = { - { - let output: Val<::bevy_ui::prelude::UiPosition> = - ::bevy_ui::prelude::UiPosition::top_right(x.into_inner(), y.into_inner()) - .into(); - output - } - }; - output - }, - " Position relative to the top-right corner", - &["x", "y"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_ui::widget::TextNodeFlags>| { + let output: Val<::bevy_ui::widget::TextNodeFlags> = { + { + let output: Val<::bevy_ui::widget::TextNodeFlags> = <::bevy_ui::widget::TextNodeFlags as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::UiPosition, + ::bevy_ui::widget::TextNodeFlags, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_val_functions(world: &mut World) { +pub(crate) fn register_ui_position_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::Val, + ::bevy_ui::UiPosition, >::new(world) .register_documented( - "all", - |_self: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiRect> = { + "anchor", + |anchor: Val<::glam::Vec2>| { + let output: Val<::bevy_ui::UiPosition> = { + { + let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::anchor( + anchor.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Position at the given normalized anchor point", + &["anchor"], + ) + .register_documented( + "at", + | + _self: Val<::bevy_ui::UiPosition>, + x: Val<::bevy_ui::Val>, + y: Val<::bevy_ui::Val>| + { + let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::Val::all( + let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::at( _self.into_inner(), + x.into_inner(), + y.into_inner(), ) .into(); output @@ -1781,16 +1680,18 @@ pub(crate) fn register_val_functions(world: &mut World) { }; output }, - " Returns a [`UiRect`] with all its fields equal to this value.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = Val::Px(1.).all();\n assert_eq!(ui_rect.left, Val::Px(1.));\n assert_eq!(ui_rect.right, Val::Px(1.));\n assert_eq!(ui_rect.top, Val::Px(1.));\n assert_eq!(ui_rect.bottom, Val::Px(1.));\n ```", - &["_self"], + " Creates a position from self with the given `x` and `y` coordinates", + &["_self", "x", "y"], ) .register_documented( - "bottom", - |_self: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiRect> = { + "at_percent", + |_self: Val<::bevy_ui::UiPosition>, x: f32, y: f32| { + let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::Val::bottom( + let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::at_percent( _self.into_inner(), + x, + y, ) .into(); output @@ -1798,16 +1699,18 @@ pub(crate) fn register_val_functions(world: &mut World) { }; output }, - " Returns a [`UiRect`] with its `bottom` equal to this value,\n and all other fields set to `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = Val::Px(1.).bottom();\n assert_eq!(ui_rect.left, Val::ZERO);\n assert_eq!(ui_rect.right, Val::ZERO);\n assert_eq!(ui_rect.top, Val::ZERO);\n assert_eq!(ui_rect.bottom, Val::Px(1.));\n ```", - &["_self"], + " Creates a percentage position from self with the given `x` and `y` coordinates", + &["_self", "x", "y"], ) .register_documented( - "clone", - |_self: Ref<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::Val> = { + "at_px", + |_self: Val<::bevy_ui::UiPosition>, x: f32, y: f32| { + let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::prelude::Val> = <::bevy_ui::prelude::Val as ::std::clone::Clone>::clone( - &_self, + let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::at_px( + _self.into_inner(), + x, + y, ) .into(); output @@ -1815,17 +1718,125 @@ pub(crate) fn register_val_functions(world: &mut World) { }; output }, - "", - &["_self"], + " Creates a position in logical pixels from self with the given `x` and `y` coordinates", + &["_self", "x", "y"], ) .register_documented( - "div", - |_self: Val<::bevy_ui::prelude::Val>, rhs: f32| { - let output: Val<::bevy_ui::prelude::Val> = { + "at_x", + |_self: Val<::bevy_ui::UiPosition>, x: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::prelude::Val> = <::bevy_ui::prelude::Val as ::std::ops::Div< - f32, - >>::div(_self.into_inner(), rhs) + let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::at_x( + _self.into_inner(), + x.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a position from self with the given `x` coordinate", + &["_self", "x"], + ) + .register_documented( + "at_y", + |_self: Val<::bevy_ui::UiPosition>, y: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiPosition> = { + { + let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::at_y( + _self.into_inner(), + y.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a position from self with the given `y` coordinate", + &["_self", "y"], + ) + .register_documented( + "bottom", + |x: Val<::bevy_ui::Val>, y: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiPosition> = { + { + let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::bottom( + x.into_inner(), + y.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Position relative to the bottom edge", + &["x", "y"], + ) + .register_documented( + "bottom_left", + |x: Val<::bevy_ui::Val>, y: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiPosition> = { + { + let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::bottom_left( + x.into_inner(), + y.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Position relative to the bottom-left corner", + &["x", "y"], + ) + .register_documented( + "bottom_right", + |x: Val<::bevy_ui::Val>, y: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiPosition> = { + { + let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::bottom_right( + x.into_inner(), + y.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Position relative to the bottom-right corner", + &["x", "y"], + ) + .register_documented( + "center", + |x: Val<::bevy_ui::Val>, y: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiPosition> = { + { + let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::center( + x.into_inner(), + y.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Position relative to the center", + &["x", "y"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::UiPosition>| { + let output: Val<::bevy_ui::UiPosition> = { + { + let output: Val<::bevy_ui::UiPosition> = <::bevy_ui::UiPosition as ::std::clone::Clone>::clone( + &_self, + ) .into(); output } @@ -1833,15 +1844,15 @@ pub(crate) fn register_val_functions(world: &mut World) { output }, "", - &["_self", "rhs"], + &["_self"], ) .register_documented( "eq", - |_self: Ref<::bevy_ui::prelude::Val>, other: Ref<::bevy_ui::prelude::Val>| { + |_self: Ref<::bevy_ui::UiPosition>, other: Ref<::bevy_ui::UiPosition>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::Val as ::std::cmp::PartialEq< - ::bevy_ui::prelude::Val, + let output: bool = <::bevy_ui::UiPosition as ::std::cmp::PartialEq< + ::bevy_ui::UiPosition, >>::eq(&_self, &other) .into(); output @@ -1853,12 +1864,13 @@ pub(crate) fn register_val_functions(world: &mut World) { &["_self", "other"], ) .register_documented( - "horizontal", - |_self: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiRect> = { + "left", + |x: Val<::bevy_ui::Val>, y: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::Val::horizontal( - _self.into_inner(), + let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::left( + x.into_inner(), + y.into_inner(), ) .into(); output @@ -1866,16 +1878,43 @@ pub(crate) fn register_val_functions(world: &mut World) { }; output }, - " Returns a [`UiRect`] with all its `left` and `right` equal to this value,\n and its `top` and `bottom` set to `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = Val::Px(1.).horizontal();\n assert_eq!(ui_rect.left, Val::Px(1.));\n assert_eq!(ui_rect.right, Val::Px(1.));\n assert_eq!(ui_rect.top, Val::ZERO);\n assert_eq!(ui_rect.bottom, Val::ZERO);\n ```", - &["_self"], + " Position relative to the left edge", + &["x", "y"], ) .register_documented( - "left", - |_self: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiRect> = { + "new", + |anchor: Val<::glam::Vec2>, x: Val<::bevy_ui::Val>, y: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiPosition> = { + { + let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::new( + anchor.into_inner(), + x.into_inner(), + y.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Create a new position", + &["anchor", "x", "y"], + ) + .register_documented( + "resolve", + | + _self: Val<::bevy_ui::UiPosition>, + scale_factor: f32, + physical_size: Val<::glam::Vec2>, + physical_target_size: Val<::glam::Vec2>| + { + let output: Val<::glam::Vec2> = { { - let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::Val::left( + let output: Val<::glam::Vec2> = ::bevy_ui::UiPosition::resolve( _self.into_inner(), + scale_factor, + physical_size.into_inner(), + physical_target_size.into_inner(), ) .into(); output @@ -1883,33 +1922,35 @@ pub(crate) fn register_val_functions(world: &mut World) { }; output }, - " Returns a [`UiRect`] with its `left` equal to this value,\n and all other fields set to `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = Val::Px(1.).left();\n assert_eq!(ui_rect.left, Val::Px(1.));\n assert_eq!(ui_rect.right, Val::ZERO);\n assert_eq!(ui_rect.top, Val::ZERO);\n assert_eq!(ui_rect.bottom, Val::ZERO);\n ```", - &["_self"], + " Resolves the `Position` into physical coordinates.", + &["_self", "scale_factor", "physical_size", "physical_target_size"], ) .register_documented( - "mul", - |_self: Val<::bevy_ui::prelude::Val>, rhs: f32| { - let output: Val<::bevy_ui::prelude::Val> = { + "right", + |x: Val<::bevy_ui::Val>, y: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::prelude::Val> = <::bevy_ui::prelude::Val as ::std::ops::Mul< - f32, - >>::mul(_self.into_inner(), rhs) + let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::right( + x.into_inner(), + y.into_inner(), + ) .into(); output } }; output }, - "", - &["_self", "rhs"], + " Position relative to the right edge", + &["x", "y"], ) .register_documented( - "neg", - |_self: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::Val> = { + "top", + |x: Val<::bevy_ui::Val>, y: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::prelude::Val> = <::bevy_ui::prelude::Val as ::std::ops::Neg>::neg( - _self.into_inner(), + let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::top( + x.into_inner(), + y.into_inner(), ) .into(); output @@ -1917,16 +1958,17 @@ pub(crate) fn register_val_functions(world: &mut World) { }; output }, - "", - &["_self"], + " Position relative to the top edge", + &["x", "y"], ) .register_documented( - "right", - |_self: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiRect> = { + "top_left", + |x: Val<::bevy_ui::Val>, y: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::Val::right( - _self.into_inner(), + let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::top_left( + x.into_inner(), + y.into_inner(), ) .into(); output @@ -1934,16 +1976,17 @@ pub(crate) fn register_val_functions(world: &mut World) { }; output }, - " Returns a [`UiRect`] with its `right` equal to this value,\n and all other fields set to `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = Val::Px(1.).right();\n assert_eq!(ui_rect.left, Val::ZERO);\n assert_eq!(ui_rect.right, Val::Px(1.));\n assert_eq!(ui_rect.top, Val::ZERO);\n assert_eq!(ui_rect.bottom, Val::ZERO);\n ```", - &["_self"], + " Position relative to the top-left corner", + &["x", "y"], ) .register_documented( - "top", - |_self: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiRect> = { + "top_right", + |x: Val<::bevy_ui::Val>, y: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::Val::top( - _self.into_inner(), + let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::top_right( + x.into_inner(), + y.into_inner(), ) .into(); output @@ -1951,16 +1994,17 @@ pub(crate) fn register_val_functions(world: &mut World) { }; output }, - " Returns a [`UiRect`] with its `top` equal to this value,\n and all other fields set to `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = Val::Px(1.).top();\n assert_eq!(ui_rect.left, Val::ZERO);\n assert_eq!(ui_rect.right, Val::ZERO);\n assert_eq!(ui_rect.top, Val::Px(1.));\n assert_eq!(ui_rect.bottom, Val::ZERO);\n ```", - &["_self"], + " Position relative to the top-right corner", + &["x", "y"], ) .register_documented( - "vertical", - |_self: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiRect> = { + "with_anchor", + |_self: Val<::bevy_ui::UiPosition>, anchor: Val<::glam::Vec2>| { + let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::Val::vertical( + let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::with_anchor( _self.into_inner(), + anchor.into_inner(), ) .into(); output @@ -1968,223 +2012,28 @@ pub(crate) fn register_val_functions(world: &mut World) { }; output }, - " Returns a [`UiRect`] with all its `top` and `bottom` equal to this value,\n and its `left` and `right` set to `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = Val::Px(1.).vertical();\n assert_eq!(ui_rect.left, Val::ZERO);\n assert_eq!(ui_rect.right, Val::ZERO);\n assert_eq!(ui_rect.top, Val::Px(1.));\n assert_eq!(ui_rect.bottom, Val::Px(1.));\n ```", - &["_self"], + " Creates a position from self with the given `anchor` point", + &["_self", "anchor"], ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::Val, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_color_stop_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::gradients::ColorStop, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::gradients::ColorStop>| { - let output: Val<::bevy_ui::gradients::ColorStop> = { - { - let output: Val<::bevy_ui::gradients::ColorStop> = - <::bevy_ui::gradients::ColorStop as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::gradients::ColorStop>, - other: Ref<::bevy_ui::gradients::ColorStop>| { - let output: bool = { - { - let output: bool = <::bevy_ui::gradients::ColorStop as ::std::cmp::PartialEq< - ::bevy_ui::gradients::ColorStop, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "with_hint", - |_self: Val<::bevy_ui::gradients::ColorStop>, hint: f32| { - let output: Val<::bevy_ui::gradients::ColorStop> = { - { - let output: Val<::bevy_ui::gradients::ColorStop> = - ::bevy_ui::gradients::ColorStop::with_hint(_self.into_inner(), hint).into(); - output - } - }; - output - }, - "", - &["_self", "hint"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_ui::gradients::ColorStop, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_angular_color_stop_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::gradients::AngularColorStop, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::gradients::AngularColorStop>| { - let output: Val<::bevy_ui::gradients::AngularColorStop> = { - { - let output: Val<::bevy_ui::gradients::AngularColorStop> = - <::bevy_ui::gradients::AngularColorStop as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::gradients::AngularColorStop>, - other: Ref<::bevy_ui::gradients::AngularColorStop>| { - let output: bool = { - { - let output: bool = - <::bevy_ui::gradients::AngularColorStop as ::std::cmp::PartialEq< - ::bevy_ui::gradients::AngularColorStop, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "with_hint", - |_self: Val<::bevy_ui::gradients::AngularColorStop>, hint: f32| { - let output: Val<::bevy_ui::gradients::AngularColorStop> = { - { - let output: Val<::bevy_ui::gradients::AngularColorStop> = - ::bevy_ui::gradients::AngularColorStop::with_hint(_self.into_inner(), hint) - .into(); - output - } - }; - output - }, - "", - &["_self", "hint"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_ui::gradients::AngularColorStop, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); -} -pub(crate) fn register_linear_gradient_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::gradients::LinearGradient, - >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::gradients::LinearGradient>| { - let output: Val<::bevy_ui::gradients::LinearGradient> = { - { - let output: Val<::bevy_ui::gradients::LinearGradient> = - <::bevy_ui::gradients::LinearGradient as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::gradients::LinearGradient>, - other: Ref<::bevy_ui::gradients::LinearGradient>| { - let output: bool = { - { - let output: bool = - <::bevy_ui::gradients::LinearGradient as ::std::cmp::PartialEq< - ::bevy_ui::gradients::LinearGradient, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "in_color_space", - |_self: Val<::bevy_ui::gradients::LinearGradient>, - color_space: Val<::bevy_ui::gradients::InterpolationColorSpace>| { - let output: Val<::bevy_ui::gradients::LinearGradient> = { - { - let output: Val<::bevy_ui::gradients::LinearGradient> = - ::bevy_ui::gradients::LinearGradient::in_color_space( - _self.into_inner(), - color_space.into_inner(), - ) - .into(); - output - } - }; - output - }, - "", - &["_self", "color_space"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); - registry - .register_type_data::< - ::bevy_ui::gradients::LinearGradient, + ::bevy_ui::UiPosition, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } -pub(crate) fn register_interpolation_color_space_functions(world: &mut World) { +pub(crate) fn register_val_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::gradients::InterpolationColorSpace, + ::bevy_ui::Val, >::new(world) .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ui::gradients::InterpolationColorSpace>| { - let output: () = { + "all", + |_self: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiRect> = { { - let output: () = <::bevy_ui::gradients::InterpolationColorSpace as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, + let output: Val<::bevy_ui::UiRect> = ::bevy_ui::Val::all( + _self.into_inner(), ) .into(); output @@ -2192,16 +2041,16 @@ pub(crate) fn register_interpolation_color_space_functions(world: &mut World) { }; output }, - "", + " Returns a [`UiRect`] with all its fields equal to this value.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = Val::Px(1.).all();\n assert_eq!(ui_rect.left, Val::Px(1.));\n assert_eq!(ui_rect.right, Val::Px(1.));\n assert_eq!(ui_rect.top, Val::Px(1.));\n assert_eq!(ui_rect.bottom, Val::Px(1.));\n ```", &["_self"], ) .register_documented( - "clone", - |_self: Ref<::bevy_ui::gradients::InterpolationColorSpace>| { - let output: Val<::bevy_ui::gradients::InterpolationColorSpace> = { + "bottom", + |_self: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::gradients::InterpolationColorSpace> = <::bevy_ui::gradients::InterpolationColorSpace as ::std::clone::Clone>::clone( - &_self, + let output: Val<::bevy_ui::UiRect> = ::bevy_ui::Val::bottom( + _self.into_inner(), ) .into(); output @@ -2209,20 +2058,17 @@ pub(crate) fn register_interpolation_color_space_functions(world: &mut World) { }; output }, - "", + " Returns a [`UiRect`] with its `bottom` equal to this value,\n and all other fields set to `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = Val::Px(1.).bottom();\n assert_eq!(ui_rect.left, Val::ZERO);\n assert_eq!(ui_rect.right, Val::ZERO);\n assert_eq!(ui_rect.top, Val::ZERO);\n assert_eq!(ui_rect.bottom, Val::Px(1.));\n ```", &["_self"], ) .register_documented( - "eq", - | - _self: Ref<::bevy_ui::gradients::InterpolationColorSpace>, - other: Ref<::bevy_ui::gradients::InterpolationColorSpace>| - { - let output: bool = { + "clone", + |_self: Ref<::bevy_ui::Val>| { + let output: Val<::bevy_ui::Val> = { { - let output: bool = <::bevy_ui::gradients::InterpolationColorSpace as ::std::cmp::PartialEq< - ::bevy_ui::gradients::InterpolationColorSpace, - >>::eq(&_self, &other) + let output: Val<::bevy_ui::Val> = <::bevy_ui::Val as ::std::clone::Clone>::clone( + &_self, + ) .into(); output } @@ -2230,564 +2076,1087 @@ pub(crate) fn register_interpolation_color_space_functions(world: &mut World) { output }, "", - &["_self", "other"], - ); - let registry = world.get_resource_or_init::(); - let mut registry = registry.write(); + &["_self"], + ) + .register_documented( + "div", + |_self: Val<::bevy_ui::Val>, rhs: f32| { + let output: Val<::bevy_ui::Val> = { + { + let output: Val<::bevy_ui::Val> = <::bevy_ui::Val as ::std::ops::Div< + f32, + >>::div(_self.into_inner(), rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::Val>, other: Ref<::bevy_ui::Val>| { + let output: bool = { + { + let output: bool = <::bevy_ui::Val as ::std::cmp::PartialEq< + ::bevy_ui::Val, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "horizontal", + |_self: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiRect> = { + { + let output: Val<::bevy_ui::UiRect> = ::bevy_ui::Val::horizontal( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns a [`UiRect`] with all its `left` and `right` equal to this value,\n and its `top` and `bottom` set to `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = Val::Px(1.).horizontal();\n assert_eq!(ui_rect.left, Val::Px(1.));\n assert_eq!(ui_rect.right, Val::Px(1.));\n assert_eq!(ui_rect.top, Val::ZERO);\n assert_eq!(ui_rect.bottom, Val::ZERO);\n ```", + &["_self"], + ) + .register_documented( + "left", + |_self: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiRect> = { + { + let output: Val<::bevy_ui::UiRect> = ::bevy_ui::Val::left( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns a [`UiRect`] with its `left` equal to this value,\n and all other fields set to `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = Val::Px(1.).left();\n assert_eq!(ui_rect.left, Val::Px(1.));\n assert_eq!(ui_rect.right, Val::ZERO);\n assert_eq!(ui_rect.top, Val::ZERO);\n assert_eq!(ui_rect.bottom, Val::ZERO);\n ```", + &["_self"], + ) + .register_documented( + "mul", + |_self: Val<::bevy_ui::Val>, rhs: f32| { + let output: Val<::bevy_ui::Val> = { + { + let output: Val<::bevy_ui::Val> = <::bevy_ui::Val as ::std::ops::Mul< + f32, + >>::mul(_self.into_inner(), rhs) + .into(); + output + } + }; + output + }, + "", + &["_self", "rhs"], + ) + .register_documented( + "neg", + |_self: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::Val> = { + { + let output: Val<::bevy_ui::Val> = <::bevy_ui::Val as ::std::ops::Neg>::neg( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "right", + |_self: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiRect> = { + { + let output: Val<::bevy_ui::UiRect> = ::bevy_ui::Val::right( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns a [`UiRect`] with its `right` equal to this value,\n and all other fields set to `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = Val::Px(1.).right();\n assert_eq!(ui_rect.left, Val::ZERO);\n assert_eq!(ui_rect.right, Val::Px(1.));\n assert_eq!(ui_rect.top, Val::ZERO);\n assert_eq!(ui_rect.bottom, Val::ZERO);\n ```", + &["_self"], + ) + .register_documented( + "top", + |_self: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiRect> = { + { + let output: Val<::bevy_ui::UiRect> = ::bevy_ui::Val::top( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns a [`UiRect`] with its `top` equal to this value,\n and all other fields set to `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = Val::Px(1.).top();\n assert_eq!(ui_rect.left, Val::ZERO);\n assert_eq!(ui_rect.right, Val::ZERO);\n assert_eq!(ui_rect.top, Val::Px(1.));\n assert_eq!(ui_rect.bottom, Val::ZERO);\n ```", + &["_self"], + ) + .register_documented( + "vertical", + |_self: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiRect> = { + { + let output: Val<::bevy_ui::UiRect> = ::bevy_ui::Val::vertical( + _self.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Returns a [`UiRect`] with all its `top` and `bottom` equal to this value,\n and its `left` and `right` set to `Val::ZERO`.\n # Example\n ```\n # use bevy_ui::{UiRect, Val};\n #\n let ui_rect = Val::Px(1.).vertical();\n assert_eq!(ui_rect.left, Val::ZERO);\n assert_eq!(ui_rect.right, Val::ZERO);\n assert_eq!(ui_rect.top, Val::Px(1.));\n assert_eq!(ui_rect.bottom, Val::Px(1.));\n ```", + &["_self"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::gradients::InterpolationColorSpace, + ::bevy_ui::Val, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_color_stop_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::ColorStop, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::ColorStop>| { + let output: Val<::bevy_ui::ColorStop> = { + { + let output: Val<::bevy_ui::ColorStop> = <::bevy_ui::ColorStop as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::ColorStop>, other: Ref<::bevy_ui::ColorStop>| { + let output: bool = { + { + let output: bool = <::bevy_ui::ColorStop as ::std::cmp::PartialEq< + ::bevy_ui::ColorStop, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "with_hint", + |_self: Val<::bevy_ui::ColorStop>, hint: f32| { + let output: Val<::bevy_ui::ColorStop> = { + { + let output: Val<::bevy_ui::ColorStop> = ::bevy_ui::ColorStop::with_hint( + _self.into_inner(), + hint, + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "hint"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::ColorStop, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_angular_color_stop_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::AngularColorStop, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::AngularColorStop>| { + let output: Val<::bevy_ui::AngularColorStop> = { + { + let output: Val<::bevy_ui::AngularColorStop> = <::bevy_ui::AngularColorStop as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::AngularColorStop>, + other: Ref<::bevy_ui::AngularColorStop>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::AngularColorStop as ::std::cmp::PartialEq< + ::bevy_ui::AngularColorStop, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "with_hint", + |_self: Val<::bevy_ui::AngularColorStop>, hint: f32| { + let output: Val<::bevy_ui::AngularColorStop> = { + { + let output: Val<::bevy_ui::AngularColorStop> = ::bevy_ui::AngularColorStop::with_hint( + _self.into_inner(), + hint, + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "hint"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::AngularColorStop, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_linear_gradient_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::LinearGradient, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::LinearGradient>| { + let output: Val<::bevy_ui::LinearGradient> = { + { + let output: Val<::bevy_ui::LinearGradient> = <::bevy_ui::LinearGradient as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::LinearGradient>, + other: Ref<::bevy_ui::LinearGradient>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::LinearGradient as ::std::cmp::PartialEq< + ::bevy_ui::LinearGradient, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "in_color_space", + | + _self: Val<::bevy_ui::LinearGradient>, + color_space: Val<::bevy_ui::InterpolationColorSpace>| + { + let output: Val<::bevy_ui::LinearGradient> = { + { + let output: Val<::bevy_ui::LinearGradient> = ::bevy_ui::LinearGradient::in_color_space( + _self.into_inner(), + color_space.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "color_space"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::LinearGradient, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); +} +pub(crate) fn register_interpolation_color_space_functions(world: &mut World) { + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::bevy_ui::InterpolationColorSpace, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::bevy_ui::InterpolationColorSpace>| { + let output: () = { + { + let output: () = <::bevy_ui::InterpolationColorSpace as ::std::cmp::Eq>::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::bevy_ui::InterpolationColorSpace>| { + let output: Val<::bevy_ui::InterpolationColorSpace> = { + { + let output: Val<::bevy_ui::InterpolationColorSpace> = <::bevy_ui::InterpolationColorSpace as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::InterpolationColorSpace>, + other: Ref<::bevy_ui::InterpolationColorSpace>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::InterpolationColorSpace as ::std::cmp::PartialEq< + ::bevy_ui::InterpolationColorSpace, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); + let registry = world.get_resource_or_init::(); + let mut registry = registry.write(); + registry + .register_type_data::< + ::bevy_ui::InterpolationColorSpace, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_radial_gradient_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::gradients::RadialGradient, + ::bevy_ui::RadialGradient, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::gradients::RadialGradient>| { - let output: Val<::bevy_ui::gradients::RadialGradient> = { - { - let output: Val<::bevy_ui::gradients::RadialGradient> = - <::bevy_ui::gradients::RadialGradient as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::gradients::RadialGradient>, - other: Ref<::bevy_ui::gradients::RadialGradient>| { - let output: bool = { - { - let output: bool = - <::bevy_ui::gradients::RadialGradient as ::std::cmp::PartialEq< - ::bevy_ui::gradients::RadialGradient, + .register_documented( + "clone", + |_self: Ref<::bevy_ui::RadialGradient>| { + let output: Val<::bevy_ui::RadialGradient> = { + { + let output: Val<::bevy_ui::RadialGradient> = <::bevy_ui::RadialGradient as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::RadialGradient>, + other: Ref<::bevy_ui::RadialGradient>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::RadialGradient as ::std::cmp::PartialEq< + ::bevy_ui::RadialGradient, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "in_color_space", - |_self: Val<::bevy_ui::gradients::RadialGradient>, - color_space: Val<::bevy_ui::gradients::InterpolationColorSpace>| { - let output: Val<::bevy_ui::gradients::RadialGradient> = { - { - let output: Val<::bevy_ui::gradients::RadialGradient> = - ::bevy_ui::gradients::RadialGradient::in_color_space( - _self.into_inner(), - color_space.into_inner(), - ) - .into(); - output - } - }; - output - }, - "", - &["_self", "color_space"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "in_color_space", + | + _self: Val<::bevy_ui::RadialGradient>, + color_space: Val<::bevy_ui::InterpolationColorSpace>| + { + let output: Val<::bevy_ui::RadialGradient> = { + { + let output: Val<::bevy_ui::RadialGradient> = ::bevy_ui::RadialGradient::in_color_space( + _self.into_inner(), + color_space.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "color_space"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::gradients::RadialGradient, + ::bevy_ui::RadialGradient, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_radial_gradient_shape_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::gradients::RadialGradientShape, + ::bevy_ui::RadialGradientShape, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::gradients::RadialGradientShape>| { - let output: Val<::bevy_ui::gradients::RadialGradientShape> = { - { - let output: Val<::bevy_ui::gradients::RadialGradientShape> = - <::bevy_ui::gradients::RadialGradientShape as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::gradients::RadialGradientShape>, - other: Ref<::bevy_ui::gradients::RadialGradientShape>| { - let output: bool = { - { - let output: bool = - <::bevy_ui::gradients::RadialGradientShape as ::std::cmp::PartialEq< - ::bevy_ui::gradients::RadialGradientShape, + .register_documented( + "clone", + |_self: Ref<::bevy_ui::RadialGradientShape>| { + let output: Val<::bevy_ui::RadialGradientShape> = { + { + let output: Val<::bevy_ui::RadialGradientShape> = <::bevy_ui::RadialGradientShape as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::RadialGradientShape>, + other: Ref<::bevy_ui::RadialGradientShape>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::RadialGradientShape as ::std::cmp::PartialEq< + ::bevy_ui::RadialGradientShape, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "resolve", + | + _self: Val<::bevy_ui::RadialGradientShape>, + position: Val<::glam::Vec2>, + scale_factor: f32, + physical_size: Val<::glam::Vec2>, + physical_target_size: Val<::glam::Vec2>| + { + let output: Val<::glam::Vec2> = { + { + let output: Val<::glam::Vec2> = ::bevy_ui::RadialGradientShape::resolve( + _self.into_inner(), + position.into_inner(), + scale_factor, + physical_size.into_inner(), + physical_target_size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Resolve the physical dimensions of the end shape of the radial gradient", + &[ + "_self", + "position", + "scale_factor", + "physical_size", + "physical_target_size", + ], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::gradients::RadialGradientShape, + ::bevy_ui::RadialGradientShape, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_conic_gradient_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::gradients::ConicGradient, + ::bevy_ui::ConicGradient, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::gradients::ConicGradient>| { - let output: Val<::bevy_ui::gradients::ConicGradient> = { - { - let output: Val<::bevy_ui::gradients::ConicGradient> = - <::bevy_ui::gradients::ConicGradient as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::gradients::ConicGradient>, - other: Ref<::bevy_ui::gradients::ConicGradient>| { - let output: bool = { - { - let output: bool = - <::bevy_ui::gradients::ConicGradient as ::std::cmp::PartialEq< - ::bevy_ui::gradients::ConicGradient, + .register_documented( + "clone", + |_self: Ref<::bevy_ui::ConicGradient>| { + let output: Val<::bevy_ui::ConicGradient> = { + { + let output: Val<::bevy_ui::ConicGradient> = <::bevy_ui::ConicGradient as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::ConicGradient>, other: Ref<::bevy_ui::ConicGradient>| { + let output: bool = { + { + let output: bool = <::bevy_ui::ConicGradient as ::std::cmp::PartialEq< + ::bevy_ui::ConicGradient, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "in_color_space", - |_self: Val<::bevy_ui::gradients::ConicGradient>, - color_space: Val<::bevy_ui::gradients::InterpolationColorSpace>| { - let output: Val<::bevy_ui::gradients::ConicGradient> = { - { - let output: Val<::bevy_ui::gradients::ConicGradient> = - ::bevy_ui::gradients::ConicGradient::in_color_space( - _self.into_inner(), - color_space.into_inner(), - ) - .into(); - output - } - }; - output - }, - "", - &["_self", "color_space"], - ) - .register_documented( - "with_position", - |_self: Val<::bevy_ui::gradients::ConicGradient>, - position: Val<::bevy_ui::prelude::UiPosition>| { - let output: Val<::bevy_ui::gradients::ConicGradient> = { - { - let output: Val<::bevy_ui::gradients::ConicGradient> = - ::bevy_ui::gradients::ConicGradient::with_position( - _self.into_inner(), - position.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Sets the position of the gradient", - &["_self", "position"], - ) - .register_documented( - "with_start", - |_self: Val<::bevy_ui::gradients::ConicGradient>, start: f32| { - let output: Val<::bevy_ui::gradients::ConicGradient> = { - { - let output: Val<::bevy_ui::gradients::ConicGradient> = - ::bevy_ui::gradients::ConicGradient::with_start(_self.into_inner(), start) - .into(); - output - } - }; - output - }, - " Sets the starting angle of the gradient in radians", - &["_self", "start"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "in_color_space", + | + _self: Val<::bevy_ui::ConicGradient>, + color_space: Val<::bevy_ui::InterpolationColorSpace>| + { + let output: Val<::bevy_ui::ConicGradient> = { + { + let output: Val<::bevy_ui::ConicGradient> = ::bevy_ui::ConicGradient::in_color_space( + _self.into_inner(), + color_space.into_inner(), + ) + .into(); + output + } + }; + output + }, + "", + &["_self", "color_space"], + ) + .register_documented( + "with_position", + |_self: Val<::bevy_ui::ConicGradient>, position: Val<::bevy_ui::UiPosition>| { + let output: Val<::bevy_ui::ConicGradient> = { + { + let output: Val<::bevy_ui::ConicGradient> = ::bevy_ui::ConicGradient::with_position( + _self.into_inner(), + position.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Sets the position of the gradient", + &["_self", "position"], + ) + .register_documented( + "with_start", + |_self: Val<::bevy_ui::ConicGradient>, start: f32| { + let output: Val<::bevy_ui::ConicGradient> = { + { + let output: Val<::bevy_ui::ConicGradient> = ::bevy_ui::ConicGradient::with_start( + _self.into_inner(), + start, + ) + .into(); + output + } + }; + output + }, + " Sets the starting angle of the gradient in radians", + &["_self", "start"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::gradients::ConicGradient, + ::bevy_ui::ConicGradient, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_gradient_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::gradients::Gradient, + ::bevy_ui::Gradient, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::gradients::Gradient>| { - let output: Val<::bevy_ui::gradients::Gradient> = { - { - let output: Val<::bevy_ui::gradients::Gradient> = - <::bevy_ui::gradients::Gradient as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::gradients::Gradient>, other: Ref<::bevy_ui::gradients::Gradient>| { - let output: bool = { - { - let output: bool = <::bevy_ui::gradients::Gradient as ::std::cmp::PartialEq< - ::bevy_ui::gradients::Gradient, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "is_empty", - |_self: Ref<::bevy_ui::gradients::Gradient>| { - let output: bool = { - { - let output: bool = ::bevy_ui::gradients::Gradient::is_empty(&_self).into(); - output - } - }; - output - }, - " Returns true if the gradient has no stops.", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_ui::Gradient>| { + let output: Val<::bevy_ui::Gradient> = { + { + let output: Val<::bevy_ui::Gradient> = <::bevy_ui::Gradient as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::Gradient>, other: Ref<::bevy_ui::Gradient>| { + let output: bool = { + { + let output: bool = <::bevy_ui::Gradient as ::std::cmp::PartialEq< + ::bevy_ui::Gradient, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "is_empty", + |_self: Ref<::bevy_ui::Gradient>| { + let output: bool = { + { + let output: bool = ::bevy_ui::Gradient::is_empty(&_self).into(); + output + } + }; + output + }, + " Returns true if the gradient has no stops.", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::gradients::Gradient, + ::bevy_ui::Gradient, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_background_gradient_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::gradients::BackgroundGradient, + ::bevy_ui::BackgroundGradient, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::gradients::BackgroundGradient>| { - let output: Val<::bevy_ui::gradients::BackgroundGradient> = { - { - let output: Val<::bevy_ui::gradients::BackgroundGradient> = - <::bevy_ui::gradients::BackgroundGradient as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::gradients::BackgroundGradient>, - other: Ref<::bevy_ui::gradients::BackgroundGradient>| { - let output: bool = { - { - let output: bool = - <::bevy_ui::gradients::BackgroundGradient as ::std::cmp::PartialEq< - ::bevy_ui::gradients::BackgroundGradient, + .register_documented( + "clone", + |_self: Ref<::bevy_ui::BackgroundGradient>| { + let output: Val<::bevy_ui::BackgroundGradient> = { + { + let output: Val<::bevy_ui::BackgroundGradient> = <::bevy_ui::BackgroundGradient as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::BackgroundGradient>, + other: Ref<::bevy_ui::BackgroundGradient>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::BackgroundGradient as ::std::cmp::PartialEq< + ::bevy_ui::BackgroundGradient, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::gradients::BackgroundGradient, + ::bevy_ui::BackgroundGradient, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_border_gradient_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::gradients::BorderGradient, + ::bevy_ui::BorderGradient, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::gradients::BorderGradient>| { - let output: Val<::bevy_ui::gradients::BorderGradient> = { - { - let output: Val<::bevy_ui::gradients::BorderGradient> = - <::bevy_ui::gradients::BorderGradient as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::gradients::BorderGradient>, - other: Ref<::bevy_ui::gradients::BorderGradient>| { - let output: bool = { - { - let output: bool = - <::bevy_ui::gradients::BorderGradient as ::std::cmp::PartialEq< - ::bevy_ui::gradients::BorderGradient, + .register_documented( + "clone", + |_self: Ref<::bevy_ui::BorderGradient>| { + let output: Val<::bevy_ui::BorderGradient> = { + { + let output: Val<::bevy_ui::BorderGradient> = <::bevy_ui::BorderGradient as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::BorderGradient>, + other: Ref<::bevy_ui::BorderGradient>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::BorderGradient as ::std::cmp::PartialEq< + ::bevy_ui::BorderGradient, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::gradients::BorderGradient, + ::bevy_ui::BorderGradient, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_val_2_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::ui_transform::Val2, + ::bevy_ui::Val2, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::ui_transform::Val2>| { - let output: Val<::bevy_ui::ui_transform::Val2> = { - { - let output: Val<::bevy_ui::ui_transform::Val2> = - <::bevy_ui::ui_transform::Val2 as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::ui_transform::Val2>, other: Ref<::bevy_ui::ui_transform::Val2>| { - let output: bool = { - { - let output: bool = <::bevy_ui::ui_transform::Val2 as ::std::cmp::PartialEq< - ::bevy_ui::ui_transform::Val2, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "new", - |x: Val<::bevy_ui::prelude::Val>, y: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::ui_transform::Val2> = { - { - let output: Val<::bevy_ui::ui_transform::Val2> = - ::bevy_ui::ui_transform::Val2::new(x.into_inner(), y.into_inner()).into(); - output - } - }; - output - }, - " Creates a new [`Val2`]", - &["x", "y"], - ) - .register_documented( - "percent", - |x: f32, y: f32| { - let output: Val<::bevy_ui::ui_transform::Val2> = { - { - let output: Val<::bevy_ui::ui_transform::Val2> = - ::bevy_ui::ui_transform::Val2::percent(x, y).into(); - output - } - }; - output - }, - " Creates a new [`Val2`] where both components are percentage values", - &["x", "y"], - ) - .register_documented( - "px", - |x: f32, y: f32| { - let output: Val<::bevy_ui::ui_transform::Val2> = { - { - let output: Val<::bevy_ui::ui_transform::Val2> = - ::bevy_ui::ui_transform::Val2::px(x, y).into(); - output - } - }; - output - }, - " Creates a new [`Val2`] where both components are in logical pixels", - &["x", "y"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_ui::Val2>| { + let output: Val<::bevy_ui::Val2> = { + { + let output: Val<::bevy_ui::Val2> = <::bevy_ui::Val2 as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::Val2>, other: Ref<::bevy_ui::Val2>| { + let output: bool = { + { + let output: bool = <::bevy_ui::Val2 as ::std::cmp::PartialEq< + ::bevy_ui::Val2, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "new", + |x: Val<::bevy_ui::Val>, y: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::Val2> = { + { + let output: Val<::bevy_ui::Val2> = ::bevy_ui::Val2::new( + x.into_inner(), + y.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a new [`Val2`]", + &["x", "y"], + ) + .register_documented( + "percent", + |x: f32, y: f32| { + let output: Val<::bevy_ui::Val2> = { + { + let output: Val<::bevy_ui::Val2> = ::bevy_ui::Val2::percent(x, y) + .into(); + output + } + }; + output + }, + " Creates a new [`Val2`] where both components are percentage values", + &["x", "y"], + ) + .register_documented( + "px", + |x: f32, y: f32| { + let output: Val<::bevy_ui::Val2> = { + { + let output: Val<::bevy_ui::Val2> = ::bevy_ui::Val2::px(x, y) + .into(); + output + } + }; + output + }, + " Creates a new [`Val2`] where both components are in logical pixels", + &["x", "y"], + ) + .register_documented( + "resolve", + | + _self: Ref<::bevy_ui::Val2>, + scale_factor: f32, + base_size: Val<::glam::Vec2>, + viewport_size: Val<::glam::Vec2>| + { + let output: Val<::glam::Vec2> = { + { + let output: Val<::glam::Vec2> = ::bevy_ui::Val2::resolve( + &_self, + scale_factor, + base_size.into_inner(), + viewport_size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Resolves this [`Val2`] from the given `scale_factor`, `parent_size`,\n and `viewport_size`.\n Component values of [`Val::Auto`] are resolved to 0.", + &["_self", "scale_factor", "base_size", "viewport_size"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::ui_transform::Val2, + ::bevy_ui::Val2, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_ui_transform_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::ui_transform::UiTransform, + ::bevy_ui::UiTransform, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::ui_transform::UiTransform>| { - let output: Val<::bevy_ui::ui_transform::UiTransform> = { - { - let output: Val<::bevy_ui::ui_transform::UiTransform> = - <::bevy_ui::ui_transform::UiTransform as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::ui_transform::UiTransform>, - other: Ref<::bevy_ui::ui_transform::UiTransform>| { - let output: bool = { - { - let output: bool = - <::bevy_ui::ui_transform::UiTransform as ::std::cmp::PartialEq< - ::bevy_ui::ui_transform::UiTransform, + .register_documented( + "clone", + |_self: Ref<::bevy_ui::UiTransform>| { + let output: Val<::bevy_ui::UiTransform> = { + { + let output: Val<::bevy_ui::UiTransform> = <::bevy_ui::UiTransform as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "compute_affine", + | + _self: Ref<::bevy_ui::UiTransform>, + scale_factor: f32, + base_size: Val<::glam::Vec2>, + target_size: Val<::glam::Vec2>| + { + let output: Val<::glam::Affine2> = { + { + let output: Val<::glam::Affine2> = ::bevy_ui::UiTransform::compute_affine( + &_self, + scale_factor, + base_size.into_inner(), + target_size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Resolves the translation from the given `scale_factor`, `base_value`, and `target_size`\n and returns a 2d affine transform from the resolved translation, and the `UiTransform`'s rotation, and scale.", + &["_self", "scale_factor", "base_size", "target_size"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::UiTransform>, other: Ref<::bevy_ui::UiTransform>| { + let output: bool = { + { + let output: bool = <::bevy_ui::UiTransform as ::std::cmp::PartialEq< + ::bevy_ui::UiTransform, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "from_rotation", - |rotation: Val<::bevy_math::Rot2>| { - let output: Val<::bevy_ui::ui_transform::UiTransform> = { - { - let output: Val<::bevy_ui::ui_transform::UiTransform> = - ::bevy_ui::ui_transform::UiTransform::from_rotation(rotation.into_inner()) - .into(); - output - } - }; - output - }, - " Creates a UI transform representing a rotation.", - &["rotation"], - ) - .register_documented( - "from_translation", - |translation: Val<::bevy_ui::ui_transform::Val2>| { - let output: Val<::bevy_ui::ui_transform::UiTransform> = { - { - let output: Val<::bevy_ui::ui_transform::UiTransform> = - ::bevy_ui::ui_transform::UiTransform::from_translation( - translation.into_inner(), - ) - .into(); - output - } - }; - output - }, - " Creates a UI transform representing a responsive translation.", - &["translation"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "from_rotation", + |rotation: Val<::bevy_math::Rot2>| { + let output: Val<::bevy_ui::UiTransform> = { + { + let output: Val<::bevy_ui::UiTransform> = ::bevy_ui::UiTransform::from_rotation( + rotation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a UI transform representing a rotation.", + &["rotation"], + ) + .register_documented( + "from_scale", + |scale: Val<::glam::Vec2>| { + let output: Val<::bevy_ui::UiTransform> = { + { + let output: Val<::bevy_ui::UiTransform> = ::bevy_ui::UiTransform::from_scale( + scale.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a UI transform representing a scaling.", + &["scale"], + ) + .register_documented( + "from_translation", + |translation: Val<::bevy_ui::Val2>| { + let output: Val<::bevy_ui::UiTransform> = { + { + let output: Val<::bevy_ui::UiTransform> = ::bevy_ui::UiTransform::from_translation( + translation.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Creates a UI transform representing a responsive translation.", + &["translation"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::ui_transform::UiTransform, + ::bevy_ui::UiTransform, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } @@ -2795,56 +3164,60 @@ pub(crate) fn register_relative_cursor_position_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_ui::RelativeCursorPosition, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::RelativeCursorPosition>| { - let output: Val<::bevy_ui::RelativeCursorPosition> = { - { - let output: Val<::bevy_ui::RelativeCursorPosition> = - <::bevy_ui::RelativeCursorPosition as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "cursor_over", - |_self: Ref<::bevy_ui::RelativeCursorPosition>| { - let output: bool = { - { - let output: bool = - ::bevy_ui::RelativeCursorPosition::cursor_over(&_self).into(); - output - } - }; - output - }, - " A helper function to check if the mouse is over the node", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::RelativeCursorPosition>, - other: Ref<::bevy_ui::RelativeCursorPosition>| { - let output: bool = { - { - let output: bool = - <::bevy_ui::RelativeCursorPosition as ::std::cmp::PartialEq< + .register_documented( + "clone", + |_self: Ref<::bevy_ui::RelativeCursorPosition>| { + let output: Val<::bevy_ui::RelativeCursorPosition> = { + { + let output: Val<::bevy_ui::RelativeCursorPosition> = <::bevy_ui::RelativeCursorPosition as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "cursor_over", + |_self: Ref<::bevy_ui::RelativeCursorPosition>| { + let output: bool = { + { + let output: bool = ::bevy_ui::RelativeCursorPosition::cursor_over( + &_self, + ) + .into(); + output + } + }; + output + }, + " A helper function to check if the mouse is over the node", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::RelativeCursorPosition>, + other: Ref<::bevy_ui::RelativeCursorPosition>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::RelativeCursorPosition as ::std::cmp::PartialEq< ::bevy_ui::RelativeCursorPosition, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -2855,14 +3228,14 @@ pub(crate) fn register_relative_cursor_position_functions(world: &mut World) { } pub(crate) fn register_ui_rect_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::UiRect, + ::bevy_ui::UiRect, >::new(world) .register_documented( "all", - |value: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiRect> = { + |value: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::all( + let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::all( value.into_inner(), ) .into(); @@ -2876,13 +3249,10 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { ) .register_documented( "axes", - | - horizontal: Val<::bevy_ui::prelude::Val>, - vertical: Val<::bevy_ui::prelude::Val>| - { - let output: Val<::bevy_ui::prelude::UiRect> = { + |horizontal: Val<::bevy_ui::Val>, vertical: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::axes( + let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::axes( horizontal.into_inner(), vertical.into_inner(), ) @@ -2897,10 +3267,10 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { ) .register_documented( "bottom", - |bottom: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiRect> = { + |bottom: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::bottom( + let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::bottom( bottom.into_inner(), ) .into(); @@ -2914,10 +3284,10 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::UiRect>| { - let output: Val<::bevy_ui::prelude::UiRect> = { + |_self: Ref<::bevy_ui::UiRect>| { + let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::prelude::UiRect> = <::bevy_ui::prelude::UiRect as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::UiRect> = <::bevy_ui::UiRect as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -2931,14 +3301,11 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_ui::prelude::UiRect>, - other: Ref<::bevy_ui::prelude::UiRect>| - { + |_self: Ref<::bevy_ui::UiRect>, other: Ref<::bevy_ui::UiRect>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::UiRect as ::std::cmp::PartialEq< - ::bevy_ui::prelude::UiRect, + let output: bool = <::bevy_ui::UiRect as ::std::cmp::PartialEq< + ::bevy_ui::UiRect, >>::eq(&_self, &other) .into(); output @@ -2951,10 +3318,10 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { ) .register_documented( "horizontal", - |value: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiRect> = { + |value: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::horizontal( + let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::horizontal( value.into_inner(), ) .into(); @@ -2968,10 +3335,10 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { ) .register_documented( "left", - |left: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiRect> = { + |left: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::left( + let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::left( left.into_inner(), ) .into(); @@ -2986,14 +3353,14 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { .register_documented( "new", | - left: Val<::bevy_ui::prelude::Val>, - right: Val<::bevy_ui::prelude::Val>, - top: Val<::bevy_ui::prelude::Val>, - bottom: Val<::bevy_ui::prelude::Val>| + left: Val<::bevy_ui::Val>, + right: Val<::bevy_ui::Val>, + top: Val<::bevy_ui::Val>, + bottom: Val<::bevy_ui::Val>| { - let output: Val<::bevy_ui::prelude::UiRect> = { + let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::new( + let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::new( left.into_inner(), right.into_inner(), top.into_inner(), @@ -3011,9 +3378,9 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { .register_documented( "percent", |left: f32, right: f32, top: f32, bottom: f32| { - let output: Val<::bevy_ui::prelude::UiRect> = { + let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::percent( + let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::percent( left, right, top, @@ -3031,9 +3398,9 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { .register_documented( "px", |left: f32, right: f32, top: f32, bottom: f32| { - let output: Val<::bevy_ui::prelude::UiRect> = { + let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::px( + let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::px( left, right, top, @@ -3050,10 +3417,10 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { ) .register_documented( "right", - |right: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiRect> = { + |right: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::right( + let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::right( right.into_inner(), ) .into(); @@ -3067,10 +3434,10 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { ) .register_documented( "top", - |top: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiRect> = { + |top: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::top( + let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::top( top.into_inner(), ) .into(); @@ -3084,10 +3451,10 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { ) .register_documented( "vertical", - |value: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiRect> = { + |value: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::vertical( + let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::vertical( value.into_inner(), ) .into(); @@ -3101,13 +3468,10 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { ) .register_documented( "with_bottom", - | - _self: Val<::bevy_ui::prelude::UiRect>, - bottom: Val<::bevy_ui::prelude::Val>| - { - let output: Val<::bevy_ui::prelude::UiRect> = { + |_self: Val<::bevy_ui::UiRect>, bottom: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::with_bottom( + let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::with_bottom( _self.into_inner(), bottom.into_inner(), ) @@ -3122,10 +3486,10 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { ) .register_documented( "with_left", - |_self: Val<::bevy_ui::prelude::UiRect>, left: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiRect> = { + |_self: Val<::bevy_ui::UiRect>, left: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::with_left( + let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::with_left( _self.into_inner(), left.into_inner(), ) @@ -3140,13 +3504,10 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { ) .register_documented( "with_right", - | - _self: Val<::bevy_ui::prelude::UiRect>, - right: Val<::bevy_ui::prelude::Val>| - { - let output: Val<::bevy_ui::prelude::UiRect> = { + |_self: Val<::bevy_ui::UiRect>, right: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::with_right( + let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::with_right( _self.into_inner(), right.into_inner(), ) @@ -3161,10 +3522,10 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { ) .register_documented( "with_top", - |_self: Val<::bevy_ui::prelude::UiRect>, top: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::UiRect> = { + |_self: Val<::bevy_ui::UiRect>, top: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::prelude::UiRect> = ::bevy_ui::prelude::UiRect::with_top( + let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::with_top( _self.into_inner(), top.into_inner(), ) @@ -3181,20 +3542,20 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::UiRect, + ::bevy_ui::UiRect, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_border_radius_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::BorderRadius, + ::bevy_ui::BorderRadius, >::new(world) .register_documented( "all", - |radius: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::BorderRadius> = { + |radius: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::all( + let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::all( radius.into_inner(), ) .into(); @@ -3208,10 +3569,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { ) .register_documented( "bottom", - |radius: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::BorderRadius> = { + |radius: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::bottom( + let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::bottom( radius.into_inner(), ) .into(); @@ -3225,10 +3586,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { ) .register_documented( "bottom_left", - |radius: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::BorderRadius> = { + |radius: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::bottom_left( + let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::bottom_left( radius.into_inner(), ) .into(); @@ -3242,10 +3603,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { ) .register_documented( "bottom_right", - |radius: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::BorderRadius> = { + |radius: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::bottom_right( + let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::bottom_right( radius.into_inner(), ) .into(); @@ -3259,10 +3620,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::BorderRadius>| { - let output: Val<::bevy_ui::prelude::BorderRadius> = { + |_self: Ref<::bevy_ui::BorderRadius>| { + let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::prelude::BorderRadius> = <::bevy_ui::prelude::BorderRadius as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::BorderRadius> = <::bevy_ui::BorderRadius as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -3276,14 +3637,11 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_ui::prelude::BorderRadius>, - other: Ref<::bevy_ui::prelude::BorderRadius>| - { + |_self: Ref<::bevy_ui::BorderRadius>, other: Ref<::bevy_ui::BorderRadius>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::BorderRadius as ::std::cmp::PartialEq< - ::bevy_ui::prelude::BorderRadius, + let output: bool = <::bevy_ui::BorderRadius as ::std::cmp::PartialEq< + ::bevy_ui::BorderRadius, >>::eq(&_self, &other) .into(); output @@ -3296,10 +3654,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { ) .register_documented( "left", - |radius: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::BorderRadius> = { + |radius: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::left( + let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::left( radius.into_inner(), ) .into(); @@ -3314,14 +3672,14 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { .register_documented( "new", | - top_left: Val<::bevy_ui::prelude::Val>, - top_right: Val<::bevy_ui::prelude::Val>, - bottom_right: Val<::bevy_ui::prelude::Val>, - bottom_left: Val<::bevy_ui::prelude::Val>| + top_left: Val<::bevy_ui::Val>, + top_right: Val<::bevy_ui::Val>, + bottom_right: Val<::bevy_ui::Val>, + bottom_left: Val<::bevy_ui::Val>| { - let output: Val<::bevy_ui::prelude::BorderRadius> = { + let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::new( + let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::new( top_left.into_inner(), top_right.into_inner(), bottom_right.into_inner(), @@ -3339,9 +3697,9 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { .register_documented( "percent", |top_left: f32, top_right: f32, bottom_right: f32, bottom_left: f32| { - let output: Val<::bevy_ui::prelude::BorderRadius> = { + let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::percent( + let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::percent( top_left, top_right, bottom_right, @@ -3359,9 +3717,9 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { .register_documented( "px", |top_left: f32, top_right: f32, bottom_right: f32, bottom_left: f32| { - let output: Val<::bevy_ui::prelude::BorderRadius> = { + let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::px( + let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::px( top_left, top_right, bottom_right, @@ -3376,12 +3734,62 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { " Sets the radii to logical pixel values.", &["top_left", "top_right", "bottom_right", "bottom_left"], ) + .register_documented( + "resolve", + | + _self: Ref<::bevy_ui::BorderRadius>, + scale_factor: f32, + node_size: Val<::glam::Vec2>, + viewport_size: Val<::glam::Vec2>| + { + let output: Val<::bevy_ui::ResolvedBorderRadius> = { + { + let output: Val<::bevy_ui::ResolvedBorderRadius> = ::bevy_ui::BorderRadius::resolve( + &_self, + scale_factor, + node_size.into_inner(), + viewport_size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Resolve the border radii for the corners from the given context values.\n Returns the radii of the each corner in physical pixels.", + &["_self", "scale_factor", "node_size", "viewport_size"], + ) + .register_documented( + "resolve_single_corner", + | + radius: Val<::bevy_ui::Val>, + scale_factor: f32, + min_length: f32, + viewport_size: Val<::glam::Vec2>| + { + let output: f32 = { + { + let output: f32 = ::bevy_ui::BorderRadius::resolve_single_corner( + radius.into_inner(), + scale_factor, + min_length, + viewport_size.into_inner(), + ) + .into(); + output + } + }; + output + }, + " Resolve the border radius for a single corner from the given context values.\n Returns the radius of the corner in physical pixels.", + &["radius", "scale_factor", "min_length", "viewport_size"], + ) .register_documented( "right", - |radius: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::BorderRadius> = { + |radius: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::right( + let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::right( radius.into_inner(), ) .into(); @@ -3395,10 +3803,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { ) .register_documented( "top", - |radius: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::BorderRadius> = { + |radius: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::top( + let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::top( radius.into_inner(), ) .into(); @@ -3412,10 +3820,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { ) .register_documented( "top_left", - |radius: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::BorderRadius> = { + |radius: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::top_left( + let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::top_left( radius.into_inner(), ) .into(); @@ -3429,10 +3837,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { ) .register_documented( "top_right", - |radius: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::BorderRadius> = { + |radius: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::top_right( + let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::top_right( radius.into_inner(), ) .into(); @@ -3446,13 +3854,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { ) .register_documented( "with_bottom", - | - _self: Val<::bevy_ui::prelude::BorderRadius>, - radius: Val<::bevy_ui::prelude::Val>| - { - let output: Val<::bevy_ui::prelude::BorderRadius> = { + |_self: Val<::bevy_ui::BorderRadius>, radius: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::with_bottom( + let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::with_bottom( _self.into_inner(), radius.into_inner(), ) @@ -3467,13 +3872,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { ) .register_documented( "with_bottom_left", - | - _self: Val<::bevy_ui::prelude::BorderRadius>, - radius: Val<::bevy_ui::prelude::Val>| - { - let output: Val<::bevy_ui::prelude::BorderRadius> = { + |_self: Val<::bevy_ui::BorderRadius>, radius: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::with_bottom_left( + let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::with_bottom_left( _self.into_inner(), radius.into_inner(), ) @@ -3488,13 +3890,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { ) .register_documented( "with_bottom_right", - | - _self: Val<::bevy_ui::prelude::BorderRadius>, - radius: Val<::bevy_ui::prelude::Val>| - { - let output: Val<::bevy_ui::prelude::BorderRadius> = { + |_self: Val<::bevy_ui::BorderRadius>, radius: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::with_bottom_right( + let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::with_bottom_right( _self.into_inner(), radius.into_inner(), ) @@ -3509,13 +3908,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { ) .register_documented( "with_left", - | - _self: Val<::bevy_ui::prelude::BorderRadius>, - radius: Val<::bevy_ui::prelude::Val>| - { - let output: Val<::bevy_ui::prelude::BorderRadius> = { + |_self: Val<::bevy_ui::BorderRadius>, radius: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::with_left( + let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::with_left( _self.into_inner(), radius.into_inner(), ) @@ -3530,13 +3926,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { ) .register_documented( "with_right", - | - _self: Val<::bevy_ui::prelude::BorderRadius>, - radius: Val<::bevy_ui::prelude::Val>| - { - let output: Val<::bevy_ui::prelude::BorderRadius> = { + |_self: Val<::bevy_ui::BorderRadius>, radius: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::with_right( + let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::with_right( _self.into_inner(), radius.into_inner(), ) @@ -3551,13 +3944,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { ) .register_documented( "with_top", - | - _self: Val<::bevy_ui::prelude::BorderRadius>, - radius: Val<::bevy_ui::prelude::Val>| - { - let output: Val<::bevy_ui::prelude::BorderRadius> = { + |_self: Val<::bevy_ui::BorderRadius>, radius: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::with_top( + let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::with_top( _self.into_inner(), radius.into_inner(), ) @@ -3572,13 +3962,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { ) .register_documented( "with_top_left", - | - _self: Val<::bevy_ui::prelude::BorderRadius>, - radius: Val<::bevy_ui::prelude::Val>| - { - let output: Val<::bevy_ui::prelude::BorderRadius> = { + |_self: Val<::bevy_ui::BorderRadius>, radius: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::with_top_left( + let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::with_top_left( _self.into_inner(), radius.into_inner(), ) @@ -3593,13 +3980,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { ) .register_documented( "with_top_right", - | - _self: Val<::bevy_ui::prelude::BorderRadius>, - radius: Val<::bevy_ui::prelude::Val>| - { - let output: Val<::bevy_ui::prelude::BorderRadius> = { + |_self: Val<::bevy_ui::BorderRadius>, radius: Val<::bevy_ui::Val>| { + let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::prelude::BorderRadius> = ::bevy_ui::prelude::BorderRadius::with_top_right( + let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::with_top_right( _self.into_inner(), radius.into_inner(), ) @@ -3616,67 +4000,66 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::BorderRadius, + ::bevy_ui::BorderRadius, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_layout_config_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::LayoutConfig, + ::bevy_ui::LayoutConfig, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::prelude::LayoutConfig>| { - let output: Val<::bevy_ui::prelude::LayoutConfig> = { - { - let output: Val<::bevy_ui::prelude::LayoutConfig> = - <::bevy_ui::prelude::LayoutConfig as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::prelude::LayoutConfig>, - other: Ref<::bevy_ui::prelude::LayoutConfig>| { - let output: bool = { - { - let output: bool = - <::bevy_ui::prelude::LayoutConfig as ::std::cmp::PartialEq< - ::bevy_ui::prelude::LayoutConfig, + .register_documented( + "clone", + |_self: Ref<::bevy_ui::LayoutConfig>| { + let output: Val<::bevy_ui::LayoutConfig> = { + { + let output: Val<::bevy_ui::LayoutConfig> = <::bevy_ui::LayoutConfig as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::LayoutConfig>, other: Ref<::bevy_ui::LayoutConfig>| { + let output: bool = { + { + let output: bool = <::bevy_ui::LayoutConfig as ::std::cmp::PartialEq< + ::bevy_ui::LayoutConfig, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::LayoutConfig, + ::bevy_ui::LayoutConfig, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_outline_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::Outline, + ::bevy_ui::Outline, >::new(world) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::Outline>| { - let output: Val<::bevy_ui::prelude::Outline> = { + |_self: Ref<::bevy_ui::Outline>| { + let output: Val<::bevy_ui::Outline> = { { - let output: Val<::bevy_ui::prelude::Outline> = <::bevy_ui::prelude::Outline as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::Outline> = <::bevy_ui::Outline as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -3690,14 +4073,11 @@ pub(crate) fn register_outline_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_ui::prelude::Outline>, - other: Ref<::bevy_ui::prelude::Outline>| - { + |_self: Ref<::bevy_ui::Outline>, other: Ref<::bevy_ui::Outline>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::Outline as ::std::cmp::PartialEq< - ::bevy_ui::prelude::Outline, + let output: bool = <::bevy_ui::Outline as ::std::cmp::PartialEq< + ::bevy_ui::Outline, >>::eq(&_self, &other) .into(); output @@ -3711,13 +4091,13 @@ pub(crate) fn register_outline_functions(world: &mut World) { .register_documented( "new", | - width: Val<::bevy_ui::prelude::Val>, - offset: Val<::bevy_ui::prelude::Val>, + width: Val<::bevy_ui::Val>, + offset: Val<::bevy_ui::Val>, color: Val<::bevy_color::Color>| { - let output: Val<::bevy_ui::prelude::Outline> = { + let output: Val<::bevy_ui::Outline> = { { - let output: Val<::bevy_ui::prelude::Outline> = ::bevy_ui::prelude::Outline::new( + let output: Val<::bevy_ui::Outline> = ::bevy_ui::Outline::new( width.into_inner(), offset.into_inner(), color.into_inner(), @@ -3735,48 +4115,49 @@ pub(crate) fn register_outline_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::Outline, + ::bevy_ui::Outline, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_scroll_position_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::ScrollPosition, + ::bevy_ui::ScrollPosition, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::prelude::ScrollPosition>| { - let output: Val<::bevy_ui::prelude::ScrollPosition> = { - { - let output: Val<::bevy_ui::prelude::ScrollPosition> = - <::bevy_ui::prelude::ScrollPosition as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_ui::ScrollPosition>| { + let output: Val<::bevy_ui::ScrollPosition> = { + { + let output: Val<::bevy_ui::ScrollPosition> = <::bevy_ui::ScrollPosition as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::ScrollPosition, + ::bevy_ui::ScrollPosition, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_position_type_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::PositionType, + ::bevy_ui::PositionType, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ui::prelude::PositionType>| { + |_self: Ref<::bevy_ui::PositionType>| { let output: () = { { - let output: () = <::bevy_ui::prelude::PositionType as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_ui::PositionType as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -3790,10 +4171,10 @@ pub(crate) fn register_position_type_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::PositionType>| { - let output: Val<::bevy_ui::prelude::PositionType> = { + |_self: Ref<::bevy_ui::PositionType>| { + let output: Val<::bevy_ui::PositionType> = { { - let output: Val<::bevy_ui::prelude::PositionType> = <::bevy_ui::prelude::PositionType as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::PositionType> = <::bevy_ui::PositionType as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -3807,14 +4188,11 @@ pub(crate) fn register_position_type_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_ui::prelude::PositionType>, - other: Ref<::bevy_ui::prelude::PositionType>| - { + |_self: Ref<::bevy_ui::PositionType>, other: Ref<::bevy_ui::PositionType>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::PositionType as ::std::cmp::PartialEq< - ::bevy_ui::prelude::PositionType, + let output: bool = <::bevy_ui::PositionType as ::std::cmp::PartialEq< + ::bevy_ui::PositionType, >>::eq(&_self, &other) .into(); output @@ -3829,20 +4207,20 @@ pub(crate) fn register_position_type_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::PositionType, + ::bevy_ui::PositionType, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_align_self_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::AlignSelf, + ::bevy_ui::AlignSelf, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ui::prelude::AlignSelf>| { + |_self: Ref<::bevy_ui::AlignSelf>| { let output: () = { { - let output: () = <::bevy_ui::prelude::AlignSelf as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_ui::AlignSelf as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -3856,10 +4234,10 @@ pub(crate) fn register_align_self_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::AlignSelf>| { - let output: Val<::bevy_ui::prelude::AlignSelf> = { + |_self: Ref<::bevy_ui::AlignSelf>| { + let output: Val<::bevy_ui::AlignSelf> = { { - let output: Val<::bevy_ui::prelude::AlignSelf> = <::bevy_ui::prelude::AlignSelf as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::AlignSelf> = <::bevy_ui::AlignSelf as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -3873,14 +4251,11 @@ pub(crate) fn register_align_self_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_ui::prelude::AlignSelf>, - other: Ref<::bevy_ui::prelude::AlignSelf>| - { + |_self: Ref<::bevy_ui::AlignSelf>, other: Ref<::bevy_ui::AlignSelf>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::AlignSelf as ::std::cmp::PartialEq< - ::bevy_ui::prelude::AlignSelf, + let output: bool = <::bevy_ui::AlignSelf as ::std::cmp::PartialEq< + ::bevy_ui::AlignSelf, >>::eq(&_self, &other) .into(); output @@ -3895,69 +4270,69 @@ pub(crate) fn register_align_self_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::AlignSelf, + ::bevy_ui::AlignSelf, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_repeated_grid_track_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::RepeatedGridTrack, + ::bevy_ui::RepeatedGridTrack, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::prelude::RepeatedGridTrack>| { - let output: Val<::bevy_ui::prelude::RepeatedGridTrack> = { - { - let output: Val<::bevy_ui::prelude::RepeatedGridTrack> = - <::bevy_ui::prelude::RepeatedGridTrack as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::prelude::RepeatedGridTrack>, - other: Ref<::bevy_ui::prelude::RepeatedGridTrack>| { - let output: bool = { - { - let output: bool = - <::bevy_ui::prelude::RepeatedGridTrack as ::std::cmp::PartialEq< - ::bevy_ui::prelude::RepeatedGridTrack, + .register_documented( + "clone", + |_self: Ref<::bevy_ui::RepeatedGridTrack>| { + let output: Val<::bevy_ui::RepeatedGridTrack> = { + { + let output: Val<::bevy_ui::RepeatedGridTrack> = <::bevy_ui::RepeatedGridTrack as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::RepeatedGridTrack>, + other: Ref<::bevy_ui::RepeatedGridTrack>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::RepeatedGridTrack as ::std::cmp::PartialEq< + ::bevy_ui::RepeatedGridTrack, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::RepeatedGridTrack, + ::bevy_ui::RepeatedGridTrack, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_align_content_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::AlignContent, + ::bevy_ui::AlignContent, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ui::prelude::AlignContent>| { + |_self: Ref<::bevy_ui::AlignContent>| { let output: () = { { - let output: () = <::bevy_ui::prelude::AlignContent as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_ui::AlignContent as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -3971,10 +4346,10 @@ pub(crate) fn register_align_content_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::AlignContent>| { - let output: Val<::bevy_ui::prelude::AlignContent> = { + |_self: Ref<::bevy_ui::AlignContent>| { + let output: Val<::bevy_ui::AlignContent> = { { - let output: Val<::bevy_ui::prelude::AlignContent> = <::bevy_ui::prelude::AlignContent as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::AlignContent> = <::bevy_ui::AlignContent as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -3988,14 +4363,11 @@ pub(crate) fn register_align_content_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_ui::prelude::AlignContent>, - other: Ref<::bevy_ui::prelude::AlignContent>| - { + |_self: Ref<::bevy_ui::AlignContent>, other: Ref<::bevy_ui::AlignContent>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::AlignContent as ::std::cmp::PartialEq< - ::bevy_ui::prelude::AlignContent, + let output: bool = <::bevy_ui::AlignContent as ::std::cmp::PartialEq< + ::bevy_ui::AlignContent, >>::eq(&_self, &other) .into(); output @@ -4010,20 +4382,20 @@ pub(crate) fn register_align_content_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::AlignContent, + ::bevy_ui::AlignContent, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_align_items_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::AlignItems, + ::bevy_ui::AlignItems, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ui::prelude::AlignItems>| { + |_self: Ref<::bevy_ui::AlignItems>| { let output: () = { { - let output: () = <::bevy_ui::prelude::AlignItems as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_ui::AlignItems as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -4037,10 +4409,10 @@ pub(crate) fn register_align_items_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::AlignItems>| { - let output: Val<::bevy_ui::prelude::AlignItems> = { + |_self: Ref<::bevy_ui::AlignItems>| { + let output: Val<::bevy_ui::AlignItems> = { { - let output: Val<::bevy_ui::prelude::AlignItems> = <::bevy_ui::prelude::AlignItems as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::AlignItems> = <::bevy_ui::AlignItems as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -4054,14 +4426,11 @@ pub(crate) fn register_align_items_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_ui::prelude::AlignItems>, - other: Ref<::bevy_ui::prelude::AlignItems>| - { + |_self: Ref<::bevy_ui::AlignItems>, other: Ref<::bevy_ui::AlignItems>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::AlignItems as ::std::cmp::PartialEq< - ::bevy_ui::prelude::AlignItems, + let output: bool = <::bevy_ui::AlignItems as ::std::cmp::PartialEq< + ::bevy_ui::AlignItems, >>::eq(&_self, &other) .into(); output @@ -4076,20 +4445,20 @@ pub(crate) fn register_align_items_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::AlignItems, + ::bevy_ui::AlignItems, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_box_sizing_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::BoxSizing, + ::bevy_ui::BoxSizing, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ui::prelude::BoxSizing>| { + |_self: Ref<::bevy_ui::BoxSizing>| { let output: () = { { - let output: () = <::bevy_ui::prelude::BoxSizing as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_ui::BoxSizing as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -4103,10 +4472,10 @@ pub(crate) fn register_box_sizing_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::BoxSizing>| { - let output: Val<::bevy_ui::prelude::BoxSizing> = { + |_self: Ref<::bevy_ui::BoxSizing>| { + let output: Val<::bevy_ui::BoxSizing> = { { - let output: Val<::bevy_ui::prelude::BoxSizing> = <::bevy_ui::prelude::BoxSizing as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::BoxSizing> = <::bevy_ui::BoxSizing as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -4120,14 +4489,11 @@ pub(crate) fn register_box_sizing_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_ui::prelude::BoxSizing>, - other: Ref<::bevy_ui::prelude::BoxSizing>| - { + |_self: Ref<::bevy_ui::BoxSizing>, other: Ref<::bevy_ui::BoxSizing>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::BoxSizing as ::std::cmp::PartialEq< - ::bevy_ui::prelude::BoxSizing, + let output: bool = <::bevy_ui::BoxSizing as ::std::cmp::PartialEq< + ::bevy_ui::BoxSizing, >>::eq(&_self, &other) .into(); output @@ -4142,20 +4508,20 @@ pub(crate) fn register_box_sizing_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::BoxSizing, + ::bevy_ui::BoxSizing, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_flex_direction_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::FlexDirection, + ::bevy_ui::FlexDirection, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ui::prelude::FlexDirection>| { + |_self: Ref<::bevy_ui::FlexDirection>| { let output: () = { { - let output: () = <::bevy_ui::prelude::FlexDirection as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_ui::FlexDirection as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -4169,10 +4535,10 @@ pub(crate) fn register_flex_direction_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::FlexDirection>| { - let output: Val<::bevy_ui::prelude::FlexDirection> = { + |_self: Ref<::bevy_ui::FlexDirection>| { + let output: Val<::bevy_ui::FlexDirection> = { { - let output: Val<::bevy_ui::prelude::FlexDirection> = <::bevy_ui::prelude::FlexDirection as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::FlexDirection> = <::bevy_ui::FlexDirection as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -4186,14 +4552,11 @@ pub(crate) fn register_flex_direction_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_ui::prelude::FlexDirection>, - other: Ref<::bevy_ui::prelude::FlexDirection>| - { + |_self: Ref<::bevy_ui::FlexDirection>, other: Ref<::bevy_ui::FlexDirection>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::FlexDirection as ::std::cmp::PartialEq< - ::bevy_ui::prelude::FlexDirection, + let output: bool = <::bevy_ui::FlexDirection as ::std::cmp::PartialEq< + ::bevy_ui::FlexDirection, >>::eq(&_self, &other) .into(); output @@ -4208,20 +4571,20 @@ pub(crate) fn register_flex_direction_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::FlexDirection, + ::bevy_ui::FlexDirection, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_flex_wrap_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::FlexWrap, + ::bevy_ui::FlexWrap, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ui::prelude::FlexWrap>| { + |_self: Ref<::bevy_ui::FlexWrap>| { let output: () = { { - let output: () = <::bevy_ui::prelude::FlexWrap as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_ui::FlexWrap as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -4235,10 +4598,10 @@ pub(crate) fn register_flex_wrap_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::FlexWrap>| { - let output: Val<::bevy_ui::prelude::FlexWrap> = { + |_self: Ref<::bevy_ui::FlexWrap>| { + let output: Val<::bevy_ui::FlexWrap> = { { - let output: Val<::bevy_ui::prelude::FlexWrap> = <::bevy_ui::prelude::FlexWrap as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::FlexWrap> = <::bevy_ui::FlexWrap as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -4252,14 +4615,11 @@ pub(crate) fn register_flex_wrap_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_ui::prelude::FlexWrap>, - other: Ref<::bevy_ui::prelude::FlexWrap>| - { + |_self: Ref<::bevy_ui::FlexWrap>, other: Ref<::bevy_ui::FlexWrap>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::FlexWrap as ::std::cmp::PartialEq< - ::bevy_ui::prelude::FlexWrap, + let output: bool = <::bevy_ui::FlexWrap as ::std::cmp::PartialEq< + ::bevy_ui::FlexWrap, >>::eq(&_self, &other) .into(); output @@ -4274,20 +4634,20 @@ pub(crate) fn register_flex_wrap_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::FlexWrap, + ::bevy_ui::FlexWrap, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_grid_auto_flow_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::GridAutoFlow, + ::bevy_ui::GridAutoFlow, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ui::prelude::GridAutoFlow>| { + |_self: Ref<::bevy_ui::GridAutoFlow>| { let output: () = { { - let output: () = <::bevy_ui::prelude::GridAutoFlow as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_ui::GridAutoFlow as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -4301,10 +4661,10 @@ pub(crate) fn register_grid_auto_flow_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::GridAutoFlow>| { - let output: Val<::bevy_ui::prelude::GridAutoFlow> = { + |_self: Ref<::bevy_ui::GridAutoFlow>| { + let output: Val<::bevy_ui::GridAutoFlow> = { { - let output: Val<::bevy_ui::prelude::GridAutoFlow> = <::bevy_ui::prelude::GridAutoFlow as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::GridAutoFlow> = <::bevy_ui::GridAutoFlow as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -4318,14 +4678,11 @@ pub(crate) fn register_grid_auto_flow_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_ui::prelude::GridAutoFlow>, - other: Ref<::bevy_ui::prelude::GridAutoFlow>| - { + |_self: Ref<::bevy_ui::GridAutoFlow>, other: Ref<::bevy_ui::GridAutoFlow>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::GridAutoFlow as ::std::cmp::PartialEq< - ::bevy_ui::prelude::GridAutoFlow, + let output: bool = <::bevy_ui::GridAutoFlow as ::std::cmp::PartialEq< + ::bevy_ui::GridAutoFlow, >>::eq(&_self, &other) .into(); output @@ -4340,20 +4697,20 @@ pub(crate) fn register_grid_auto_flow_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::GridAutoFlow, + ::bevy_ui::GridAutoFlow, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_grid_placement_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::GridPlacement, + ::bevy_ui::GridPlacement, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ui::prelude::GridPlacement>| { + |_self: Ref<::bevy_ui::GridPlacement>| { let output: () = { { - let output: () = <::bevy_ui::prelude::GridPlacement as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_ui::GridPlacement as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -4368,9 +4725,9 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { .register_documented( "auto", || { - let output: Val<::bevy_ui::prelude::GridPlacement> = { + let output: Val<::bevy_ui::GridPlacement> = { { - let output: Val<::bevy_ui::prelude::GridPlacement> = ::bevy_ui::prelude::GridPlacement::auto() + let output: Val<::bevy_ui::GridPlacement> = ::bevy_ui::GridPlacement::auto() .into(); output } @@ -4382,10 +4739,10 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::GridPlacement>| { - let output: Val<::bevy_ui::prelude::GridPlacement> = { + |_self: Ref<::bevy_ui::GridPlacement>| { + let output: Val<::bevy_ui::GridPlacement> = { { - let output: Val<::bevy_ui::prelude::GridPlacement> = <::bevy_ui::prelude::GridPlacement as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::GridPlacement> = <::bevy_ui::GridPlacement as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -4400,9 +4757,9 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { .register_documented( "end", |end: i16| { - let output: Val<::bevy_ui::prelude::GridPlacement> = { + let output: Val<::bevy_ui::GridPlacement> = { { - let output: Val<::bevy_ui::prelude::GridPlacement> = ::bevy_ui::prelude::GridPlacement::end( + let output: Val<::bevy_ui::GridPlacement> = ::bevy_ui::GridPlacement::end( end, ) .into(); @@ -4417,9 +4774,9 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { .register_documented( "end_span", |end: i16, span: u16| { - let output: Val<::bevy_ui::prelude::GridPlacement> = { + let output: Val<::bevy_ui::GridPlacement> = { { - let output: Val<::bevy_ui::prelude::GridPlacement> = ::bevy_ui::prelude::GridPlacement::end_span( + let output: Val<::bevy_ui::GridPlacement> = ::bevy_ui::GridPlacement::end_span( end, span, ) @@ -4434,14 +4791,11 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_ui::prelude::GridPlacement>, - other: Ref<::bevy_ui::prelude::GridPlacement>| - { + |_self: Ref<::bevy_ui::GridPlacement>, other: Ref<::bevy_ui::GridPlacement>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::GridPlacement as ::std::cmp::PartialEq< - ::bevy_ui::prelude::GridPlacement, + let output: bool = <::bevy_ui::GridPlacement as ::std::cmp::PartialEq< + ::bevy_ui::GridPlacement, >>::eq(&_self, &other) .into(); output @@ -4454,10 +4808,10 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { ) .register_documented( "get_end", - |_self: Val<::bevy_ui::prelude::GridPlacement>| { + |_self: Val<::bevy_ui::GridPlacement>| { let output: ::std::option::Option = { { - let output: ::std::option::Option = ::bevy_ui::prelude::GridPlacement::get_end( + let output: ::std::option::Option = ::bevy_ui::GridPlacement::get_end( _self.into_inner(), ) .into(); @@ -4471,10 +4825,10 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { ) .register_documented( "get_span", - |_self: Val<::bevy_ui::prelude::GridPlacement>| { + |_self: Val<::bevy_ui::GridPlacement>| { let output: ::std::option::Option = { { - let output: ::std::option::Option = ::bevy_ui::prelude::GridPlacement::get_span( + let output: ::std::option::Option = ::bevy_ui::GridPlacement::get_span( _self.into_inner(), ) .into(); @@ -4488,10 +4842,10 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { ) .register_documented( "get_start", - |_self: Val<::bevy_ui::prelude::GridPlacement>| { + |_self: Val<::bevy_ui::GridPlacement>| { let output: ::std::option::Option = { { - let output: ::std::option::Option = ::bevy_ui::prelude::GridPlacement::get_start( + let output: ::std::option::Option = ::bevy_ui::GridPlacement::get_start( _self.into_inner(), ) .into(); @@ -4505,10 +4859,10 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { ) .register_documented( "set_end", - |_self: Val<::bevy_ui::prelude::GridPlacement>, end: i16| { - let output: Val<::bevy_ui::prelude::GridPlacement> = { + |_self: Val<::bevy_ui::GridPlacement>, end: i16| { + let output: Val<::bevy_ui::GridPlacement> = { { - let output: Val<::bevy_ui::prelude::GridPlacement> = ::bevy_ui::prelude::GridPlacement::set_end( + let output: Val<::bevy_ui::GridPlacement> = ::bevy_ui::GridPlacement::set_end( _self.into_inner(), end, ) @@ -4523,10 +4877,10 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { ) .register_documented( "set_span", - |_self: Val<::bevy_ui::prelude::GridPlacement>, span: u16| { - let output: Val<::bevy_ui::prelude::GridPlacement> = { + |_self: Val<::bevy_ui::GridPlacement>, span: u16| { + let output: Val<::bevy_ui::GridPlacement> = { { - let output: Val<::bevy_ui::prelude::GridPlacement> = ::bevy_ui::prelude::GridPlacement::set_span( + let output: Val<::bevy_ui::GridPlacement> = ::bevy_ui::GridPlacement::set_span( _self.into_inner(), span, ) @@ -4541,10 +4895,10 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { ) .register_documented( "set_start", - |_self: Val<::bevy_ui::prelude::GridPlacement>, start: i16| { - let output: Val<::bevy_ui::prelude::GridPlacement> = { + |_self: Val<::bevy_ui::GridPlacement>, start: i16| { + let output: Val<::bevy_ui::GridPlacement> = { { - let output: Val<::bevy_ui::prelude::GridPlacement> = ::bevy_ui::prelude::GridPlacement::set_start( + let output: Val<::bevy_ui::GridPlacement> = ::bevy_ui::GridPlacement::set_start( _self.into_inner(), start, ) @@ -4560,9 +4914,9 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { .register_documented( "span", |span: u16| { - let output: Val<::bevy_ui::prelude::GridPlacement> = { + let output: Val<::bevy_ui::GridPlacement> = { { - let output: Val<::bevy_ui::prelude::GridPlacement> = ::bevy_ui::prelude::GridPlacement::span( + let output: Val<::bevy_ui::GridPlacement> = ::bevy_ui::GridPlacement::span( span, ) .into(); @@ -4577,9 +4931,9 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { .register_documented( "start", |start: i16| { - let output: Val<::bevy_ui::prelude::GridPlacement> = { + let output: Val<::bevy_ui::GridPlacement> = { { - let output: Val<::bevy_ui::prelude::GridPlacement> = ::bevy_ui::prelude::GridPlacement::start( + let output: Val<::bevy_ui::GridPlacement> = ::bevy_ui::GridPlacement::start( start, ) .into(); @@ -4594,9 +4948,9 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { .register_documented( "start_end", |start: i16, end: i16| { - let output: Val<::bevy_ui::prelude::GridPlacement> = { + let output: Val<::bevy_ui::GridPlacement> = { { - let output: Val<::bevy_ui::prelude::GridPlacement> = ::bevy_ui::prelude::GridPlacement::start_end( + let output: Val<::bevy_ui::GridPlacement> = ::bevy_ui::GridPlacement::start_end( start, end, ) @@ -4612,9 +4966,9 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { .register_documented( "start_span", |start: i16, span: u16| { - let output: Val<::bevy_ui::prelude::GridPlacement> = { + let output: Val<::bevy_ui::GridPlacement> = { { - let output: Val<::bevy_ui::prelude::GridPlacement> = ::bevy_ui::prelude::GridPlacement::start_span( + let output: Val<::bevy_ui::GridPlacement> = ::bevy_ui::GridPlacement::start_span( start, span, ) @@ -4631,114 +4985,115 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::GridPlacement, + ::bevy_ui::GridPlacement, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_grid_track_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::GridTrack, + ::bevy_ui::GridTrack, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::prelude::GridTrack>| { - let output: Val<::bevy_ui::prelude::GridTrack> = { - { - let output: Val<::bevy_ui::prelude::GridTrack> = - <::bevy_ui::prelude::GridTrack as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::prelude::GridTrack>, other: Ref<::bevy_ui::prelude::GridTrack>| { - let output: bool = { - { - let output: bool = <::bevy_ui::prelude::GridTrack as ::std::cmp::PartialEq< - ::bevy_ui::prelude::GridTrack, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_ui::GridTrack>| { + let output: Val<::bevy_ui::GridTrack> = { + { + let output: Val<::bevy_ui::GridTrack> = <::bevy_ui::GridTrack as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::GridTrack>, other: Ref<::bevy_ui::GridTrack>| { + let output: bool = { + { + let output: bool = <::bevy_ui::GridTrack as ::std::cmp::PartialEq< + ::bevy_ui::GridTrack, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::GridTrack, + ::bevy_ui::GridTrack, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_grid_track_repetition_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::GridTrackRepetition, + ::bevy_ui::GridTrackRepetition, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::prelude::GridTrackRepetition>| { - let output: Val<::bevy_ui::prelude::GridTrackRepetition> = { - { - let output: Val<::bevy_ui::prelude::GridTrackRepetition> = - <::bevy_ui::prelude::GridTrackRepetition as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::prelude::GridTrackRepetition>, - other: Ref<::bevy_ui::prelude::GridTrackRepetition>| { - let output: bool = { - { - let output: bool = - <::bevy_ui::prelude::GridTrackRepetition as ::std::cmp::PartialEq< - ::bevy_ui::prelude::GridTrackRepetition, + .register_documented( + "clone", + |_self: Ref<::bevy_ui::GridTrackRepetition>| { + let output: Val<::bevy_ui::GridTrackRepetition> = { + { + let output: Val<::bevy_ui::GridTrackRepetition> = <::bevy_ui::GridTrackRepetition as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::GridTrackRepetition>, + other: Ref<::bevy_ui::GridTrackRepetition>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::GridTrackRepetition as ::std::cmp::PartialEq< + ::bevy_ui::GridTrackRepetition, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::GridTrackRepetition, + ::bevy_ui::GridTrackRepetition, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_justify_content_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::JustifyContent, + ::bevy_ui::JustifyContent, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ui::prelude::JustifyContent>| { + |_self: Ref<::bevy_ui::JustifyContent>| { let output: () = { { - let output: () = <::bevy_ui::prelude::JustifyContent as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_ui::JustifyContent as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -4752,10 +5107,10 @@ pub(crate) fn register_justify_content_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::JustifyContent>| { - let output: Val<::bevy_ui::prelude::JustifyContent> = { + |_self: Ref<::bevy_ui::JustifyContent>| { + let output: Val<::bevy_ui::JustifyContent> = { { - let output: Val<::bevy_ui::prelude::JustifyContent> = <::bevy_ui::prelude::JustifyContent as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::JustifyContent> = <::bevy_ui::JustifyContent as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -4770,13 +5125,13 @@ pub(crate) fn register_justify_content_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_ui::prelude::JustifyContent>, - other: Ref<::bevy_ui::prelude::JustifyContent>| + _self: Ref<::bevy_ui::JustifyContent>, + other: Ref<::bevy_ui::JustifyContent>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::JustifyContent as ::std::cmp::PartialEq< - ::bevy_ui::prelude::JustifyContent, + let output: bool = <::bevy_ui::JustifyContent as ::std::cmp::PartialEq< + ::bevy_ui::JustifyContent, >>::eq(&_self, &other) .into(); output @@ -4791,20 +5146,20 @@ pub(crate) fn register_justify_content_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::JustifyContent, + ::bevy_ui::JustifyContent, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_justify_items_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::JustifyItems, + ::bevy_ui::JustifyItems, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ui::prelude::JustifyItems>| { + |_self: Ref<::bevy_ui::JustifyItems>| { let output: () = { { - let output: () = <::bevy_ui::prelude::JustifyItems as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_ui::JustifyItems as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -4818,10 +5173,10 @@ pub(crate) fn register_justify_items_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::JustifyItems>| { - let output: Val<::bevy_ui::prelude::JustifyItems> = { + |_self: Ref<::bevy_ui::JustifyItems>| { + let output: Val<::bevy_ui::JustifyItems> = { { - let output: Val<::bevy_ui::prelude::JustifyItems> = <::bevy_ui::prelude::JustifyItems as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::JustifyItems> = <::bevy_ui::JustifyItems as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -4835,14 +5190,11 @@ pub(crate) fn register_justify_items_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_ui::prelude::JustifyItems>, - other: Ref<::bevy_ui::prelude::JustifyItems>| - { + |_self: Ref<::bevy_ui::JustifyItems>, other: Ref<::bevy_ui::JustifyItems>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::JustifyItems as ::std::cmp::PartialEq< - ::bevy_ui::prelude::JustifyItems, + let output: bool = <::bevy_ui::JustifyItems as ::std::cmp::PartialEq< + ::bevy_ui::JustifyItems, >>::eq(&_self, &other) .into(); output @@ -4857,20 +5209,20 @@ pub(crate) fn register_justify_items_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::JustifyItems, + ::bevy_ui::JustifyItems, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_justify_self_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::JustifySelf, + ::bevy_ui::JustifySelf, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ui::prelude::JustifySelf>| { + |_self: Ref<::bevy_ui::JustifySelf>| { let output: () = { { - let output: () = <::bevy_ui::prelude::JustifySelf as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_ui::JustifySelf as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -4884,10 +5236,10 @@ pub(crate) fn register_justify_self_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::JustifySelf>| { - let output: Val<::bevy_ui::prelude::JustifySelf> = { + |_self: Ref<::bevy_ui::JustifySelf>| { + let output: Val<::bevy_ui::JustifySelf> = { { - let output: Val<::bevy_ui::prelude::JustifySelf> = <::bevy_ui::prelude::JustifySelf as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::JustifySelf> = <::bevy_ui::JustifySelf as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -4901,14 +5253,11 @@ pub(crate) fn register_justify_self_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_ui::prelude::JustifySelf>, - other: Ref<::bevy_ui::prelude::JustifySelf>| - { + |_self: Ref<::bevy_ui::JustifySelf>, other: Ref<::bevy_ui::JustifySelf>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::JustifySelf as ::std::cmp::PartialEq< - ::bevy_ui::prelude::JustifySelf, + let output: bool = <::bevy_ui::JustifySelf as ::std::cmp::PartialEq< + ::bevy_ui::JustifySelf, >>::eq(&_self, &other) .into(); output @@ -4923,118 +5272,118 @@ pub(crate) fn register_justify_self_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::JustifySelf, + ::bevy_ui::JustifySelf, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_max_track_sizing_function_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::MaxTrackSizingFunction, + ::bevy_ui::MaxTrackSizingFunction, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::prelude::MaxTrackSizingFunction>| { - let output: Val<::bevy_ui::prelude::MaxTrackSizingFunction> = { - { - let output: Val<::bevy_ui::prelude::MaxTrackSizingFunction> = - <::bevy_ui::prelude::MaxTrackSizingFunction as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::prelude::MaxTrackSizingFunction>, - other: Ref<::bevy_ui::prelude::MaxTrackSizingFunction>| { - let output: bool = { - { - let output: bool = - <::bevy_ui::prelude::MaxTrackSizingFunction as ::std::cmp::PartialEq< - ::bevy_ui::prelude::MaxTrackSizingFunction, + .register_documented( + "clone", + |_self: Ref<::bevy_ui::MaxTrackSizingFunction>| { + let output: Val<::bevy_ui::MaxTrackSizingFunction> = { + { + let output: Val<::bevy_ui::MaxTrackSizingFunction> = <::bevy_ui::MaxTrackSizingFunction as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::MaxTrackSizingFunction>, + other: Ref<::bevy_ui::MaxTrackSizingFunction>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::MaxTrackSizingFunction as ::std::cmp::PartialEq< + ::bevy_ui::MaxTrackSizingFunction, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::MaxTrackSizingFunction, + ::bevy_ui::MaxTrackSizingFunction, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_min_track_sizing_function_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::MinTrackSizingFunction, + ::bevy_ui::MinTrackSizingFunction, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::prelude::MinTrackSizingFunction>| { - let output: Val<::bevy_ui::prelude::MinTrackSizingFunction> = { - { - let output: Val<::bevy_ui::prelude::MinTrackSizingFunction> = - <::bevy_ui::prelude::MinTrackSizingFunction as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::prelude::MinTrackSizingFunction>, - other: Ref<::bevy_ui::prelude::MinTrackSizingFunction>| { - let output: bool = { - { - let output: bool = - <::bevy_ui::prelude::MinTrackSizingFunction as ::std::cmp::PartialEq< - ::bevy_ui::prelude::MinTrackSizingFunction, + .register_documented( + "clone", + |_self: Ref<::bevy_ui::MinTrackSizingFunction>| { + let output: Val<::bevy_ui::MinTrackSizingFunction> = { + { + let output: Val<::bevy_ui::MinTrackSizingFunction> = <::bevy_ui::MinTrackSizingFunction as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::MinTrackSizingFunction>, + other: Ref<::bevy_ui::MinTrackSizingFunction>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::MinTrackSizingFunction as ::std::cmp::PartialEq< + ::bevy_ui::MinTrackSizingFunction, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::MinTrackSizingFunction, + ::bevy_ui::MinTrackSizingFunction, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_overflow_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::Overflow, + ::bevy_ui::Overflow, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ui::prelude::Overflow>| { + |_self: Ref<::bevy_ui::Overflow>| { let output: () = { { - let output: () = <::bevy_ui::prelude::Overflow as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_ui::Overflow as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -5049,9 +5398,9 @@ pub(crate) fn register_overflow_functions(world: &mut World) { .register_documented( "clip", || { - let output: Val<::bevy_ui::prelude::Overflow> = { + let output: Val<::bevy_ui::Overflow> = { { - let output: Val<::bevy_ui::prelude::Overflow> = ::bevy_ui::prelude::Overflow::clip() + let output: Val<::bevy_ui::Overflow> = ::bevy_ui::Overflow::clip() .into(); output } @@ -5064,9 +5413,9 @@ pub(crate) fn register_overflow_functions(world: &mut World) { .register_documented( "clip_x", || { - let output: Val<::bevy_ui::prelude::Overflow> = { + let output: Val<::bevy_ui::Overflow> = { { - let output: Val<::bevy_ui::prelude::Overflow> = ::bevy_ui::prelude::Overflow::clip_x() + let output: Val<::bevy_ui::Overflow> = ::bevy_ui::Overflow::clip_x() .into(); output } @@ -5079,9 +5428,9 @@ pub(crate) fn register_overflow_functions(world: &mut World) { .register_documented( "clip_y", || { - let output: Val<::bevy_ui::prelude::Overflow> = { + let output: Val<::bevy_ui::Overflow> = { { - let output: Val<::bevy_ui::prelude::Overflow> = ::bevy_ui::prelude::Overflow::clip_y() + let output: Val<::bevy_ui::Overflow> = ::bevy_ui::Overflow::clip_y() .into(); output } @@ -5093,10 +5442,10 @@ pub(crate) fn register_overflow_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::Overflow>| { - let output: Val<::bevy_ui::prelude::Overflow> = { + |_self: Ref<::bevy_ui::Overflow>| { + let output: Val<::bevy_ui::Overflow> = { { - let output: Val<::bevy_ui::prelude::Overflow> = <::bevy_ui::prelude::Overflow as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::Overflow> = <::bevy_ui::Overflow as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -5110,14 +5459,11 @@ pub(crate) fn register_overflow_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_ui::prelude::Overflow>, - other: Ref<::bevy_ui::prelude::Overflow>| - { + |_self: Ref<::bevy_ui::Overflow>, other: Ref<::bevy_ui::Overflow>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::Overflow as ::std::cmp::PartialEq< - ::bevy_ui::prelude::Overflow, + let output: bool = <::bevy_ui::Overflow as ::std::cmp::PartialEq< + ::bevy_ui::Overflow, >>::eq(&_self, &other) .into(); output @@ -5131,9 +5477,9 @@ pub(crate) fn register_overflow_functions(world: &mut World) { .register_documented( "hidden", || { - let output: Val<::bevy_ui::prelude::Overflow> = { + let output: Val<::bevy_ui::Overflow> = { { - let output: Val<::bevy_ui::prelude::Overflow> = ::bevy_ui::prelude::Overflow::hidden() + let output: Val<::bevy_ui::Overflow> = ::bevy_ui::Overflow::hidden() .into(); output } @@ -5146,9 +5492,9 @@ pub(crate) fn register_overflow_functions(world: &mut World) { .register_documented( "hidden_x", || { - let output: Val<::bevy_ui::prelude::Overflow> = { + let output: Val<::bevy_ui::Overflow> = { { - let output: Val<::bevy_ui::prelude::Overflow> = ::bevy_ui::prelude::Overflow::hidden_x() + let output: Val<::bevy_ui::Overflow> = ::bevy_ui::Overflow::hidden_x() .into(); output } @@ -5161,9 +5507,9 @@ pub(crate) fn register_overflow_functions(world: &mut World) { .register_documented( "hidden_y", || { - let output: Val<::bevy_ui::prelude::Overflow> = { + let output: Val<::bevy_ui::Overflow> = { { - let output: Val<::bevy_ui::prelude::Overflow> = ::bevy_ui::prelude::Overflow::hidden_y() + let output: Val<::bevy_ui::Overflow> = ::bevy_ui::Overflow::hidden_y() .into(); output } @@ -5175,12 +5521,10 @@ pub(crate) fn register_overflow_functions(world: &mut World) { ) .register_documented( "is_visible", - |_self: Ref<::bevy_ui::prelude::Overflow>| { + |_self: Ref<::bevy_ui::Overflow>| { let output: bool = { { - let output: bool = ::bevy_ui::prelude::Overflow::is_visible( - &_self, - ) + let output: bool = ::bevy_ui::Overflow::is_visible(&_self) .into(); output } @@ -5193,9 +5537,9 @@ pub(crate) fn register_overflow_functions(world: &mut World) { .register_documented( "scroll", || { - let output: Val<::bevy_ui::prelude::Overflow> = { + let output: Val<::bevy_ui::Overflow> = { { - let output: Val<::bevy_ui::prelude::Overflow> = ::bevy_ui::prelude::Overflow::scroll() + let output: Val<::bevy_ui::Overflow> = ::bevy_ui::Overflow::scroll() .into(); output } @@ -5208,9 +5552,9 @@ pub(crate) fn register_overflow_functions(world: &mut World) { .register_documented( "scroll_x", || { - let output: Val<::bevy_ui::prelude::Overflow> = { + let output: Val<::bevy_ui::Overflow> = { { - let output: Val<::bevy_ui::prelude::Overflow> = ::bevy_ui::prelude::Overflow::scroll_x() + let output: Val<::bevy_ui::Overflow> = ::bevy_ui::Overflow::scroll_x() .into(); output } @@ -5223,9 +5567,9 @@ pub(crate) fn register_overflow_functions(world: &mut World) { .register_documented( "scroll_y", || { - let output: Val<::bevy_ui::prelude::Overflow> = { + let output: Val<::bevy_ui::Overflow> = { { - let output: Val<::bevy_ui::prelude::Overflow> = ::bevy_ui::prelude::Overflow::scroll_y() + let output: Val<::bevy_ui::Overflow> = ::bevy_ui::Overflow::scroll_y() .into(); output } @@ -5238,9 +5582,9 @@ pub(crate) fn register_overflow_functions(world: &mut World) { .register_documented( "visible", || { - let output: Val<::bevy_ui::prelude::Overflow> = { + let output: Val<::bevy_ui::Overflow> = { { - let output: Val<::bevy_ui::prelude::Overflow> = ::bevy_ui::prelude::Overflow::visible() + let output: Val<::bevy_ui::Overflow> = ::bevy_ui::Overflow::visible() .into(); output } @@ -5254,20 +5598,20 @@ pub(crate) fn register_overflow_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::Overflow, + ::bevy_ui::Overflow, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_overflow_clip_margin_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::OverflowClipMargin, + ::bevy_ui::OverflowClipMargin, >::new(world) .register_documented( "border_box", || { - let output: Val<::bevy_ui::prelude::OverflowClipMargin> = { + let output: Val<::bevy_ui::OverflowClipMargin> = { { - let output: Val<::bevy_ui::prelude::OverflowClipMargin> = ::bevy_ui::prelude::OverflowClipMargin::border_box() + let output: Val<::bevy_ui::OverflowClipMargin> = ::bevy_ui::OverflowClipMargin::border_box() .into(); output } @@ -5279,10 +5623,10 @@ pub(crate) fn register_overflow_clip_margin_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::OverflowClipMargin>| { - let output: Val<::bevy_ui::prelude::OverflowClipMargin> = { + |_self: Ref<::bevy_ui::OverflowClipMargin>| { + let output: Val<::bevy_ui::OverflowClipMargin> = { { - let output: Val<::bevy_ui::prelude::OverflowClipMargin> = <::bevy_ui::prelude::OverflowClipMargin as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::OverflowClipMargin> = <::bevy_ui::OverflowClipMargin as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -5297,9 +5641,9 @@ pub(crate) fn register_overflow_clip_margin_functions(world: &mut World) { .register_documented( "content_box", || { - let output: Val<::bevy_ui::prelude::OverflowClipMargin> = { + let output: Val<::bevy_ui::OverflowClipMargin> = { { - let output: Val<::bevy_ui::prelude::OverflowClipMargin> = ::bevy_ui::prelude::OverflowClipMargin::content_box() + let output: Val<::bevy_ui::OverflowClipMargin> = ::bevy_ui::OverflowClipMargin::content_box() .into(); output } @@ -5312,13 +5656,13 @@ pub(crate) fn register_overflow_clip_margin_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_ui::prelude::OverflowClipMargin>, - other: Ref<::bevy_ui::prelude::OverflowClipMargin>| + _self: Ref<::bevy_ui::OverflowClipMargin>, + other: Ref<::bevy_ui::OverflowClipMargin>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::OverflowClipMargin as ::std::cmp::PartialEq< - ::bevy_ui::prelude::OverflowClipMargin, + let output: bool = <::bevy_ui::OverflowClipMargin as ::std::cmp::PartialEq< + ::bevy_ui::OverflowClipMargin, >>::eq(&_self, &other) .into(); output @@ -5332,9 +5676,9 @@ pub(crate) fn register_overflow_clip_margin_functions(world: &mut World) { .register_documented( "padding_box", || { - let output: Val<::bevy_ui::prelude::OverflowClipMargin> = { + let output: Val<::bevy_ui::OverflowClipMargin> = { { - let output: Val<::bevy_ui::prelude::OverflowClipMargin> = ::bevy_ui::prelude::OverflowClipMargin::padding_box() + let output: Val<::bevy_ui::OverflowClipMargin> = ::bevy_ui::OverflowClipMargin::padding_box() .into(); output } @@ -5346,10 +5690,10 @@ pub(crate) fn register_overflow_clip_margin_functions(world: &mut World) { ) .register_documented( "with_margin", - |_self: Val<::bevy_ui::prelude::OverflowClipMargin>, margin: f32| { - let output: Val<::bevy_ui::prelude::OverflowClipMargin> = { + |_self: Val<::bevy_ui::OverflowClipMargin>, margin: f32| { + let output: Val<::bevy_ui::OverflowClipMargin> = { { - let output: Val<::bevy_ui::prelude::OverflowClipMargin> = ::bevy_ui::prelude::OverflowClipMargin::with_margin( + let output: Val<::bevy_ui::OverflowClipMargin> = ::bevy_ui::OverflowClipMargin::with_margin( _self.into_inner(), margin, ) @@ -5366,20 +5710,20 @@ pub(crate) fn register_overflow_clip_margin_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::OverflowClipMargin, + ::bevy_ui::OverflowClipMargin, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_global_z_index_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::GlobalZIndex, + ::bevy_ui::GlobalZIndex, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ui::prelude::GlobalZIndex>| { + |_self: Ref<::bevy_ui::GlobalZIndex>| { let output: () = { { - let output: () = <::bevy_ui::prelude::GlobalZIndex as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_ui::GlobalZIndex as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -5393,10 +5737,10 @@ pub(crate) fn register_global_z_index_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::GlobalZIndex>| { - let output: Val<::bevy_ui::prelude::GlobalZIndex> = { + |_self: Ref<::bevy_ui::GlobalZIndex>| { + let output: Val<::bevy_ui::GlobalZIndex> = { { - let output: Val<::bevy_ui::prelude::GlobalZIndex> = <::bevy_ui::prelude::GlobalZIndex as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::GlobalZIndex> = <::bevy_ui::GlobalZIndex as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -5410,14 +5754,11 @@ pub(crate) fn register_global_z_index_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_ui::prelude::GlobalZIndex>, - other: Ref<::bevy_ui::prelude::GlobalZIndex>| - { + |_self: Ref<::bevy_ui::GlobalZIndex>, other: Ref<::bevy_ui::GlobalZIndex>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::GlobalZIndex as ::std::cmp::PartialEq< - ::bevy_ui::prelude::GlobalZIndex, + let output: bool = <::bevy_ui::GlobalZIndex as ::std::cmp::PartialEq< + ::bevy_ui::GlobalZIndex, >>::eq(&_self, &other) .into(); output @@ -5432,20 +5773,20 @@ pub(crate) fn register_global_z_index_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::GlobalZIndex, + ::bevy_ui::GlobalZIndex, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_z_index_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::ZIndex, + ::bevy_ui::ZIndex, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ui::prelude::ZIndex>| { + |_self: Ref<::bevy_ui::ZIndex>| { let output: () = { { - let output: () = <::bevy_ui::prelude::ZIndex as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_ui::ZIndex as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -5459,10 +5800,10 @@ pub(crate) fn register_z_index_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui::prelude::ZIndex>| { - let output: Val<::bevy_ui::prelude::ZIndex> = { + |_self: Ref<::bevy_ui::ZIndex>| { + let output: Val<::bevy_ui::ZIndex> = { { - let output: Val<::bevy_ui::prelude::ZIndex> = <::bevy_ui::prelude::ZIndex as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui::ZIndex> = <::bevy_ui::ZIndex as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -5476,14 +5817,11 @@ pub(crate) fn register_z_index_functions(world: &mut World) { ) .register_documented( "eq", - | - _self: Ref<::bevy_ui::prelude::ZIndex>, - other: Ref<::bevy_ui::prelude::ZIndex>| - { + |_self: Ref<::bevy_ui::ZIndex>, other: Ref<::bevy_ui::ZIndex>| { let output: bool = { { - let output: bool = <::bevy_ui::prelude::ZIndex as ::std::cmp::PartialEq< - ::bevy_ui::prelude::ZIndex, + let output: bool = <::bevy_ui::ZIndex as ::std::cmp::PartialEq< + ::bevy_ui::ZIndex, >>::eq(&_self, &other) .into(); output @@ -5498,287 +5836,287 @@ pub(crate) fn register_z_index_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::ZIndex, + ::bevy_ui::ZIndex, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_resolved_border_radius_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::ResolvedBorderRadius, + ::bevy_ui::ResolvedBorderRadius, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::prelude::ResolvedBorderRadius>| { - let output: Val<::bevy_ui::prelude::ResolvedBorderRadius> = { - { - let output: Val<::bevy_ui::prelude::ResolvedBorderRadius> = - <::bevy_ui::prelude::ResolvedBorderRadius as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::prelude::ResolvedBorderRadius>, - other: Ref<::bevy_ui::prelude::ResolvedBorderRadius>| { - let output: bool = { - { - let output: bool = - <::bevy_ui::prelude::ResolvedBorderRadius as ::std::cmp::PartialEq< - ::bevy_ui::prelude::ResolvedBorderRadius, + .register_documented( + "clone", + |_self: Ref<::bevy_ui::ResolvedBorderRadius>| { + let output: Val<::bevy_ui::ResolvedBorderRadius> = { + { + let output: Val<::bevy_ui::ResolvedBorderRadius> = <::bevy_ui::ResolvedBorderRadius as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::ResolvedBorderRadius>, + other: Ref<::bevy_ui::ResolvedBorderRadius>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::ResolvedBorderRadius as ::std::cmp::PartialEq< + ::bevy_ui::ResolvedBorderRadius, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::ResolvedBorderRadius, + ::bevy_ui::ResolvedBorderRadius, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_background_color_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::BackgroundColor, + ::bevy_ui::BackgroundColor, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::prelude::BackgroundColor>| { - let output: Val<::bevy_ui::prelude::BackgroundColor> = { - { - let output: Val<::bevy_ui::prelude::BackgroundColor> = - <::bevy_ui::prelude::BackgroundColor as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::prelude::BackgroundColor>, - other: Ref<::bevy_ui::prelude::BackgroundColor>| { - let output: bool = { - { - let output: bool = - <::bevy_ui::prelude::BackgroundColor as ::std::cmp::PartialEq< - ::bevy_ui::prelude::BackgroundColor, + .register_documented( + "clone", + |_self: Ref<::bevy_ui::BackgroundColor>| { + let output: Val<::bevy_ui::BackgroundColor> = { + { + let output: Val<::bevy_ui::BackgroundColor> = <::bevy_ui::BackgroundColor as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + | + _self: Ref<::bevy_ui::BackgroundColor>, + other: Ref<::bevy_ui::BackgroundColor>| + { + let output: bool = { + { + let output: bool = <::bevy_ui::BackgroundColor as ::std::cmp::PartialEq< + ::bevy_ui::BackgroundColor, >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::BackgroundColor, + ::bevy_ui::BackgroundColor, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_border_color_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::BorderColor, + ::bevy_ui::BorderColor, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::prelude::BorderColor>| { - let output: Val<::bevy_ui::prelude::BorderColor> = { - { - let output: Val<::bevy_ui::prelude::BorderColor> = - <::bevy_ui::prelude::BorderColor as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::prelude::BorderColor>, - other: Ref<::bevy_ui::prelude::BorderColor>| { - let output: bool = { - { - let output: bool = <::bevy_ui::prelude::BorderColor as ::std::cmp::PartialEq< - ::bevy_ui::prelude::BorderColor, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "is_fully_transparent", - |_self: Ref<::bevy_ui::prelude::BorderColor>| { - let output: bool = { - { - let output: bool = - ::bevy_ui::prelude::BorderColor::is_fully_transparent(&_self).into(); - output - } - }; - output - }, - " Check if all contained border colors are transparent", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_ui::BorderColor>| { + let output: Val<::bevy_ui::BorderColor> = { + { + let output: Val<::bevy_ui::BorderColor> = <::bevy_ui::BorderColor as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::BorderColor>, other: Ref<::bevy_ui::BorderColor>| { + let output: bool = { + { + let output: bool = <::bevy_ui::BorderColor as ::std::cmp::PartialEq< + ::bevy_ui::BorderColor, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "is_fully_transparent", + |_self: Ref<::bevy_ui::BorderColor>| { + let output: bool = { + { + let output: bool = ::bevy_ui::BorderColor::is_fully_transparent( + &_self, + ) + .into(); + output + } + }; + output + }, + " Check if all contained border colors are transparent", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::BorderColor, + ::bevy_ui::BorderColor, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_box_shadow_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::BoxShadow, + ::bevy_ui::BoxShadow, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::prelude::BoxShadow>| { - let output: Val<::bevy_ui::prelude::BoxShadow> = { - { - let output: Val<::bevy_ui::prelude::BoxShadow> = - <::bevy_ui::prelude::BoxShadow as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::prelude::BoxShadow>, other: Ref<::bevy_ui::prelude::BoxShadow>| { - let output: bool = { - { - let output: bool = <::bevy_ui::prelude::BoxShadow as ::std::cmp::PartialEq< - ::bevy_ui::prelude::BoxShadow, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "new", - |color: Val<::bevy_color::Color>, - x_offset: Val<::bevy_ui::prelude::Val>, - y_offset: Val<::bevy_ui::prelude::Val>, - spread_radius: Val<::bevy_ui::prelude::Val>, - blur_radius: Val<::bevy_ui::prelude::Val>| { - let output: Val<::bevy_ui::prelude::BoxShadow> = { - { - let output: Val<::bevy_ui::prelude::BoxShadow> = - ::bevy_ui::prelude::BoxShadow::new( - color.into_inner(), - x_offset.into_inner(), - y_offset.into_inner(), - spread_radius.into_inner(), - blur_radius.into_inner(), - ) - .into(); - output - } - }; - output - }, - " A single drop shadow", - &[ - "color", - "x_offset", - "y_offset", - "spread_radius", - "blur_radius", - ], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_ui::BoxShadow>| { + let output: Val<::bevy_ui::BoxShadow> = { + { + let output: Val<::bevy_ui::BoxShadow> = <::bevy_ui::BoxShadow as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::BoxShadow>, other: Ref<::bevy_ui::BoxShadow>| { + let output: bool = { + { + let output: bool = <::bevy_ui::BoxShadow as ::std::cmp::PartialEq< + ::bevy_ui::BoxShadow, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "new", + | + color: Val<::bevy_color::Color>, + x_offset: Val<::bevy_ui::Val>, + y_offset: Val<::bevy_ui::Val>, + spread_radius: Val<::bevy_ui::Val>, + blur_radius: Val<::bevy_ui::Val>| + { + let output: Val<::bevy_ui::BoxShadow> = { + { + let output: Val<::bevy_ui::BoxShadow> = ::bevy_ui::BoxShadow::new( + color.into_inner(), + x_offset.into_inner(), + y_offset.into_inner(), + spread_radius.into_inner(), + blur_radius.into_inner(), + ) + .into(); + output + } + }; + output + }, + " A single drop shadow", + &["color", "x_offset", "y_offset", "spread_radius", "blur_radius"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::BoxShadow, + ::bevy_ui::BoxShadow, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_shadow_style_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui::prelude::ShadowStyle, + ::bevy_ui::ShadowStyle, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ui::prelude::ShadowStyle>| { - let output: Val<::bevy_ui::prelude::ShadowStyle> = { - { - let output: Val<::bevy_ui::prelude::ShadowStyle> = - <::bevy_ui::prelude::ShadowStyle as ::std::clone::Clone>::clone(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::bevy_ui::prelude::ShadowStyle>, - other: Ref<::bevy_ui::prelude::ShadowStyle>| { - let output: bool = { - { - let output: bool = <::bevy_ui::prelude::ShadowStyle as ::std::cmp::PartialEq< - ::bevy_ui::prelude::ShadowStyle, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_ui::ShadowStyle>| { + let output: Val<::bevy_ui::ShadowStyle> = { + { + let output: Val<::bevy_ui::ShadowStyle> = <::bevy_ui::ShadowStyle as ::std::clone::Clone>::clone( + &_self, + ) + .into(); + output + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::bevy_ui::ShadowStyle>, other: Ref<::bevy_ui::ShadowStyle>| { + let output: bool = { + { + let output: bool = <::bevy_ui::ShadowStyle as ::std::cmp::PartialEq< + ::bevy_ui::ShadowStyle, + >>::eq(&_self, &other) + .into(); + output + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui::prelude::ShadowStyle, + ::bevy_ui::ShadowStyle, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } diff --git a/crates/bindings/bevy_ui_render_bms_bindings/src/lib.rs b/crates/bindings/bevy_ui_render_bms_bindings/src/lib.rs index abe7a127c1..d2db5cee1f 100644 --- a/crates/bindings/bevy_ui_render_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_ui_render_bms_bindings/src/lib.rs @@ -1,27 +1,30 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, + from::{Ref, Mut, Val}, namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyUiRenderScriptingPlugin; pub(crate) fn register_box_shadow_samples_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui_render::prelude::BoxShadowSamples, + ::bevy_ui_render::BoxShadowSamples, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ui_render::prelude::BoxShadowSamples>| { + |_self: Ref<::bevy_ui_render::BoxShadowSamples>| { let output: () = { { - let output: () = <::bevy_ui_render::prelude::BoxShadowSamples as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_ui_render::BoxShadowSamples as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -35,10 +38,10 @@ pub(crate) fn register_box_shadow_samples_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui_render::prelude::BoxShadowSamples>| { - let output: Val<::bevy_ui_render::prelude::BoxShadowSamples> = { + |_self: Ref<::bevy_ui_render::BoxShadowSamples>| { + let output: Val<::bevy_ui_render::BoxShadowSamples> = { { - let output: Val<::bevy_ui_render::prelude::BoxShadowSamples> = <::bevy_ui_render::prelude::BoxShadowSamples as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui_render::BoxShadowSamples> = <::bevy_ui_render::BoxShadowSamples as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -53,13 +56,13 @@ pub(crate) fn register_box_shadow_samples_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_ui_render::prelude::BoxShadowSamples>, - other: Ref<::bevy_ui_render::prelude::BoxShadowSamples>| + _self: Ref<::bevy_ui_render::BoxShadowSamples>, + other: Ref<::bevy_ui_render::BoxShadowSamples>| { let output: bool = { { - let output: bool = <::bevy_ui_render::prelude::BoxShadowSamples as ::std::cmp::PartialEq< - ::bevy_ui_render::prelude::BoxShadowSamples, + let output: bool = <::bevy_ui_render::BoxShadowSamples as ::std::cmp::PartialEq< + ::bevy_ui_render::BoxShadowSamples, >>::eq(&_self, &other) .into(); output @@ -74,20 +77,20 @@ pub(crate) fn register_box_shadow_samples_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui_render::prelude::BoxShadowSamples, + ::bevy_ui_render::BoxShadowSamples, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } pub(crate) fn register_ui_anti_alias_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< - ::bevy_ui_render::prelude::UiAntiAlias, + ::bevy_ui_render::UiAntiAlias, >::new(world) .register_documented( "assert_receiver_is_total_eq", - |_self: Ref<::bevy_ui_render::prelude::UiAntiAlias>| { + |_self: Ref<::bevy_ui_render::UiAntiAlias>| { let output: () = { { - let output: () = <::bevy_ui_render::prelude::UiAntiAlias as ::std::cmp::Eq>::assert_receiver_is_total_eq( + let output: () = <::bevy_ui_render::UiAntiAlias as ::std::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -101,10 +104,10 @@ pub(crate) fn register_ui_anti_alias_functions(world: &mut World) { ) .register_documented( "clone", - |_self: Ref<::bevy_ui_render::prelude::UiAntiAlias>| { - let output: Val<::bevy_ui_render::prelude::UiAntiAlias> = { + |_self: Ref<::bevy_ui_render::UiAntiAlias>| { + let output: Val<::bevy_ui_render::UiAntiAlias> = { { - let output: Val<::bevy_ui_render::prelude::UiAntiAlias> = <::bevy_ui_render::prelude::UiAntiAlias as ::std::clone::Clone>::clone( + let output: Val<::bevy_ui_render::UiAntiAlias> = <::bevy_ui_render::UiAntiAlias as ::std::clone::Clone>::clone( &_self, ) .into(); @@ -119,13 +122,13 @@ pub(crate) fn register_ui_anti_alias_functions(world: &mut World) { .register_documented( "eq", | - _self: Ref<::bevy_ui_render::prelude::UiAntiAlias>, - other: Ref<::bevy_ui_render::prelude::UiAntiAlias>| + _self: Ref<::bevy_ui_render::UiAntiAlias>, + other: Ref<::bevy_ui_render::UiAntiAlias>| { let output: bool = { { - let output: bool = <::bevy_ui_render::prelude::UiAntiAlias as ::std::cmp::PartialEq< - ::bevy_ui_render::prelude::UiAntiAlias, + let output: bool = <::bevy_ui_render::UiAntiAlias as ::std::cmp::PartialEq< + ::bevy_ui_render::UiAntiAlias, >>::eq(&_self, &other) .into(); output @@ -140,7 +143,7 @@ pub(crate) fn register_ui_anti_alias_functions(world: &mut World) { let mut registry = registry.write(); registry .register_type_data::< - ::bevy_ui_render::prelude::UiAntiAlias, + ::bevy_ui_render::UiAntiAlias, bevy_mod_scripting_bindings::MarkAsGenerated, >(); } diff --git a/makefile b/makefile index 11927a5baf..8fd3a7c73e 100644 --- a/makefile +++ b/makefile @@ -63,10 +63,10 @@ clean_bevy: cd ${BEVY_PATH} && cargo clean generate_bevy: - cd ${BEVY_PATH} && cargo +${NIGHTLY_VERSION} bevy-api-gen generate --output ${OUTPUT_PATH} --template-args '{ "self_is_bms_lua": true}' --features ${GEN_BEVY_FEATURES} -vv + cd ${BEVY_PATH} && cargo +${NIGHTLY_VERSION} bevy-api-gen generate --output ${OUTPUT_PATH} --features ${GEN_BEVY_FEATURES} -vv collect_bevy: - cd ${BEVY_PATH} && cargo +${NIGHTLY_VERSION} bevy-api-gen collect --output ${OUTPUT_PATH} --template-args '{ "self_is_bms_lua": true}' + cd ${BEVY_PATH} && cargo +${NIGHTLY_VERSION} bevy-api-gen collect --output ${OUTPUT_PATH} deletion_confirmation: @echo -n "This action will delete ALL files in directories: '${GENERATED_SRC_PATH}' amd ${OUTPUT_PATH} (y/N) " diff --git a/xtask/src/args.rs b/xtask/src/args.rs new file mode 100644 index 0000000000..d34bc6a03a --- /dev/null +++ b/xtask/src/args.rs @@ -0,0 +1,86 @@ +use std::path::PathBuf; + +use crate::features::Features; +use clap::Parser; + +#[derive(Debug, Parser, Clone)] +pub struct GlobalArgs { + #[clap(long, short, global = true, value_parser=clap::value_parser!(Features), value_name=Features::to_placeholder(), default_value=Features::default().to_string(),required = false)] + pub features: Features, + + #[clap( + long, + global = true, + default_value = "false", + help = "Enable coverage collection for cargo commands" + )] + pub coverage: bool, + + #[clap(skip)] + pub override_workspace_dir: Option, + + #[clap(skip)] + pub override_toolchain: Option, + + #[clap( + long, + short, + global = true, + value_name = "PROFILE", + help = "The cargo profile to use for commands that support it" + )] + pub profile: Option, + + #[clap( + long, + global = true, + value_name = "JOBS", + help = "The number of parallel jobs to run at most" + )] + pub jobs: Option, +} + +impl GlobalArgs { + pub fn with_max_jobs(self, jobs: usize) -> Self { + Self { + jobs: Some(jobs), + ..self + } + } + + pub fn with_coverage(self) -> Self { + Self { + coverage: true, + ..self + } + } + + pub fn without_coverage(self) -> Self { + Self { + coverage: false, + ..self + } + } + + pub fn with_workspace_dir(self, dir: PathBuf) -> Self { + Self { + override_workspace_dir: Some(dir), + ..self + } + } + + pub fn with_toolchain(self, toolchain: String) -> Self { + Self { + override_toolchain: Some(toolchain), + ..self + } + } + + pub fn with_features(self, features: Features) -> Self { + Self { features, ..self } + } + + pub fn with_profile(self, profile: Option) -> Self { + Self { profile, ..self } + } +} diff --git a/xtask/src/codegen.rs b/xtask/src/codegen.rs new file mode 100644 index 0000000000..46f5fc5a03 --- /dev/null +++ b/xtask/src/codegen.rs @@ -0,0 +1,147 @@ +use anyhow::Result; +use cargo_metadata::semver::Version; +use std::path::PathBuf; + +use log::info; + +use crate::{ + args::GlobalArgs, codegen_crate_dir, main_workspace_cargo_metadata, read_rust_toolchain, + relative_workspace_dir, run_system_command, workspace_dir, +}; + +pub struct CodegenSettings { + pub bevy_repo_app_settings: GlobalArgs, + pub main_workspace_app_settings: GlobalArgs, + pub bevy_version: Version, + pub bevy_dir: PathBuf, + pub output_dir: PathBuf, + pub bevy_features: Vec, + pub template_args: String, + pub bms_bindings_path: PathBuf, +} + +pub fn prepare_codegen( + app_settings: GlobalArgs, + output_dir: Option, + bevy_features: Vec, +) -> Result { + let main_workspace_app_settings = app_settings; + let bevy_dir = relative_workspace_dir(&main_workspace_app_settings, "target/codegen/bevy")?; + let bevy_target_dir = bevy_dir.join("target"); + // clear the bevy target dir if it exists + info!("Clearing bevy target dir: {bevy_target_dir:?}"); + if bevy_target_dir.exists() { + std::fs::remove_dir_all(&bevy_target_dir)?; + } + + info!("Cleaning output dir: {output_dir:?}"); + let output_dir = if let Some(output_dir) = output_dir { + // safety measure + let output_dir = relative_workspace_dir(&main_workspace_app_settings, output_dir)?; + if output_dir.exists() && output_dir.to_string_lossy().contains("target") { + std::fs::remove_dir_all(&output_dir)?; + } + std::fs::create_dir_all(&output_dir)?; + output_dir + } else { + Default::default() + }; + + let api_gen_dir = codegen_crate_dir(&main_workspace_app_settings)?; + let codegen_toolchain = read_rust_toolchain(&api_gen_dir); + let codegen_app_settings = main_workspace_app_settings + .clone() + .with_workspace_dir(api_gen_dir.clone()); + // .with_toolchain(codegen_toolchain.clone()); // don't think it's needed, the rust toolchain file sorts that out + + let bevy_repo_app_settings = main_workspace_app_settings + .clone() + .with_workspace_dir(bevy_dir.clone()) + .with_toolchain(codegen_toolchain.clone()); + + // run cargo install + log::info!("Running bevy_api_gen against toolchain: {codegen_toolchain}"); + run_system_command( + &codegen_app_settings, + "cargo", + "Failed to install bevy_api_gen", + vec!["install", "--path", "."], + None, + false, + )?; + + let metadata = main_workspace_cargo_metadata()?; + + let bevy_version = metadata + .packages + .iter() + .filter_map(|p| (p.name.as_str() == "bevy").then_some(&p.version)) + .max() + .expect("could not find bevy package in metadata"); + log::info!("Using bevy version {bevy_version}"); + + // create directories if they don't already exist + std::fs::create_dir_all(&bevy_dir)?; + + // git clone bevy repo + let _ = run_system_command( + &bevy_repo_app_settings, + "git", + "Failed to clone bevy repo", + vec![ + "clone", + "https://github.com/bevyengine/bevy", + "--branch", + format!("v{}", &bevy_version).as_str(), + "--depth", + "1", + ".", + ], + None, + false, + ); + + // fetch the tags + run_system_command( + &bevy_repo_app_settings, + "git", + "Failed to fetch bevy tags", + vec!["fetch", "--tags"], + Some(&bevy_dir), + false, + )?; + + // checkout the version tag + run_system_command( + &bevy_repo_app_settings, + "git", + "Failed to checkout bevy tag", + vec!["checkout", format!("v{}", &bevy_version).as_str()], + Some(&bevy_dir), + false, + )?; + + // run bevy_api_gen + + // nothing in template args for now. + let template_args = CodegenTemplateArgs {}; + + let template_args = serde_json::to_string(&template_args)?; + let bms_bindings_path = workspace_dir(&main_workspace_app_settings)? + .join("crates/bevy_mod_scripting_bindings") + .to_path_buf(); + + Ok(CodegenSettings { + bevy_repo_app_settings: bevy_repo_app_settings, + main_workspace_app_settings: main_workspace_app_settings, + bevy_version: bevy_version.clone(), + bevy_dir: bevy_dir, + output_dir: output_dir, + bevy_features, + template_args, + bms_bindings_path, + }) +} + +#[derive(Debug, Clone, serde::Serialize)] +pub struct CodegenTemplateArgs {} diff --git a/xtask/src/command.rs b/xtask/src/command.rs new file mode 100644 index 0000000000..6f2259a9ea --- /dev/null +++ b/xtask/src/command.rs @@ -0,0 +1,198 @@ +use anyhow::{Context, Result, bail}; +use log::info; +use std::{ + ffi::OsStr, + path::{Path, PathBuf}, + process::{Command, Output}, +}; + +use crate::GlobalArgs; + +pub fn run_system_command>>( + app_settings: &GlobalArgs, + command: &str, + context: &str, + add_args: I, + dir: Option<&Path>, + capture_streams_in_output: bool, +) -> Result { + info!("Running system command: {command}"); + + let working_dir = match dir { + Some(d) => relative_workspace_dir(app_settings, d)?, + None => workspace_dir(app_settings)?, + }; + + let mut cmd = Command::new(command); + cmd.args(add_args).current_dir(working_dir); + + if !capture_streams_in_output { + cmd.stdout(std::process::Stdio::inherit()) + .stderr(std::process::Stdio::inherit()); + } + + info!("Using command: {cmd:?}"); + + let output = cmd.output(); + if capture_streams_in_output { + info!("Command status: {:?}", output.as_ref().map(|o| o.status)); + } else { + info!("Command output: {output:?}"); + } + + let output = output.with_context(|| context.to_owned())?; + match output.status.code() { + Some(0) => Ok(output), + _ => bail!( + "{} failed with exit code: {}", + context, + output.status.code().unwrap_or(-1) + ), + } +} + +pub fn run_workspace_command>>( + app_settings: &GlobalArgs, + command: &str, + context: &str, + add_args: I, + dir: Option<&Path>, + capture_streams_in_output: bool, +) -> Result { + let coverage_mode = if app_settings.coverage { + "with coverage" + } else { + Default::default() + }; + + info!("Running workspace command {coverage_mode}: {command}"); + + let mut args = vec![]; + + if let Some(ref toolchain) = app_settings.override_toolchain { + args.push(format!("+{toolchain}")); + } + + args.push(command.to_owned()); + + if command != "fmt" && command != "bms-codegen" && command != "install" { + // fmt doesn't care about features, workspaces or profiles + if command != "run" { + args.push("--workspace".to_owned()); + + if let Some(profile) = app_settings.profile.as_ref() { + let use_profile = if profile == "ephemeral-build" && app_settings.coverage { + // use special profile for coverage as it needs debug information + // but also don't want it too slow + "ephemeral-coverage" + } else { + profile + }; + + if !app_settings.coverage { + args.push("--profile".to_owned()); + args.push(use_profile.to_owned()); + } + + if let Some(jobs) = app_settings.jobs { + args.push("--jobs".to_owned()); + args.push(jobs.to_string()); + } + } + } + + args.extend(app_settings.features.to_cargo_args()); + } + + args.extend(add_args.into_iter().map(|s| { + s.as_ref() + .to_str() + .expect("invalid command argument") + .to_owned() + })); + + let working_dir = match dir { + Some(d) => relative_workspace_dir(app_settings, d)?, + None => workspace_dir(app_settings)?, + }; + + let mut cmd = Command::new("cargo"); + cmd.args(args).current_dir(working_dir); + + if !capture_streams_in_output { + cmd.stdout(std::process::Stdio::inherit()) + .stderr(std::process::Stdio::inherit()); + } + + info!("Using command: {cmd:?}"); + + let output = cmd.output().with_context(|| context.to_owned())?; + match output.status.code() { + Some(0) => Ok(output), + _ => bail!( + "{} failed with exit code: {}. Features: {}. output {output:?}", + context, + output.status.code().unwrap_or(-1), + app_settings.features + ), + } +} + +/// Reads the metadata from the main workspace +pub fn main_workspace_cargo_metadata() -> Result { + let cargo_manifest_path = std::env::var("MAIN_CARGO_MANIFEST_PATH").unwrap(); + let path = PathBuf::from(cargo_manifest_path); + let parent_dir = path.parent().unwrap().parent().unwrap().join("Cargo.toml"); + let mut cmd = cargo_metadata::MetadataCommand::new(); + cmd.manifest_path(parent_dir.to_string_lossy().to_string()); + let out = cmd.exec()?; + Ok(out) +} + +pub fn workspace_dir(app_settings: &GlobalArgs) -> Result { + if let Some(dir) = &app_settings.override_workspace_dir { + return Ok(dir.into()); + } + + let metadata = main_workspace_cargo_metadata()?; + let workspace_root = metadata.workspace_root; + Ok(workspace_root.into()) +} + +pub fn codegen_crate_dir(app_settings: &GlobalArgs) -> Result { + let workspace_dir = workspace_dir(app_settings)?; + Ok(workspace_dir.join("codegen")) +} + +pub fn relative_workspace_dir>( + app_settings: &GlobalArgs, + dir: P, +) -> Result { + let workspace_dir = workspace_dir(app_settings)?; + Ok(workspace_dir.join(dir)) +} + +/// reads rust-toolchain.toml file at the given directory and returns the toolchain string +pub fn read_rust_toolchain(path: &Path) -> String { + let rust_toolchain_path = path.join("rust-toolchain.toml"); + + let rust_toolchain = + std::fs::read_to_string(rust_toolchain_path).expect("Could not read rust_toolchain.toml"); + + // parse the toml file + let toml: toml::Value = + toml::from_str(&rust_toolchain).expect("Could not parse rust_toolchain.toml"); + + let toolchain = toml + .get("toolchain") + .expect("Could not find toolchain in rust_toolchain.toml"); + let channel = toolchain + .get("channel") + .expect("Could not find channel in rust_toolchain.toml"); + let channel = channel + .as_str() + .expect("Channel in rust_toolchain.toml is not a string"); + + // set the toolchain + channel.to_string() +} diff --git a/xtask/src/features.rs b/xtask/src/features.rs new file mode 100644 index 0000000000..28ff1487e2 --- /dev/null +++ b/xtask/src/features.rs @@ -0,0 +1,293 @@ +use std::{ + collections::{HashMap, HashSet}, + str::FromStr, +}; + +use itertools::Itertools; +use strum::VariantNames; + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + strum::EnumString, + strum::EnumIter, + strum::Display, + strum::VariantNames, + strum::VariantArray, +)] +#[strum(serialize_all = "snake_case")] +pub enum Feature { + // bindings + CoreFunctions, + BevyEcsBindings, + BevyInputBindings, + BevyMathBindings, + BevyReflectBindings, + BevyTimeBindings, + BevyTransformBindings, + BevyColorBindings, + BevyCorePipelineBindings, + BevyA11yBindings, + BevyAnimationBindings, + BevyAssetBindings, + BevyGizmosBindings, + BevyGltfBindings, + BevyImageBindings, + BevyInputFocusBindings, + BevyMeshBindings, + BevyPbrBindings, + BevyPickingBindings, + BevyRenderBindings, + BevySceneBindings, + BevySpriteBindings, + BevyTextBindings, + + // Ladfile + LuaLanguageServerFiles, + + // Lua + Lua51, + Lua52, + Lua53, + Lua54, + Luajit, + Luajit52, + Luau, + UnsafeLuaModules, + MluaSerialize, + MluaMacros, + MluaAsync, + // Rhai, + Rhai, + // Rune + // Rune, + + // Profiling + ProfileWithTracy, +} + +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, strum::EnumIter)] +pub enum FeatureGroup { + LuaExclusive, + RhaiExclusive, + // RuneExclusive, + ForExternalCrate, + BMSFeature, + BMSFeatureNotInPowerset, +} + +impl FeatureGroup { + pub fn default_feature(self) -> Feature { + match self { + FeatureGroup::LuaExclusive => Feature::Lua54, + FeatureGroup::RhaiExclusive => Feature::Rhai, + // FeatureGroup::RuneExclusive => Feature::Rune, + _ => panic!("No default feature for non-exclusive group"), + } + } + + pub fn is_exclusive(self) -> bool { + matches!( + self, + FeatureGroup::LuaExclusive | FeatureGroup::RhaiExclusive // | FeatureGroup::RuneExclusive + ) + } +} + +trait IntoFeatureGroup { + fn to_feature_group(self) -> FeatureGroup; +} + +impl IntoFeatureGroup for Feature { + fn to_feature_group(self) -> FeatureGroup { + match self { + Feature::Lua51 + | Feature::Lua52 + | Feature::Lua53 + | Feature::Lua54 + | Feature::Luajit + | Feature::Luajit52 + | Feature::Luau => FeatureGroup::LuaExclusive, + Feature::Rhai => FeatureGroup::RhaiExclusive, + // Feature::Rune => FeatureGroup::RuneExclusive, + Feature::MluaAsync + | Feature::MluaMacros + | Feature::MluaSerialize + | Feature::UnsafeLuaModules => FeatureGroup::ForExternalCrate, + Feature::BevyEcsBindings + | Feature::BevyInputBindings + | Feature::BevyMathBindings + | Feature::BevyReflectBindings + | Feature::BevyTimeBindings + | Feature::BevyTransformBindings + | Feature::BevyColorBindings + | Feature::BevyCorePipelineBindings + | Feature::BevyA11yBindings + | Feature::BevyAnimationBindings + | Feature::BevyAssetBindings + | Feature::BevyGizmosBindings + | Feature::BevyGltfBindings + | Feature::BevyImageBindings + | Feature::BevyInputFocusBindings + | Feature::BevyMeshBindings + | Feature::BevyPbrBindings + | Feature::BevyPickingBindings + | Feature::BevyRenderBindings + | Feature::BevySceneBindings + | Feature::BevySpriteBindings + | Feature::BevyTextBindings => FeatureGroup::BMSFeatureNotInPowerset, + Feature::CoreFunctions + | Feature::ProfileWithTracy + | Feature::LuaLanguageServerFiles => FeatureGroup::BMSFeature, // don't use wildcard here, we want to be explicit + } + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Features(pub HashSet); + +impl Default for Features { + fn default() -> Self { + // should be kept up to date with the default feature + lua54 on top of anything that is handy to run locally every time + Features::new(vec![ + Feature::Lua54, + Feature::Rhai, + Feature::CoreFunctions, + Feature::BevyEcsBindings, + Feature::BevyInputBindings, + Feature::BevyMathBindings, + Feature::BevyReflectBindings, + Feature::BevyTimeBindings, + Feature::BevyTransformBindings, + Feature::BevyColorBindings, + Feature::BevyCorePipelineBindings, + Feature::LuaLanguageServerFiles, + ]) + } +} + +impl Features { + pub fn new>(features: I) -> Self { + Self(features.into_iter().collect()) + } + + /// Returns all features except the exclusive ones which are not the default + pub fn all_features() -> Self { + // remove exclusive features which are not the default + Self( + ::VARIANTS + .iter() + .filter(|f| { + let group = f.to_feature_group(); + (!group.is_exclusive()) || (**f == group.default_feature()) + }) + .cloned() + .collect(), + ) + } + + pub fn display_no_default(self) -> String { + let default_features = Self::default().0; + + let excluded_default_features = default_features + .difference(&self.0) + .map(|f| format!("-{f}")) + .collect::>(); + + let excluded_non_powerset_features = self + .0 + .iter() + .filter(|f| matches!(f.to_feature_group(), FeatureGroup::BMSFeatureNotInPowerset)) + .map(|f| f.to_string()) + .collect::>(); + + let mut features = self + .0 + .into_iter() + .filter(|f| { + !default_features.contains(f) + && !excluded_non_powerset_features.contains(&f.to_string()) + }) + .map(|f| f.to_string()) + .collect::>(); + + features.sort(); + excluded_default_features + .into_iter() + .chain(features) + .chain(std::iter::once(format!( + "+{} bindings", + excluded_non_powerset_features.len() + ))) + .collect::>() + .join(",") + } + + pub fn without(self, feature: Feature) -> Self { + Self(self.0.into_iter().filter(|f| *f != feature).collect()) + } + + pub fn to_cargo_args(&self) -> Vec { + if self.0.is_empty() { + vec![] + } else { + vec![ + "--no-default-features".to_owned(), + "--features".to_owned(), + self.to_string(), + ] + } + } + + pub fn to_placeholder() -> clap::builder::Str { + format!("[{}]", Feature::VARIANTS.join("|")).into() + } + + pub fn split_by_group(&self) -> HashMap> { + let mut groups = HashMap::new(); + for feature in &self.0 { + let group = feature.to_feature_group(); + groups.entry(group).or_insert_with(Vec::new).push(*feature); + } + groups + } +} + +impl std::fmt::Display for Features { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + // exclude default features + for (i, feature) in self.0.iter().sorted().enumerate() { + if i > 0 { + write!(f, ",")?; + } + write!(f, "{feature}")?; + } + std::result::Result::Ok(()) + } +} + +impl From for Features { + fn from(s: String) -> Self { + if s.is_empty() { + return Self::new(vec![]); + } + + let features = s + .trim() + .split(',') + .map(|f| { + Feature::from_str(f).unwrap_or_else(|_| { + eprintln!("Unknown feature: '{f}'"); + std::process::exit(1); + }) + }) + .collect(); + Self(features) + } +} diff --git a/xtask/src/lib.rs b/xtask/src/lib.rs index 06faa395f9..c14779312b 100644 --- a/xtask/src/lib.rs +++ b/xtask/src/lib.rs @@ -1,5 +1,13 @@ -mod binding_crate; -mod codegen_meta; +pub(crate) mod args; +pub(crate) mod binding_crate; +pub(crate) mod codegen; +pub(crate) mod codegen_meta; +pub(crate) mod command; +pub(crate) mod features; +pub use args::*; pub use binding_crate::*; +pub use codegen::*; pub use codegen_meta::*; +pub use command::*; +pub use features::*; diff --git a/xtask/src/main.rs b/xtask/src/main.rs index fbdf825587..491d187b97 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -1,6 +1,6 @@ use std::{ - collections::{HashMap, HashSet}, - ffi::{OsStr, OsString}, + collections::HashMap, + ffi::OsString, io::Write, path::{Path, PathBuf}, process::{Command, Output}, @@ -14,293 +14,11 @@ use json_comments::StripComments; use log::*; use serde::{Deserialize, Serialize}; use strum::{IntoEnumIterator, VariantNames}; -use xtask::{BindingCrate, Meta}; - -#[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - strum::EnumString, - strum::EnumIter, - strum::Display, - strum::VariantNames, - strum::VariantArray, -)] -#[strum(serialize_all = "snake_case")] -enum Feature { - // bindings - CoreFunctions, - BevyEcsBindings, - BevyInputBindings, - BevyMathBindings, - BevyReflectBindings, - BevyTimeBindings, - BevyTransformBindings, - BevyColorBindings, - BevyCorePipelineBindings, - BevyA11yBindings, - BevyAnimationBindings, - BevyAssetBindings, - BevyGizmosBindings, - BevyGltfBindings, - BevyImageBindings, - BevyInputFocusBindings, - BevyMeshBindings, - BevyPbrBindings, - BevyPickingBindings, - BevyRenderBindings, - BevySceneBindings, - BevySpriteBindings, - BevyTextBindings, - - // Ladfile - LuaLanguageServerFiles, - - // Lua - Lua51, - Lua52, - Lua53, - Lua54, - Luajit, - Luajit52, - Luau, - UnsafeLuaModules, - MluaSerialize, - MluaMacros, - MluaAsync, - // Rhai, - Rhai, - // Rune - // Rune, - - // Profiling - ProfileWithTracy, -} - -#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, strum::EnumIter)] -enum FeatureGroup { - LuaExclusive, - RhaiExclusive, - // RuneExclusive, - ForExternalCrate, - BMSFeature, - BMSFeatureNotInPowerset, -} - -impl FeatureGroup { - fn default_feature(self) -> Feature { - match self { - FeatureGroup::LuaExclusive => Feature::Lua54, - FeatureGroup::RhaiExclusive => Feature::Rhai, - // FeatureGroup::RuneExclusive => Feature::Rune, - _ => panic!("No default feature for non-exclusive group"), - } - } - - fn is_exclusive(self) -> bool { - matches!( - self, - FeatureGroup::LuaExclusive | FeatureGroup::RhaiExclusive // | FeatureGroup::RuneExclusive - ) - } -} - -trait IntoFeatureGroup { - fn to_feature_group(self) -> FeatureGroup; -} - -impl IntoFeatureGroup for Feature { - fn to_feature_group(self) -> FeatureGroup { - match self { - Feature::Lua51 - | Feature::Lua52 - | Feature::Lua53 - | Feature::Lua54 - | Feature::Luajit - | Feature::Luajit52 - | Feature::Luau => FeatureGroup::LuaExclusive, - Feature::Rhai => FeatureGroup::RhaiExclusive, - // Feature::Rune => FeatureGroup::RuneExclusive, - Feature::MluaAsync - | Feature::MluaMacros - | Feature::MluaSerialize - | Feature::UnsafeLuaModules => FeatureGroup::ForExternalCrate, - Feature::BevyEcsBindings - | Feature::BevyInputBindings - | Feature::BevyMathBindings - | Feature::BevyReflectBindings - | Feature::BevyTimeBindings - | Feature::BevyTransformBindings - | Feature::BevyColorBindings - | Feature::BevyCorePipelineBindings - | Feature::BevyA11yBindings - | Feature::BevyAnimationBindings - | Feature::BevyAssetBindings - | Feature::BevyGizmosBindings - | Feature::BevyGltfBindings - | Feature::BevyImageBindings - | Feature::BevyInputFocusBindings - | Feature::BevyMeshBindings - | Feature::BevyPbrBindings - | Feature::BevyPickingBindings - | Feature::BevyRenderBindings - | Feature::BevySceneBindings - | Feature::BevySpriteBindings - | Feature::BevyTextBindings => FeatureGroup::BMSFeatureNotInPowerset, - Feature::CoreFunctions - | Feature::ProfileWithTracy - | Feature::LuaLanguageServerFiles => FeatureGroup::BMSFeature, // don't use wildcard here, we want to be explicit - } - } -} - -#[derive(Debug, Clone, PartialEq, Eq)] -struct Features(HashSet); - -impl Default for Features { - fn default() -> Self { - // should be kept up to date with the default feature + lua54 on top of anything that is handy to run locally every time - Features::new(vec![ - Feature::Lua54, - Feature::Rhai, - Feature::CoreFunctions, - Feature::BevyEcsBindings, - Feature::BevyInputBindings, - Feature::BevyMathBindings, - Feature::BevyReflectBindings, - Feature::BevyTimeBindings, - Feature::BevyTransformBindings, - Feature::BevyColorBindings, - Feature::BevyCorePipelineBindings, - Feature::LuaLanguageServerFiles, - ]) - } -} - -impl Features { - fn new>(features: I) -> Self { - Self(features.into_iter().collect()) - } - - /// Returns all features except the exclusive ones which are not the default - fn all_features() -> Self { - // remove exclusive features which are not the default - Self( - ::VARIANTS - .iter() - .filter(|f| { - let group = f.to_feature_group(); - (!group.is_exclusive()) || (**f == group.default_feature()) - }) - .cloned() - .collect(), - ) - } - - fn display_no_default(self) -> String { - let default_features = Self::default().0; - - let excluded_default_features = default_features - .difference(&self.0) - .map(|f| format!("-{f}")) - .collect::>(); - - let excluded_non_powerset_features = self - .0 - .iter() - .filter(|f| matches!(f.to_feature_group(), FeatureGroup::BMSFeatureNotInPowerset)) - .map(|f| f.to_string()) - .collect::>(); - - let mut features = self - .0 - .into_iter() - .filter(|f| { - !default_features.contains(f) - && !excluded_non_powerset_features.contains(&f.to_string()) - }) - .map(|f| f.to_string()) - .collect::>(); - - features.sort(); - excluded_default_features - .into_iter() - .chain(features) - .chain(std::iter::once(format!( - "+{} bindings", - excluded_non_powerset_features.len() - ))) - .collect::>() - .join(",") - } - - fn without(self, feature: Feature) -> Self { - Self(self.0.into_iter().filter(|f| *f != feature).collect()) - } - - fn to_cargo_args(&self) -> Vec { - if self.0.is_empty() { - vec![] - } else { - vec![ - "--no-default-features".to_owned(), - "--features".to_owned(), - self.to_string(), - ] - } - } - - fn to_placeholder() -> clap::builder::Str { - format!("[{}]", Feature::VARIANTS.join("|")).into() - } - - fn split_by_group(&self) -> HashMap> { - let mut groups = HashMap::new(); - for feature in &self.0 { - let group = feature.to_feature_group(); - groups.entry(group).or_insert_with(Vec::new).push(*feature); - } - groups - } -} - -impl std::fmt::Display for Features { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - // exclude default features - for (i, feature) in self.0.iter().sorted().enumerate() { - if i > 0 { - write!(f, ",")?; - } - write!(f, "{feature}")?; - } - std::result::Result::Ok(()) - } -} - -impl From for Features { - fn from(s: String) -> Self { - if s.is_empty() { - return Self::new(vec![]); - } - - let features = s - .trim() - .split(',') - .map(|f| { - Feature::from_str(f).unwrap_or_else(|_| { - eprintln!("Unknown feature: '{f}'"); - std::process::exit(1); - }) - }) - .collect(); - Self(features) - } -} +use xtask::{ + BindingCrate, Feature, FeatureGroup, Features, GlobalArgs, Meta, codegen_crate_dir, + main_workspace_cargo_metadata, prepare_codegen, read_rust_toolchain, relative_workspace_dir, + run_system_command, run_workspace_command, workspace_dir, +}; /// Enumerates the binaries available in the project and their paths #[derive( @@ -439,12 +157,18 @@ impl App { Xtasks::Codegen { output_dir, bevy_features, + list_only, } => { - cmd.arg("codegen") + let cmd = cmd + .arg("codegen") .arg("--output-dir") .arg(output_dir) .arg("--bevy-features") .arg(bevy_features.join(",")); + + if list_only { + cmd.arg("--list-only"); + } } Xtasks::Example { example } => { cmd.arg("example").arg(example); @@ -517,88 +241,6 @@ impl App { } } -#[derive(Debug, Parser, Clone)] -struct GlobalArgs { - #[clap(long, short, global = true, value_parser=clap::value_parser!(Features), value_name=Features::to_placeholder(), default_value=Features::default().to_string(),required = false)] - features: Features, - - #[clap( - long, - global = true, - default_value = "false", - help = "Enable coverage collection for cargo commands" - )] - coverage: bool, - - #[clap(skip)] - override_workspace_dir: Option, - - #[clap(skip)] - override_toolchain: Option, - - #[clap( - long, - short, - global = true, - value_name = "PROFILE", - help = "The cargo profile to use for commands that support it" - )] - profile: Option, - - #[clap( - long, - global = true, - value_name = "JOBS", - help = "The number of parallel jobs to run at most" - )] - jobs: Option, -} - -impl GlobalArgs { - pub fn with_max_jobs(self, jobs: usize) -> Self { - Self { - jobs: Some(jobs), - ..self - } - } - - pub fn with_coverage(self) -> Self { - Self { - coverage: true, - ..self - } - } - - pub fn without_coverage(self) -> Self { - Self { - coverage: false, - ..self - } - } - - pub fn with_workspace_dir(self, dir: PathBuf) -> Self { - Self { - override_workspace_dir: Some(dir), - ..self - } - } - - pub fn with_toolchain(self, toolchain: String) -> Self { - Self { - override_toolchain: Some(toolchain), - ..self - } - } - - pub fn with_features(self, features: Features) -> Self { - Self { features, ..self } - } - - pub fn with_profile(self, profile: Option) -> Self { - Self { profile, ..self } - } -} - #[derive( Debug, Clone, @@ -647,10 +289,6 @@ impl Macro { format!("[{}]", Macro::VARIANTS.join("|")).into() } } -#[derive(Debug, Clone, serde::Serialize)] -struct CodegenTemplateArgs { - self_is_bms_lua: bool, -} fn fetch_default_bevy_features() -> String { let try_dirs = vec![".", "../"]; @@ -754,6 +392,10 @@ enum Xtasks { help = "The features to enable for the bevy crate" )] bevy_features: Vec, + + /// If set will not generate but instead print out type and debug information from the bevy crate + #[clap(long)] + list_only: bool, }, /// Build the main workspace, and then run all tests Test { @@ -869,7 +511,14 @@ impl Xtasks { Xtasks::Codegen { output_dir, bevy_features, - } => Self::codegen(app_settings, output_dir, bevy_features), + list_only, + } => { + if list_only { + Self::codegen_list(app_settings, output_dir, bevy_features) + } else { + Self::codegen(app_settings, output_dir, bevy_features) + } + } Xtasks::Install { binary } => Self::install(app_settings, binary), Xtasks::Bencher { publish } => Self::bencher(app_settings, publish), Xtasks::Bench { @@ -884,40 +533,6 @@ impl Xtasks { Ok("".into()) } - /// Reads the metadata from the main workspace - fn main_workspace_cargo_metadata() -> Result { - let cargo_manifest_path = std::env::var("MAIN_CARGO_MANIFEST_PATH").unwrap(); - let path = PathBuf::from(cargo_manifest_path); - let parent_dir = path.parent().unwrap().parent().unwrap().join("Cargo.toml"); - let mut cmd = cargo_metadata::MetadataCommand::new(); - cmd.manifest_path(parent_dir.to_string_lossy().to_string()); - let out = cmd.exec()?; - Ok(out) - } - - fn workspace_dir(app_settings: &GlobalArgs) -> Result { - if let Some(dir) = &app_settings.override_workspace_dir { - return Ok(dir.into()); - } - - let metadata = Self::main_workspace_cargo_metadata()?; - let workspace_root = metadata.workspace_root; - Ok(workspace_root.into()) - } - - fn codegen_crate_dir(app_settings: &GlobalArgs) -> Result { - let workspace_dir = Self::workspace_dir(app_settings)?; - Ok(workspace_dir.join("codegen")) - } - - fn relative_workspace_dir>( - app_settings: &GlobalArgs, - dir: P, - ) -> Result { - let workspace_dir = Self::workspace_dir(app_settings)?; - Ok(workspace_dir.join(dir)) - } - fn append_rustflags(flag: &str) { let rustflags = std::env::var("RUSTFLAGS").unwrap_or_default(); let mut flags = rustflags.split(' ').collect::>(); @@ -926,136 +541,6 @@ impl Xtasks { unsafe { std::env::set_var("RUSTFLAGS", flags) }; } - fn run_system_command>>( - app_settings: &GlobalArgs, - command: &str, - context: &str, - add_args: I, - dir: Option<&Path>, - capture_streams_in_output: bool, - ) -> Result { - info!("Running system command: {command}"); - - let working_dir = match dir { - Some(d) => Self::relative_workspace_dir(app_settings, d)?, - None => Self::workspace_dir(app_settings)?, - }; - - let mut cmd = Command::new(command); - cmd.args(add_args).current_dir(working_dir); - - if !capture_streams_in_output { - cmd.stdout(std::process::Stdio::inherit()) - .stderr(std::process::Stdio::inherit()); - } - - info!("Using command: {cmd:?}"); - - let output = cmd.output(); - if capture_streams_in_output { - info!("Command status: {:?}", output.as_ref().map(|o| o.status)); - } else { - info!("Command output: {output:?}"); - } - - let output = output.with_context(|| context.to_owned())?; - match output.status.code() { - Some(0) => Ok(output), - _ => bail!( - "{} failed with exit code: {}", - context, - output.status.code().unwrap_or(-1) - ), - } - } - - fn run_workspace_command>>( - app_settings: &GlobalArgs, - command: &str, - context: &str, - add_args: I, - dir: Option<&Path>, - capture_streams_in_output: bool, - ) -> Result { - let coverage_mode = if app_settings.coverage { - "with coverage" - } else { - Default::default() - }; - - info!("Running workspace command {coverage_mode}: {command}"); - - let mut args = vec![]; - - if let Some(ref toolchain) = app_settings.override_toolchain { - args.push(format!("+{toolchain}")); - } - - args.push(command.to_owned()); - - if command != "fmt" && command != "bms-codegen" && command != "install" { - // fmt doesn't care about features, workspaces or profiles - if command != "run" { - args.push("--workspace".to_owned()); - - if let Some(profile) = app_settings.profile.as_ref() { - let use_profile = if profile == "ephemeral-build" && app_settings.coverage { - // use special profile for coverage as it needs debug information - // but also don't want it too slow - "ephemeral-coverage" - } else { - profile - }; - - if !app_settings.coverage { - args.push("--profile".to_owned()); - args.push(use_profile.to_owned()); - } - - if let Some(jobs) = app_settings.jobs { - args.push("--jobs".to_owned()); - args.push(jobs.to_string()); - } - } - } - - args.extend(app_settings.features.to_cargo_args()); - } - - args.extend(add_args.into_iter().map(|s| { - s.as_ref() - .to_str() - .expect("invalid command argument") - .to_owned() - })); - - let working_dir = match dir { - Some(d) => Self::relative_workspace_dir(app_settings, d)?, - None => Self::workspace_dir(app_settings)?, - }; - - let mut cmd = Command::new("cargo"); - cmd.args(args).current_dir(working_dir); - - if !capture_streams_in_output { - cmd.stdout(std::process::Stdio::inherit()) - .stderr(std::process::Stdio::inherit()); - } - - info!("Using command: {cmd:?}"); - - let output = cmd.output().with_context(|| context.to_owned())?; - match output.status.code() { - Some(0) => Ok(output), - _ => bail!( - "{} failed with exit code: {}. Features: {}. output {output:?}", - context, - output.status.code().unwrap_or(-1), - app_settings.features - ), - } - } - fn build(timings: bool, app_settings: GlobalArgs) -> Result<()> { // build workspace using the given features let mut args = vec!["--all-targets", "--examples"]; @@ -1063,7 +548,7 @@ impl Xtasks { args.push("--timings"); } - Self::run_workspace_command( + run_workspace_command( &app_settings, "build", "Failed to build workspace", @@ -1088,7 +573,7 @@ impl Xtasks { clippy_args.extend(vec!["--", "-D", "warnings"]); } - Self::run_workspace_command( + run_workspace_command( &app_settings, "clippy", "Failed to run clippy", @@ -1102,7 +587,7 @@ impl Xtasks { } // run cargo fmt checks - Self::run_workspace_command( + run_workspace_command( &app_settings, "fmt", "Failed to run cargo fmt", @@ -1115,12 +600,12 @@ impl Xtasks { } fn check_codegen_workspace(app_settings: GlobalArgs, ide_mode: bool) -> Result<()> { - let toolchain = Self::read_rust_toolchain(&Self::codegen_crate_dir(&app_settings)?); + let toolchain = read_rust_toolchain(&codegen_crate_dir(&app_settings)?); // set the working directory to the codegen crate let app_settings = app_settings .clone() - .with_workspace_dir(Self::codegen_crate_dir(&app_settings)?) + .with_workspace_dir(codegen_crate_dir(&app_settings)?) .with_toolchain(toolchain) .with_features(Features::new(vec![])); // TODO: support features for codegen crate if any @@ -1134,7 +619,7 @@ impl Xtasks { clippy_args.extend(vec!["--all-targets", "--", "-D", "warnings"]); } - Self::run_workspace_command( + run_workspace_command( &app_settings, "clippy", "Failed to run clippy on codegen crate", @@ -1148,181 +633,85 @@ impl Xtasks { Ok(()) } - /// reads rust-toolchain.toml file at the given directory and returns the toolchain string - fn read_rust_toolchain(path: &Path) -> String { - let rust_toolchain_path = path.join("rust-toolchain.toml"); - - let rust_toolchain = std::fs::read_to_string(rust_toolchain_path) - .expect("Could not read rust_toolchain.toml"); - - // parse the toml file - let toml: toml::Value = - toml::from_str(&rust_toolchain).expect("Could not parse rust_toolchain.toml"); - - let toolchain = toml - .get("toolchain") - .expect("Could not find toolchain in rust_toolchain.toml"); - let channel = toolchain - .get("channel") - .expect("Could not find channel in rust_toolchain.toml"); - let channel = channel - .as_str() - .expect("Channel in rust_toolchain.toml is not a string"); - - // set the toolchain - channel.to_string() - } - - fn codegen( + fn codegen_list( app_settings: GlobalArgs, output_dir: PathBuf, bevy_features: Vec, ) -> Result<()> { - let main_workspace_app_settings = app_settings; - let output_dir = Self::relative_workspace_dir(&main_workspace_app_settings, output_dir)?; - let bevy_dir = - Self::relative_workspace_dir(&main_workspace_app_settings, "target/codegen/bevy")?; - let bevy_target_dir = bevy_dir.join("target"); - // clear the bevy target dir if it exists - info!("Clearing bevy target dir: {bevy_target_dir:?}"); - if bevy_target_dir.exists() { - std::fs::remove_dir_all(&bevy_target_dir)?; - } - - info!("Cleaning output dir: {output_dir:?}"); - // safety measure - if output_dir.exists() && output_dir.to_string_lossy().contains("target") { - std::fs::remove_dir_all(&output_dir)?; - } - - let api_gen_dir = Self::codegen_crate_dir(&main_workspace_app_settings)?; - let codegen_toolchain = Self::read_rust_toolchain(&api_gen_dir); - let codegen_app_settings = main_workspace_app_settings - .clone() - .with_workspace_dir(api_gen_dir.clone()); - // .with_toolchain(codegen_toolchain.clone()); // don't think it's needed, the rust toolchain file sorts that out - - let bevy_repo_app_settings = main_workspace_app_settings - .clone() - .with_workspace_dir(bevy_dir.clone()) - .with_toolchain(codegen_toolchain.clone()); - - // run cargo install - log::info!("Running bevy_api_gen against toolchain: {codegen_toolchain}"); - Self::run_system_command( - &codegen_app_settings, - "cargo", - "Failed to install bevy_api_gen", - vec!["install", "--path", "."], - None, - false, - )?; - - let metadata = Self::main_workspace_cargo_metadata()?; - - let bevy_version = metadata - .packages - .iter() - .filter_map(|p| (p.name.as_str() == "bevy").then_some(&p.version)) - .max() - .expect("could not find bevy package in metadata"); - - log::info!("Using bevy version {bevy_version}"); - // create directories if they don't already exist - std::fs::create_dir_all(&bevy_dir)?; - std::fs::create_dir_all(&output_dir)?; - - // git clone bevy repo - let _ = Self::run_system_command( - &bevy_repo_app_settings, - "git", - "Failed to clone bevy repo", + let settings = prepare_codegen(app_settings, Some(output_dir), bevy_features)?; + run_workspace_command( + &settings.bevy_repo_app_settings, + "bms-codegen", + "Failed to run bms-codegen generate", vec![ - "clone", - "https://github.com/bevyengine/bevy", - "--branch", - format!("v{bevy_version}").as_str(), - "--depth", - "1", - ".", + "list-types", + "--bms-bindings-path", + settings.bms_bindings_path.to_str().unwrap(), + "--output", + settings.output_dir.to_str().unwrap(), + "--template-args", + settings.template_args.as_str(), + "--features", + settings.bevy_features.join(",").as_str(), + "-v", ], - None, - false, - ); - - // fetch the tags - Self::run_system_command( - &bevy_repo_app_settings, - "git", - "Failed to fetch bevy tags", - vec!["fetch", "--tags"], - Some(&bevy_dir), + Some(&settings.bevy_dir), false, )?; + Ok(()) + } - // checkout the version tag - Self::run_system_command( - &bevy_repo_app_settings, - "git", - "Failed to checkout bevy tag", - vec!["checkout", format!("v{bevy_version}").as_str()], - Some(&bevy_dir), - false, - )?; - - // run bevy_api_gen - let template_args = CodegenTemplateArgs { - self_is_bms_lua: true, - }; - - let template_args = serde_json::to_string(&template_args)?; - let bms_bindings_path = Self::workspace_dir(&main_workspace_app_settings)? - .join("crates/bevy_mod_scripting_bindings") - .to_path_buf(); + fn codegen( + app_settings: GlobalArgs, + output_dir: PathBuf, + bevy_features: Vec, + ) -> Result<()> { + let settings = prepare_codegen(app_settings, Some(output_dir), bevy_features)?; - Self::run_workspace_command( - &bevy_repo_app_settings, + run_workspace_command( + &settings.bevy_repo_app_settings, "bms-codegen", "Failed to run bms-codegen generate", vec![ "generate", "--bms-bindings-path", - bms_bindings_path.to_str().unwrap(), + settings.bms_bindings_path.to_str().unwrap(), "--output", - output_dir.to_str().unwrap(), + settings.output_dir.to_str().unwrap(), "--template-args", - template_args.as_str(), + settings.template_args.as_str(), "--features", - bevy_features.join(",").as_str(), + settings.bevy_features.join(",").as_str(), "-v", ], - Some(&bevy_dir), + Some(&settings.bevy_dir), false, )?; // collect - Self::run_workspace_command( - &bevy_repo_app_settings, + run_workspace_command( + &settings.bevy_repo_app_settings, "bms-codegen", "Failed to run bms-codegen generate", vec![ "collect", "--bms-bindings-path", - bms_bindings_path.to_str().unwrap(), + settings.bms_bindings_path.to_str().unwrap(), "--output", - output_dir.to_str().unwrap(), + settings.output_dir.to_str().unwrap(), "--template-args", - template_args.as_str(), + settings.template_args.as_str(), "-v", ], - Some(&bevy_dir), + Some(&settings.bevy_dir), false, )?; // now expand the macros and replace the files in place // by running cargo expand --features crate_name and capturing the output - let generated_crates = (std::fs::read_dir(&output_dir)?).collect::, _>>()?; + let generated_crates = + (std::fs::read_dir(&settings.output_dir)?).collect::, _>>()?; let crate_names = generated_crates .iter() .filter(|s| { @@ -1337,7 +726,7 @@ impl Xtasks { // finally, generate the bindings crate code and move the code in there // get the version from the bevy workspace manifest - let manifest = Self::main_workspace_cargo_metadata()?; + let manifest = main_workspace_cargo_metadata()?; let version = manifest .packages .iter() @@ -1351,7 +740,7 @@ impl Xtasks { .expect("Could not find bevy_mod_scripting package in metadata"); // find features in the corresponding meta file .json under "features" key - let meta_path = output_dir.join(format!("{entry}.json")); + let meta_path = settings.output_dir.join(format!("{entry}.json")); let meta: Meta = serde_json::from_reader( std::fs::File::open(&meta_path) .with_context(|| format!("opening meta file {meta_path:?}"))?, @@ -1364,8 +753,8 @@ impl Xtasks { meta.version, meta.dependencies, ); - let path = Self::relative_workspace_dir( - &main_workspace_app_settings, + let path = relative_workspace_dir( + &settings.main_workspace_app_settings, format!("crates/bindings/{entry}_bms_bindings/"), )?; krate.generate_in_dir(&path)?; @@ -1380,15 +769,16 @@ impl Xtasks { dest_path.parent().unwrap() ) })?; - std::fs::copy(output_dir.join(format!("{entry}.rs")), &dest_path).with_context( - || format!("copying generated binding file to bindings crate: {dest_path:?}"), - )?; + std::fs::copy(settings.output_dir.join(format!("{entry}.rs")), &dest_path) + .with_context(|| { + format!("copying generated binding file to bindings crate: {dest_path:?}") + })?; // finally expand the macros inside let args = vec![String::from("expand")]; - let expand_cmd = Self::run_system_command( - &main_workspace_app_settings, + let expand_cmd = run_system_command( + &settings.main_workspace_app_settings, "cargo", "pre-expanding generated code", args, @@ -1446,9 +836,9 @@ impl Xtasks { // copy the `/assets/bindings.lad.json` file to it's path in the book let ladfile_path = - Self::relative_workspace_dir(&app_settings, "assets/definitions/bindings.lad.json")?; + relative_workspace_dir(&app_settings, "assets/definitions/bindings.lad.json")?; let destination_path = - Self::relative_workspace_dir(&app_settings, "docs/src/ladfiles/bindings.lad.json")?; + relative_workspace_dir(&app_settings, "docs/src/ladfiles/bindings.lad.json")?; info!("Copying generated ladfile from: {ladfile_path:?} to: {destination_path:?}"); std::fs::create_dir_all(destination_path.parent().unwrap())?; @@ -1457,7 +847,7 @@ impl Xtasks { if !no_rust_docs { info!("Building rust docs"); - let metadata = Self::main_workspace_cargo_metadata()?; + let metadata = main_workspace_cargo_metadata()?; let package = metadata .packages @@ -1499,7 +889,7 @@ impl Xtasks { if open { args.push("--open"); } - Self::run_workspace_command( + run_workspace_command( &app_settings, "doc", "Failed to build crates.io docs", @@ -1513,7 +903,7 @@ impl Xtasks { info!("Building mdbook docs"); let args = if !open { vec!["build"] } else { vec!["serve"] }; - Self::run_system_command( + run_system_command( &app_settings, "mdbook", "Failed to build or serve mdbook docs", @@ -1549,7 +939,7 @@ impl Xtasks { vec![] }; - let output = Self::run_workspace_command( + let output = run_workspace_command( // run with just lua54 &app_settings.with_features(features), "bench", @@ -1566,7 +956,7 @@ impl Xtasks { fn bencher(app_settings: GlobalArgs, publish: bool) -> Result<()> { // // first of all figure out which branch we're on // // run // git rev-parse --abbrev-ref HEAD - let workspace_dir = Self::workspace_dir(&app_settings).unwrap(); + let workspace_dir = workspace_dir(&app_settings).unwrap(); let command = Command::new("git") .args(["rev-parse", "--abbrev-ref", "HEAD"]) .current_dir(workspace_dir.clone()) @@ -1832,7 +1222,7 @@ impl Xtasks { test_args.push("--no-fail-fast".to_owned()) } - Self::run_workspace_command( + run_workspace_command( &app_settings, "test", "Failed to run tests", @@ -1843,7 +1233,7 @@ impl Xtasks { // generate coverage report and lcov file if app_settings.coverage { - Self::run_system_command( + run_system_command( &app_settings, "grcov", "Generating html coverage report", @@ -1866,7 +1256,7 @@ impl Xtasks { false, )?; - Self::run_system_command( + run_system_command( &app_settings, "grcov", "Failed to generate coverage report", @@ -2016,7 +1406,7 @@ impl Xtasks { let install_cmd = format!( "{sudo} apt-get update && {sudo} apt-get install --no-install-recommends -y libasound2-dev libudev-dev libwayland-dev" ); - Self::run_system_command( + run_system_command( &app_settings, "sh", "Failed to install Linux dependencies", @@ -2029,7 +1419,7 @@ impl Xtasks { // install bencher // linux curl --proto '=https' --tlsv1.2 -sSfL https://bencher.dev/download/install-cli.sh | sh // windows irm https://bencher.dev/download/install-cli.ps1 | iex - Self::run_system_command( + run_system_command( &app_settings, "cargo", "Failed to install bencher", @@ -2047,7 +1437,7 @@ impl Xtasks { false, )?; // install cargo mdbook - Self::run_system_command( + run_system_command( &app_settings, "cargo", "Failed to install mdbook", @@ -2057,7 +1447,7 @@ impl Xtasks { )?; // install mdbook-mermaid - Self::run_system_command( + run_system_command( &app_settings, "cargo", "Failed to install mdbook", @@ -2067,7 +1457,7 @@ impl Xtasks { )?; // install grcov - Self::run_system_command( + run_system_command( &app_settings, "cargo", "Failed to install grcov", @@ -2077,7 +1467,7 @@ impl Xtasks { )?; // install cargo expand - Self::run_system_command( + run_system_command( &app_settings, "cargo", "Failed to install cargo expand", @@ -2087,8 +1477,8 @@ impl Xtasks { )?; // install nightly toolchaing for bevy api gen - let toolchain = Self::read_rust_toolchain(&Self::codegen_crate_dir(&app_settings)?); - Self::run_system_command( + let toolchain = read_rust_toolchain(&codegen_crate_dir(&app_settings)?); + run_system_command( &app_settings, "rustup", "Failed to install nightly toolchain", @@ -2108,7 +1498,7 @@ impl Xtasks { ]; // install components for the stable and nightly toolchains - Self::run_system_command( + run_system_command( &app_settings, "rustup", "Failed to install rust components", @@ -2118,7 +1508,7 @@ impl Xtasks { )?; // add components on nightly toolchain - Self::run_system_command( + run_system_command( &app_settings, "rustup", "Failed to install nightly components", @@ -2135,7 +1525,7 @@ impl Xtasks { let vscode_settings = include_str!("../templates/settings.json.tera"); let mut tera = tera::Tera::default(); let mut context = tera::Context::new(); - let workspace_dir = Self::workspace_dir(&app_settings)?; + let workspace_dir = workspace_dir(&app_settings)?; let json_workspace_dir = serde_json::to_string(&workspace_dir)?; // make sure this works as a json string context.insert("dir", &json_workspace_dir.trim_matches('\"')); @@ -2143,7 +1533,7 @@ impl Xtasks { let templated_settings_json = Self::read_json_with_comments(templated_settings.as_bytes()) .with_context(|| "reading templated vscode settings")?; - let vscode_dir = Self::relative_workspace_dir(&app_settings, ".vscode")?; + let vscode_dir = relative_workspace_dir(&app_settings, ".vscode")?; std::fs::create_dir_all(&vscode_dir)?; let vscode_settings_path = vscode_dir.join("settings.json"); @@ -2198,12 +1588,12 @@ impl Xtasks { // path = "examples/docgen.rs" // required-features = [] - // let metadata = Self::main_workspace_cargo_metadata()?; + // let metadata = main_workspace_cargo_metadata()?; // let metadata = &metadata.root_package().unwrap().targets; // println!("{metadata:#?}"); // run the example - Self::run_workspace_command( + run_workspace_command( &app_settings, "run", "Failed to run example", @@ -2217,8 +1607,8 @@ impl Xtasks { fn install(app_settings: GlobalArgs, binary: Binary) -> std::result::Result<(), Error> { // run cargo install --path - let binary_path = Self::relative_workspace_dir(&app_settings, binary.path())?; - Self::run_system_command( + let binary_path = relative_workspace_dir(&app_settings, binary.path())?; + run_system_command( &app_settings, "cargo", "Failed to install binary", From d968ff96e891cfe31205e66b6d25d670e722e16a Mon Sep 17 00:00:00 2001 From: makspll Date: Sat, 22 Nov 2025 09:05:43 +0000 Subject: [PATCH 22/22] some changes to bindings --- .../bevy_a11y_bms_bindings/src/lib.rs | 73 +- .../bevy_animation_bms_bindings/src/lib.rs | 322 +- .../bevy_asset_bms_bindings/src/lib.rs | 280 +- .../bevy_camera_bms_bindings/src/lib.rs | 822 +- .../bevy_color_bms_bindings/src/lib.rs | 1292 +- .../src/lib.rs | 104 +- .../bindings/bevy_ecs_bms_bindings/src/lib.rs | 698 +- .../bevy_gizmos_bms_bindings/src/lib.rs | 100 +- .../bevy_gltf_bms_bindings/src/lib.rs | 56 +- .../bevy_image_bms_bindings/src/lib.rs | 196 +- .../bevy_input_bms_bindings/src/lib.rs | 997 +- .../bevy_input_focus_bms_bindings/src/lib.rs | 192 +- .../bevy_light_bms_bindings/src/lib.rs | 249 +- .../bevy_math_bms_bindings/src/lib.rs | 4116 +-- .../bevy_mesh_bms_bindings/src/lib.rs | 1188 +- .../bindings/bevy_pbr_bms_bindings/src/lib.rs | 505 +- .../bevy_picking_bms_bindings/src/lib.rs | 694 +- .../bevy_post_process_bms_bindings/src/lib.rs | 108 +- .../bevy_reflect_bms_bindings/src/lib.rs | 29942 +++++++--------- .../bevy_render_bms_bindings/src/lib.rs | 311 +- .../bevy_scene_bms_bindings/src/lib.rs | 86 +- .../bevy_sprite_bms_bindings/src/lib.rs | 213 +- .../src/lib.rs | 164 +- .../bevy_text_bms_bindings/src/lib.rs | 345 +- .../bevy_time_bms_bindings/src/lib.rs | 339 +- .../bevy_transform_bms_bindings/src/lib.rs | 753 +- .../bindings/bevy_ui_bms_bindings/src/lib.rs | 2556 +- .../bevy_ui_render_bms_bindings/src/lib.rs | 44 +- 28 files changed, 21463 insertions(+), 25282 deletions(-) diff --git a/crates/bindings/bevy_a11y_bms_bindings/src/lib.rs b/crates/bindings/bevy_a11y_bms_bindings/src/lib.rs index 7b7f72cd41..9250ca8ca0 100644 --- a/crates/bindings/bevy_a11y_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_a11y_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -24,11 +24,10 @@ pub(crate) fn register_accessibility_requested_functions(world: &mut World) { |_self: Ref<::bevy_a11y::AccessibilityRequested>| { let output: Val<::bevy_a11y::AccessibilityRequested> = { { - let output: Val<::bevy_a11y::AccessibilityRequested> = <::bevy_a11y::AccessibilityRequested as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_a11y::AccessibilityRequested = <::bevy_a11y::AccessibilityRequested as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42,10 +41,9 @@ pub(crate) fn register_accessibility_requested_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_a11y::AccessibilityRequested::get( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -59,11 +57,10 @@ pub(crate) fn register_accessibility_requested_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_a11y::AccessibilityRequested::set( - &_self, - value, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -88,11 +85,10 @@ pub(crate) fn register_manage_accessibility_updates_functions(world: &mut World) |_self: Ref<::bevy_a11y::ManageAccessibilityUpdates>| { let output: Val<::bevy_a11y::ManageAccessibilityUpdates> = { { - let output: Val<::bevy_a11y::ManageAccessibilityUpdates> = <::bevy_a11y::ManageAccessibilityUpdates as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_a11y::ManageAccessibilityUpdates = <::bevy_a11y::ManageAccessibilityUpdates as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -106,10 +102,9 @@ pub(crate) fn register_manage_accessibility_updates_functions(world: &mut World) let output: bool = { { let output: bool = ::bevy_a11y::ManageAccessibilityUpdates::get( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -123,11 +118,10 @@ pub(crate) fn register_manage_accessibility_updates_functions(world: &mut World) let output: () = { { let output: () = ::bevy_a11y::ManageAccessibilityUpdates::set( - &mut _self, - value, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -153,10 +147,9 @@ pub(crate) fn register_accessibility_systems_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_a11y::AccessibilitySystems as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -169,11 +162,10 @@ pub(crate) fn register_accessibility_systems_functions(world: &mut World) { |_self: Ref<::bevy_a11y::AccessibilitySystems>| { let output: Val<::bevy_a11y::AccessibilitySystems> = { { - let output: Val<::bevy_a11y::AccessibilitySystems> = <::bevy_a11y::AccessibilitySystems as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_a11y::AccessibilitySystems = <::bevy_a11y::AccessibilitySystems as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -191,9 +183,8 @@ pub(crate) fn register_accessibility_systems_functions(world: &mut World) { { let output: bool = <::bevy_a11y::AccessibilitySystems as ::core::cmp::PartialEq< ::bevy_a11y::AccessibilitySystems, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_animation_bms_bindings/src/lib.rs b/crates/bindings/bevy_animation_bms_bindings/src/lib.rs index 9670f0b3b2..64a5ad33fd 100644 --- a/crates/bindings/bevy_animation_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_animation_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -24,11 +24,10 @@ pub(crate) fn register_animation_node_type_functions(world: &mut World) { |_self: Ref<::bevy_animation::graph::AnimationNodeType>| { let output: Val<::bevy_animation::graph::AnimationNodeType> = { { - let output: Val<::bevy_animation::graph::AnimationNodeType> = <::bevy_animation::graph::AnimationNodeType as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_animation::graph::AnimationNodeType = <::bevy_animation::graph::AnimationNodeType as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -54,10 +53,9 @@ pub(crate) fn register_animation_graph_handle_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_animation::graph::AnimationGraphHandle as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -70,11 +68,10 @@ pub(crate) fn register_animation_graph_handle_functions(world: &mut World) { |_self: Ref<::bevy_animation::graph::AnimationGraphHandle>| { let output: Val<::bevy_animation::graph::AnimationGraphHandle> = { { - let output: Val<::bevy_animation::graph::AnimationGraphHandle> = <::bevy_animation::graph::AnimationGraphHandle as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_animation::graph::AnimationGraphHandle = <::bevy_animation::graph::AnimationGraphHandle as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -92,9 +89,8 @@ pub(crate) fn register_animation_graph_handle_functions(world: &mut World) { { let output: bool = <::bevy_animation::graph::AnimationGraphHandle as ::std::cmp::PartialEq< ::bevy_animation::graph::AnimationGraphHandle, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -131,11 +127,10 @@ pub(crate) fn register_animation_clip_functions(world: &mut World) { |_self: Ref<::bevy_animation::AnimationClip>| { let output: Val<::bevy_animation::AnimationClip> = { { - let output: Val<::bevy_animation::AnimationClip> = <::bevy_animation::AnimationClip as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_animation::AnimationClip = <::bevy_animation::AnimationClip as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -149,10 +144,9 @@ pub(crate) fn register_animation_clip_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_animation::AnimationClip::duration( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -166,11 +160,10 @@ pub(crate) fn register_animation_clip_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_animation::AnimationClip::set_duration( - &mut _self, - duration_sec, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(duration_sec), + ); + safe_transmute(output) } }; output @@ -196,10 +189,9 @@ pub(crate) fn register_animation_player_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_animation::AnimationPlayer::all_finished( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -213,10 +205,9 @@ pub(crate) fn register_animation_player_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_animation::AnimationPlayer::all_paused( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -229,11 +220,10 @@ pub(crate) fn register_animation_player_functions(world: &mut World) { |_self: Ref<::bevy_animation::AnimationPlayer>| { let output: Val<::bevy_animation::AnimationPlayer> = { { - let output: Val<::bevy_animation::AnimationPlayer> = <::bevy_animation::AnimationPlayer as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_animation::AnimationPlayer = <::bevy_animation::AnimationPlayer as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -250,11 +240,10 @@ pub(crate) fn register_animation_player_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_animation::AnimationPlayer as ::std::clone::Clone>::clone_from( - &mut _self, - &source, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(source), + ); + safe_transmute(output) } }; output @@ -284,12 +273,11 @@ pub(crate) fn register_animation_graph_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_animation::graph::AnimationGraph::add_target_to_mask_group( - &mut _self, - target.into_inner(), - mask_group, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(target), + safe_transmute(mask_group), + ); + safe_transmute(output) } }; output @@ -302,11 +290,10 @@ pub(crate) fn register_animation_graph_functions(world: &mut World) { |_self: Ref<::bevy_animation::graph::AnimationGraph>| { let output: Val<::bevy_animation::graph::AnimationGraph> = { { - let output: Val<::bevy_animation::graph::AnimationGraph> = <::bevy_animation::graph::AnimationGraph as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_animation::graph::AnimationGraph = <::bevy_animation::graph::AnimationGraph as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -319,9 +306,8 @@ pub(crate) fn register_animation_graph_functions(world: &mut World) { || { let output: Val<::bevy_animation::graph::AnimationGraph> = { { - let output: Val<::bevy_animation::graph::AnimationGraph> = ::bevy_animation::graph::AnimationGraph::new() - .into(); - output + let output: ::bevy_animation::graph::AnimationGraph = ::bevy_animation::graph::AnimationGraph::new(); + safe_transmute(output) } }; output @@ -347,10 +333,9 @@ pub(crate) fn register_animation_target_id_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_animation::AnimationTargetId as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -363,11 +348,10 @@ pub(crate) fn register_animation_target_id_functions(world: &mut World) { |_self: Ref<::bevy_animation::AnimationTargetId>| { let output: Val<::bevy_animation::AnimationTargetId> = { { - let output: Val<::bevy_animation::AnimationTargetId> = <::bevy_animation::AnimationTargetId as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_animation::AnimationTargetId = <::bevy_animation::AnimationTargetId as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -385,9 +369,8 @@ pub(crate) fn register_animation_target_id_functions(world: &mut World) { { let output: bool = <::bevy_animation::AnimationTargetId as ::std::cmp::PartialEq< ::bevy_animation::AnimationTargetId, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -400,11 +383,10 @@ pub(crate) fn register_animation_target_id_functions(world: &mut World) { |name: Ref<::bevy_ecs::name::Name>| { let output: Val<::bevy_animation::AnimationTargetId> = { { - let output: Val<::bevy_animation::AnimationTargetId> = ::bevy_animation::AnimationTargetId::from_name( - &name, - ) - .into(); - output + let output: ::bevy_animation::AnimationTargetId = ::bevy_animation::AnimationTargetId::from_name( + safe_transmute(name), + ); + safe_transmute(output) } }; output @@ -429,11 +411,10 @@ pub(crate) fn register_animation_target_functions(world: &mut World) { |_self: Ref<::bevy_animation::AnimationTarget>| { let output: Val<::bevy_animation::AnimationTarget> = { { - let output: Val<::bevy_animation::AnimationTarget> = <::bevy_animation::AnimationTarget as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_animation::AnimationTarget = <::bevy_animation::AnimationTarget as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -459,10 +440,9 @@ pub(crate) fn register_repeat_animation_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_animation::RepeatAnimation as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -475,11 +455,10 @@ pub(crate) fn register_repeat_animation_functions(world: &mut World) { |_self: Ref<::bevy_animation::RepeatAnimation>| { let output: Val<::bevy_animation::RepeatAnimation> = { { - let output: Val<::bevy_animation::RepeatAnimation> = <::bevy_animation::RepeatAnimation as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_animation::RepeatAnimation = <::bevy_animation::RepeatAnimation as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -497,9 +476,8 @@ pub(crate) fn register_repeat_animation_functions(world: &mut World) { { let output: bool = <::bevy_animation::RepeatAnimation as ::std::cmp::PartialEq< ::bevy_animation::RepeatAnimation, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -524,11 +502,10 @@ pub(crate) fn register_active_animation_functions(world: &mut World) { |_self: Ref<::bevy_animation::ActiveAnimation>| { let output: Val<::bevy_animation::ActiveAnimation> = { { - let output: Val<::bevy_animation::ActiveAnimation> = <::bevy_animation::ActiveAnimation as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_animation::ActiveAnimation = <::bevy_animation::ActiveAnimation as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -542,10 +519,9 @@ pub(crate) fn register_active_animation_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::bevy_animation::ActiveAnimation::completions( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -559,10 +535,9 @@ pub(crate) fn register_active_animation_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_animation::ActiveAnimation::elapsed( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -576,10 +551,9 @@ pub(crate) fn register_active_animation_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_animation::ActiveAnimation::is_finished( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -593,10 +567,9 @@ pub(crate) fn register_active_animation_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_animation::ActiveAnimation::is_paused( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -610,10 +583,9 @@ pub(crate) fn register_active_animation_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_animation::ActiveAnimation::is_playback_reversed( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -626,11 +598,10 @@ pub(crate) fn register_active_animation_functions(world: &mut World) { |_self: Ref<::bevy_animation::ActiveAnimation>| { let output: Val<::bevy_animation::RepeatAnimation> = { { - let output: Val<::bevy_animation::RepeatAnimation> = ::bevy_animation::ActiveAnimation::repeat_mode( - &_self, - ) - .into(); - output + let output: ::bevy_animation::RepeatAnimation = ::bevy_animation::ActiveAnimation::repeat_mode( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -644,10 +615,9 @@ pub(crate) fn register_active_animation_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_animation::ActiveAnimation::replay( - &mut _self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -661,10 +631,9 @@ pub(crate) fn register_active_animation_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_animation::ActiveAnimation::seek_time( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -678,10 +647,9 @@ pub(crate) fn register_active_animation_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_animation::ActiveAnimation::speed( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -695,10 +663,9 @@ pub(crate) fn register_active_animation_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_animation::ActiveAnimation::weight( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -723,11 +690,10 @@ pub(crate) fn register_weights_curve_functions(world: &mut World) { |_self: Ref<::bevy_animation::gltf_curves::WeightsCurve>| { let output: Val<::bevy_animation::gltf_curves::WeightsCurve> = { { - let output: Val<::bevy_animation::gltf_curves::WeightsCurve> = <::bevy_animation::gltf_curves::WeightsCurve as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_animation::gltf_curves::WeightsCurve = <::bevy_animation::gltf_curves::WeightsCurve as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -752,13 +718,10 @@ pub(crate) fn register_cubic_rotation_curve_functions(world: &mut World) { |_self: Ref<::bevy_animation::gltf_curves::CubicRotationCurve>| { let output: Val<::bevy_animation::gltf_curves::CubicRotationCurve> = { { - let output: Val< - ::bevy_animation::gltf_curves::CubicRotationCurve, - > = <::bevy_animation::gltf_curves::CubicRotationCurve as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_animation::gltf_curves::CubicRotationCurve = <::bevy_animation::gltf_curves::CubicRotationCurve as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -783,11 +746,10 @@ pub(crate) fn register_animation_graph_node_functions(world: &mut World) { |_self: Ref<::bevy_animation::graph::AnimationGraphNode>| { let output: Val<::bevy_animation::graph::AnimationGraphNode> = { { - let output: Val<::bevy_animation::graph::AnimationGraphNode> = <::bevy_animation::graph::AnimationGraphNode as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_animation::graph::AnimationGraphNode = <::bevy_animation::graph::AnimationGraphNode as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -824,13 +786,10 @@ pub(crate) fn register_animation_transitions_functions(world: &mut World) { |_self: Ref<::bevy_animation::transition::AnimationTransitions>| { let output: Val<::bevy_animation::transition::AnimationTransitions> = { { - let output: Val< - ::bevy_animation::transition::AnimationTransitions, - > = <::bevy_animation::transition::AnimationTransitions as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_animation::transition::AnimationTransitions = <::bevy_animation::transition::AnimationTransitions as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -847,11 +806,10 @@ pub(crate) fn register_animation_transitions_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_animation::transition::AnimationTransitions as ::std::clone::Clone>::clone_from( - &mut _self, - &source, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(source), + ); + safe_transmute(output) } }; output @@ -864,11 +822,8 @@ pub(crate) fn register_animation_transitions_functions(world: &mut World) { || { let output: Val<::bevy_animation::transition::AnimationTransitions> = { { - let output: Val< - ::bevy_animation::transition::AnimationTransitions, - > = ::bevy_animation::transition::AnimationTransitions::new() - .into(); - output + let output: ::bevy_animation::transition::AnimationTransitions = ::bevy_animation::transition::AnimationTransitions::new(); + safe_transmute(output) } }; output @@ -893,13 +848,10 @@ pub(crate) fn register_animation_transition_functions(world: &mut World) { |_self: Ref<::bevy_animation::transition::AnimationTransition>| { let output: Val<::bevy_animation::transition::AnimationTransition> = { { - let output: Val< - ::bevy_animation::transition::AnimationTransition, - > = <::bevy_animation::transition::AnimationTransition as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_animation::transition::AnimationTransition = <::bevy_animation::transition::AnimationTransition as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_asset_bms_bindings/src/lib.rs b/crates/bindings/bevy_asset_bms_bindings/src/lib.rs index 4c474c9c87..d3ea9a7b8d 100644 --- a/crates/bindings/bevy_asset_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_asset_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -24,11 +24,10 @@ pub(crate) fn register_untyped_handle_functions(world: &mut World) { |_self: Ref<::bevy_asset::UntypedHandle>| { let output: Val<::bevy_asset::UntypedHandle> = { { - let output: Val<::bevy_asset::UntypedHandle> = <::bevy_asset::UntypedHandle as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_asset::UntypedHandle = <::bevy_asset::UntypedHandle as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -46,9 +45,8 @@ pub(crate) fn register_untyped_handle_functions(world: &mut World) { { let output: bool = <::bevy_asset::UntypedHandle as ::core::cmp::PartialEq< ::bevy_asset::UntypedHandle, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -61,11 +59,10 @@ pub(crate) fn register_untyped_handle_functions(world: &mut World) { |_self: Ref<::bevy_asset::UntypedHandle>| { let output: Val<::bevy_asset::UntypedAssetId> = { { - let output: Val<::bevy_asset::UntypedAssetId> = ::bevy_asset::UntypedHandle::id( - &_self, - ) - .into(); - output + let output: ::bevy_asset::UntypedAssetId = ::bevy_asset::UntypedHandle::id( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -78,11 +75,10 @@ pub(crate) fn register_untyped_handle_functions(world: &mut World) { |_self: Ref<::bevy_asset::UntypedHandle>| { let output: Val<::core::any::TypeId> = { { - let output: Val<::core::any::TypeId> = ::bevy_asset::UntypedHandle::type_id( - &_self, - ) - .into(); - output + let output: ::core::any::TypeId = ::bevy_asset::UntypedHandle::type_id( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -107,11 +103,10 @@ pub(crate) fn register_untyped_asset_id_functions(world: &mut World) { |_self: Ref<::bevy_asset::UntypedAssetId>| { let output: Val<::bevy_asset::UntypedAssetId> = { { - let output: Val<::bevy_asset::UntypedAssetId> = <::bevy_asset::UntypedAssetId as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_asset::UntypedAssetId = <::bevy_asset::UntypedAssetId as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -129,9 +124,8 @@ pub(crate) fn register_untyped_asset_id_functions(world: &mut World) { { let output: bool = <::bevy_asset::UntypedAssetId as ::core::cmp::PartialEq< ::bevy_asset::UntypedAssetId, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -144,11 +138,10 @@ pub(crate) fn register_untyped_asset_id_functions(world: &mut World) { |_self: Ref<::bevy_asset::UntypedAssetId>| { let output: Val<::core::any::TypeId> = { { - let output: Val<::core::any::TypeId> = ::bevy_asset::UntypedAssetId::type_id( - &_self, - ) - .into(); - output + let output: ::core::any::TypeId = ::bevy_asset::UntypedAssetId::type_id( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -174,10 +167,9 @@ pub(crate) fn register_asset_index_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_asset::AssetIndex as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -190,11 +182,10 @@ pub(crate) fn register_asset_index_functions(world: &mut World) { |_self: Ref<::bevy_asset::AssetIndex>| { let output: Val<::bevy_asset::AssetIndex> = { { - let output: Val<::bevy_asset::AssetIndex> = <::bevy_asset::AssetIndex as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_asset::AssetIndex = <::bevy_asset::AssetIndex as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -209,9 +200,8 @@ pub(crate) fn register_asset_index_functions(world: &mut World) { { let output: bool = <::bevy_asset::AssetIndex as ::core::cmp::PartialEq< ::bevy_asset::AssetIndex, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -224,11 +214,10 @@ pub(crate) fn register_asset_index_functions(world: &mut World) { |bits: u64| { let output: Val<::bevy_asset::AssetIndex> = { { - let output: Val<::bevy_asset::AssetIndex> = ::bevy_asset::AssetIndex::from_bits( - bits, - ) - .into(); - output + let output: ::bevy_asset::AssetIndex = ::bevy_asset::AssetIndex::from_bits( + safe_transmute(bits), + ); + safe_transmute(output) } }; output @@ -242,10 +231,9 @@ pub(crate) fn register_asset_index_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::bevy_asset::AssetIndex::to_bits( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -270,9 +258,8 @@ pub(crate) fn register_render_asset_usages_functions(world: &mut World) { || { let output: Val<::bevy_asset::RenderAssetUsages> = { { - let output: Val<::bevy_asset::RenderAssetUsages> = ::bevy_asset::RenderAssetUsages::all() - .into(); - output + let output: ::bevy_asset::RenderAssetUsages = ::bevy_asset::RenderAssetUsages::all(); + safe_transmute(output) } }; output @@ -286,10 +273,9 @@ pub(crate) fn register_render_asset_usages_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_asset::RenderAssetUsages as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -302,9 +288,10 @@ pub(crate) fn register_render_asset_usages_functions(world: &mut World) { |_self: Ref<::bevy_asset::RenderAssetUsages>| { let output: u8 = { { - let output: u8 = ::bevy_asset::RenderAssetUsages::bits(&_self) - .into(); - output + let output: u8 = ::bevy_asset::RenderAssetUsages::bits( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -317,11 +304,10 @@ pub(crate) fn register_render_asset_usages_functions(world: &mut World) { |_self: Ref<::bevy_asset::RenderAssetUsages>| { let output: Val<::bevy_asset::RenderAssetUsages> = { { - let output: Val<::bevy_asset::RenderAssetUsages> = <::bevy_asset::RenderAssetUsages as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_asset::RenderAssetUsages = <::bevy_asset::RenderAssetUsages as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -334,11 +320,10 @@ pub(crate) fn register_render_asset_usages_functions(world: &mut World) { |_self: Val<::bevy_asset::RenderAssetUsages>| { let output: Val<::bevy_asset::RenderAssetUsages> = { { - let output: Val<::bevy_asset::RenderAssetUsages> = ::bevy_asset::RenderAssetUsages::complement( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_asset::RenderAssetUsages = ::bevy_asset::RenderAssetUsages::complement( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -355,11 +340,10 @@ pub(crate) fn register_render_asset_usages_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_asset::RenderAssetUsages::contains( - &_self, - other.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -375,12 +359,11 @@ pub(crate) fn register_render_asset_usages_functions(world: &mut World) { { let output: Val<::bevy_asset::RenderAssetUsages> = { { - let output: Val<::bevy_asset::RenderAssetUsages> = ::bevy_asset::RenderAssetUsages::difference( - _self.into_inner(), - other.into_inner(), - ) - .into(); - output + let output: ::bevy_asset::RenderAssetUsages = ::bevy_asset::RenderAssetUsages::difference( + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -393,9 +376,8 @@ pub(crate) fn register_render_asset_usages_functions(world: &mut World) { || { let output: Val<::bevy_asset::RenderAssetUsages> = { { - let output: Val<::bevy_asset::RenderAssetUsages> = ::bevy_asset::RenderAssetUsages::empty() - .into(); - output + let output: ::bevy_asset::RenderAssetUsages = ::bevy_asset::RenderAssetUsages::empty(); + safe_transmute(output) } }; output @@ -413,9 +395,8 @@ pub(crate) fn register_render_asset_usages_functions(world: &mut World) { { let output: bool = <::bevy_asset::RenderAssetUsages as ::core::cmp::PartialEq< ::bevy_asset::RenderAssetUsages, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -428,11 +409,10 @@ pub(crate) fn register_render_asset_usages_functions(world: &mut World) { |bits: u8| { let output: Val<::bevy_asset::RenderAssetUsages> = { { - let output: Val<::bevy_asset::RenderAssetUsages> = ::bevy_asset::RenderAssetUsages::from_bits_retain( - bits, - ) - .into(); - output + let output: ::bevy_asset::RenderAssetUsages = ::bevy_asset::RenderAssetUsages::from_bits_retain( + safe_transmute(bits), + ); + safe_transmute(output) } }; output @@ -445,11 +425,10 @@ pub(crate) fn register_render_asset_usages_functions(world: &mut World) { |bits: u8| { let output: Val<::bevy_asset::RenderAssetUsages> = { { - let output: Val<::bevy_asset::RenderAssetUsages> = ::bevy_asset::RenderAssetUsages::from_bits_truncate( - bits, - ) - .into(); - output + let output: ::bevy_asset::RenderAssetUsages = ::bevy_asset::RenderAssetUsages::from_bits_truncate( + safe_transmute(bits), + ); + safe_transmute(output) } }; output @@ -466,11 +445,10 @@ pub(crate) fn register_render_asset_usages_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_asset::RenderAssetUsages::insert( - &mut _self, - other.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -486,12 +464,11 @@ pub(crate) fn register_render_asset_usages_functions(world: &mut World) { { let output: Val<::bevy_asset::RenderAssetUsages> = { { - let output: Val<::bevy_asset::RenderAssetUsages> = ::bevy_asset::RenderAssetUsages::intersection( - _self.into_inner(), - other.into_inner(), - ) - .into(); - output + let output: ::bevy_asset::RenderAssetUsages = ::bevy_asset::RenderAssetUsages::intersection( + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -508,11 +485,10 @@ pub(crate) fn register_render_asset_usages_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_asset::RenderAssetUsages::intersects( - &_self, - other.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -526,10 +502,9 @@ pub(crate) fn register_render_asset_usages_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_asset::RenderAssetUsages::is_all( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -543,10 +518,9 @@ pub(crate) fn register_render_asset_usages_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_asset::RenderAssetUsages::is_empty( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -563,11 +537,10 @@ pub(crate) fn register_render_asset_usages_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_asset::RenderAssetUsages::remove( - &mut _self, - other.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -585,12 +558,11 @@ pub(crate) fn register_render_asset_usages_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_asset::RenderAssetUsages::set( - &mut _self, - other.into_inner(), - value, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(other), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -606,11 +578,10 @@ pub(crate) fn register_render_asset_usages_functions(world: &mut World) { { let output: Val<::bevy_asset::RenderAssetUsages> = { { - let output: Val<::bevy_asset::RenderAssetUsages> = <::bevy_asset::RenderAssetUsages as ::core::ops::Sub< + let output: ::bevy_asset::RenderAssetUsages = <::bevy_asset::RenderAssetUsages as ::core::ops::Sub< ::bevy_asset::RenderAssetUsages, - >>::sub(_self.into_inner(), other.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -626,12 +597,11 @@ pub(crate) fn register_render_asset_usages_functions(world: &mut World) { { let output: Val<::bevy_asset::RenderAssetUsages> = { { - let output: Val<::bevy_asset::RenderAssetUsages> = ::bevy_asset::RenderAssetUsages::symmetric_difference( - _self.into_inner(), - other.into_inner(), - ) - .into(); - output + let output: ::bevy_asset::RenderAssetUsages = ::bevy_asset::RenderAssetUsages::symmetric_difference( + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -648,11 +618,10 @@ pub(crate) fn register_render_asset_usages_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_asset::RenderAssetUsages::toggle( - &mut _self, - other.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -668,12 +637,11 @@ pub(crate) fn register_render_asset_usages_functions(world: &mut World) { { let output: Val<::bevy_asset::RenderAssetUsages> = { { - let output: Val<::bevy_asset::RenderAssetUsages> = ::bevy_asset::RenderAssetUsages::union( - _self.into_inner(), - other.into_inner(), - ) - .into(); - output + let output: ::bevy_asset::RenderAssetUsages = ::bevy_asset::RenderAssetUsages::union( + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_camera_bms_bindings/src/lib.rs b/crates/bindings/bevy_camera_bms_bindings/src/lib.rs index 0b49890149..84906d5a4a 100644 --- a/crates/bindings/bevy_camera_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_camera_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -24,11 +24,10 @@ pub(crate) fn register_clear_color_functions(world: &mut World) { |_self: Ref<::bevy_camera::ClearColor>| { let output: Val<::bevy_camera::ClearColor> = { { - let output: Val<::bevy_camera::ClearColor> = <::bevy_camera::ClearColor as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::ClearColor = <::bevy_camera::ClearColor as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -54,10 +53,9 @@ pub(crate) fn register_inherited_visibility_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_camera::visibility::InheritedVisibility as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -70,13 +68,10 @@ pub(crate) fn register_inherited_visibility_functions(world: &mut World) { |_self: Ref<::bevy_camera::visibility::InheritedVisibility>| { let output: Val<::bevy_camera::visibility::InheritedVisibility> = { { - let output: Val< - ::bevy_camera::visibility::InheritedVisibility, - > = <::bevy_camera::visibility::InheritedVisibility as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::visibility::InheritedVisibility = <::bevy_camera::visibility::InheritedVisibility as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -94,9 +89,8 @@ pub(crate) fn register_inherited_visibility_functions(world: &mut World) { { let output: bool = <::bevy_camera::visibility::InheritedVisibility as ::std::cmp::PartialEq< ::bevy_camera::visibility::InheritedVisibility, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -110,10 +104,9 @@ pub(crate) fn register_inherited_visibility_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_camera::visibility::InheritedVisibility::get( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -139,10 +132,9 @@ pub(crate) fn register_view_visibility_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_camera::visibility::ViewVisibility as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -155,11 +147,10 @@ pub(crate) fn register_view_visibility_functions(world: &mut World) { |_self: Ref<::bevy_camera::visibility::ViewVisibility>| { let output: Val<::bevy_camera::visibility::ViewVisibility> = { { - let output: Val<::bevy_camera::visibility::ViewVisibility> = <::bevy_camera::visibility::ViewVisibility as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::visibility::ViewVisibility = <::bevy_camera::visibility::ViewVisibility as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -177,9 +168,8 @@ pub(crate) fn register_view_visibility_functions(world: &mut World) { { let output: bool = <::bevy_camera::visibility::ViewVisibility as ::std::cmp::PartialEq< ::bevy_camera::visibility::ViewVisibility, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -193,10 +183,9 @@ pub(crate) fn register_view_visibility_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_camera::visibility::ViewVisibility::get( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -210,10 +199,9 @@ pub(crate) fn register_view_visibility_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_camera::visibility::ViewVisibility::set( - &mut _self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -239,10 +227,9 @@ pub(crate) fn register_visibility_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_camera::visibility::Visibility as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -255,11 +242,10 @@ pub(crate) fn register_visibility_functions(world: &mut World) { |_self: Ref<::bevy_camera::visibility::Visibility>| { let output: Val<::bevy_camera::visibility::Visibility> = { { - let output: Val<::bevy_camera::visibility::Visibility> = <::bevy_camera::visibility::Visibility as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::visibility::Visibility = <::bevy_camera::visibility::Visibility as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -277,9 +263,8 @@ pub(crate) fn register_visibility_functions(world: &mut World) { { let output: bool = <::bevy_camera::visibility::Visibility as ::std::cmp::PartialEq< ::bevy_camera::visibility::Visibility, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -293,10 +278,9 @@ pub(crate) fn register_visibility_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_camera::visibility::Visibility::toggle_inherited_hidden( - &mut _self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -310,10 +294,9 @@ pub(crate) fn register_visibility_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_camera::visibility::Visibility::toggle_inherited_visible( - &mut _self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -327,10 +310,9 @@ pub(crate) fn register_visibility_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_camera::visibility::Visibility::toggle_visible_hidden( - &mut _self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -353,13 +335,12 @@ pub(crate) fn register_camera_functions(world: &mut World) { .register_documented( "clip_from_view", |_self: Ref<::bevy_camera::Camera>| { - let output: Val<::glam::Mat4> = { + let output: Val<::bevy_math::Mat4> = { { - let output: Val<::glam::Mat4> = ::bevy_camera::Camera::clip_from_view( - &_self, - ) - .into(); - output + let output: ::bevy_math::Mat4 = ::bevy_camera::Camera::clip_from_view( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -372,11 +353,10 @@ pub(crate) fn register_camera_functions(world: &mut World) { |_self: Ref<::bevy_camera::Camera>| { let output: Val<::bevy_camera::Camera> = { { - let output: Val<::bevy_camera::Camera> = <::bevy_camera::Camera as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::Camera = <::bevy_camera::Camera as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -390,11 +370,10 @@ pub(crate) fn register_camera_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_camera::Camera::depth_ndc_to_view_z( - &_self, - ndc_depth, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(ndc_depth), + ); + safe_transmute(output) } }; output @@ -408,11 +387,10 @@ pub(crate) fn register_camera_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_camera::Camera::depth_ndc_to_view_z_2d( - &_self, - ndc_depth, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(ndc_depth), + ); + safe_transmute(output) } }; output @@ -426,10 +404,9 @@ pub(crate) fn register_camera_functions(world: &mut World) { let output: ::std::option::Option = { { let output: ::std::option::Option = ::bevy_camera::Camera::target_scaling_factor( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -454,11 +431,10 @@ pub(crate) fn register_camera_2_d_functions(world: &mut World) { |_self: Ref<::bevy_camera::Camera2d>| { let output: Val<::bevy_camera::Camera2d> = { { - let output: Val<::bevy_camera::Camera2d> = <::bevy_camera::Camera2d as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::Camera2d = <::bevy_camera::Camera2d as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -483,11 +459,10 @@ pub(crate) fn register_camera_3_d_functions(world: &mut World) { |_self: Ref<::bevy_camera::Camera3d>| { let output: Val<::bevy_camera::Camera3d> = { { - let output: Val<::bevy_camera::Camera3d> = <::bevy_camera::Camera3d as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::Camera3d = <::bevy_camera::Camera3d as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -512,11 +487,10 @@ pub(crate) fn register_clear_color_config_functions(world: &mut World) { |_self: Ref<::bevy_camera::ClearColorConfig>| { let output: Val<::bevy_camera::ClearColorConfig> = { { - let output: Val<::bevy_camera::ClearColorConfig> = <::bevy_camera::ClearColorConfig as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::ClearColorConfig = <::bevy_camera::ClearColorConfig as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -541,11 +515,10 @@ pub(crate) fn register_orthographic_projection_functions(world: &mut World) { |_self: Ref<::bevy_camera::OrthographicProjection>| { let output: Val<::bevy_camera::OrthographicProjection> = { { - let output: Val<::bevy_camera::OrthographicProjection> = <::bevy_camera::OrthographicProjection as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::OrthographicProjection = <::bevy_camera::OrthographicProjection as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -558,9 +531,8 @@ pub(crate) fn register_orthographic_projection_functions(world: &mut World) { || { let output: Val<::bevy_camera::OrthographicProjection> = { { - let output: Val<::bevy_camera::OrthographicProjection> = ::bevy_camera::OrthographicProjection::default_2d() - .into(); - output + let output: ::bevy_camera::OrthographicProjection = ::bevy_camera::OrthographicProjection::default_2d(); + safe_transmute(output) } }; output @@ -573,9 +545,8 @@ pub(crate) fn register_orthographic_projection_functions(world: &mut World) { || { let output: Val<::bevy_camera::OrthographicProjection> = { { - let output: Val<::bevy_camera::OrthographicProjection> = ::bevy_camera::OrthographicProjection::default_3d() - .into(); - output + let output: ::bevy_camera::OrthographicProjection = ::bevy_camera::OrthographicProjection::default_3d(); + safe_transmute(output) } }; output @@ -600,11 +571,10 @@ pub(crate) fn register_perspective_projection_functions(world: &mut World) { |_self: Ref<::bevy_camera::PerspectiveProjection>| { let output: Val<::bevy_camera::PerspectiveProjection> = { { - let output: Val<::bevy_camera::PerspectiveProjection> = <::bevy_camera::PerspectiveProjection as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::PerspectiveProjection = <::bevy_camera::PerspectiveProjection as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -629,11 +599,10 @@ pub(crate) fn register_projection_functions(world: &mut World) { |_self: Ref<::bevy_camera::Projection>| { let output: Val<::bevy_camera::Projection> = { { - let output: Val<::bevy_camera::Projection> = <::bevy_camera::Projection as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::Projection = <::bevy_camera::Projection as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -647,10 +616,9 @@ pub(crate) fn register_projection_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_camera::Projection::is_perspective( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -675,11 +643,10 @@ pub(crate) fn register_frustum_functions(world: &mut World) { |_self: Ref<::bevy_camera::primitives::Frustum>| { let output: Val<::bevy_camera::primitives::Frustum> = { { - let output: Val<::bevy_camera::primitives::Frustum> = <::bevy_camera::primitives::Frustum as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::primitives::Frustum = <::bevy_camera::primitives::Frustum as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -692,17 +659,16 @@ pub(crate) fn register_frustum_functions(world: &mut World) { | _self: Ref<::bevy_camera::primitives::Frustum>, aabb: Ref<::bevy_camera::primitives::Aabb>, - world_from_local: Ref<::glam::Affine3A>| + world_from_local: Ref<::bevy_math::Affine3A>| { let output: bool = { { let output: bool = ::bevy_camera::primitives::Frustum::contains_aabb( - &_self, - &aabb, - &world_from_local, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(aabb), + safe_transmute(world_from_local), + ); + safe_transmute(output) } }; output @@ -712,14 +678,13 @@ pub(crate) fn register_frustum_functions(world: &mut World) { ) .register_documented( "from_clip_from_world", - |clip_from_world: Ref<::glam::Mat4>| { + |clip_from_world: Ref<::bevy_math::Mat4>| { let output: Val<::bevy_camera::primitives::Frustum> = { { - let output: Val<::bevy_camera::primitives::Frustum> = ::bevy_camera::primitives::Frustum::from_clip_from_world( - &clip_from_world, - ) - .into(); - output + let output: ::bevy_camera::primitives::Frustum = ::bevy_camera::primitives::Frustum::from_clip_from_world( + safe_transmute(clip_from_world), + ); + safe_transmute(output) } }; output @@ -730,21 +695,20 @@ pub(crate) fn register_frustum_functions(world: &mut World) { .register_documented( "from_clip_from_world_custom_far", | - clip_from_world: Ref<::glam::Mat4>, - view_translation: Ref<::glam::Vec3>, - view_backward: Ref<::glam::Vec3>, + clip_from_world: Ref<::bevy_math::Mat4>, + view_translation: Ref<::bevy_math::Vec3>, + view_backward: Ref<::bevy_math::Vec3>, far: f32| { let output: Val<::bevy_camera::primitives::Frustum> = { { - let output: Val<::bevy_camera::primitives::Frustum> = ::bevy_camera::primitives::Frustum::from_clip_from_world_custom_far( - &clip_from_world, - &view_translation, - &view_backward, - far, - ) - .into(); - output + let output: ::bevy_camera::primitives::Frustum = ::bevy_camera::primitives::Frustum::from_clip_from_world_custom_far( + safe_transmute(clip_from_world), + safe_transmute(view_translation), + safe_transmute(view_backward), + safe_transmute(far), + ); + safe_transmute(output) } }; output @@ -757,21 +721,20 @@ pub(crate) fn register_frustum_functions(world: &mut World) { | _self: Ref<::bevy_camera::primitives::Frustum>, aabb: Ref<::bevy_camera::primitives::Aabb>, - world_from_local: Ref<::glam::Affine3A>, + world_from_local: Ref<::bevy_math::Affine3A>, intersect_near: bool, intersect_far: bool| { let output: bool = { { let output: bool = ::bevy_camera::primitives::Frustum::intersects_obb( - &_self, - &aabb, - &world_from_local, - intersect_near, - intersect_far, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(aabb), + safe_transmute(world_from_local), + safe_transmute(intersect_near), + safe_transmute(intersect_far), + ); + safe_transmute(output) } }; output @@ -800,11 +763,10 @@ pub(crate) fn register_visible_entities_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_camera::visibility::VisibleEntities::clear( - &mut _self, - type_id.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(type_id), + ); + safe_transmute(output) } }; output @@ -818,10 +780,9 @@ pub(crate) fn register_visible_entities_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_camera::visibility::VisibleEntities::clear_all( - &mut _self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -834,11 +795,10 @@ pub(crate) fn register_visible_entities_functions(world: &mut World) { |_self: Ref<::bevy_camera::visibility::VisibleEntities>| { let output: Val<::bevy_camera::visibility::VisibleEntities> = { { - let output: Val<::bevy_camera::visibility::VisibleEntities> = <::bevy_camera::visibility::VisibleEntities as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::visibility::VisibleEntities = <::bevy_camera::visibility::VisibleEntities as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -855,11 +815,10 @@ pub(crate) fn register_visible_entities_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_camera::visibility::VisibleEntities::is_empty( - &_self, - type_id.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(type_id), + ); + safe_transmute(output) } }; output @@ -876,11 +835,10 @@ pub(crate) fn register_visible_entities_functions(world: &mut World) { let output: usize = { { let output: usize = ::bevy_camera::visibility::VisibleEntities::len( - &_self, - type_id.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(type_id), + ); + safe_transmute(output) } }; output @@ -898,12 +856,11 @@ pub(crate) fn register_visible_entities_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_camera::visibility::VisibleEntities::push( - &mut _self, - entity.into_inner(), - type_id.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(entity), + safe_transmute(type_id), + ); + safe_transmute(output) } }; output @@ -925,15 +882,14 @@ pub(crate) fn register_viewport_functions(world: &mut World) { >::new(world) .register_documented( "clamp_to_size", - |mut _self: Mut<::bevy_camera::Viewport>, size: Val<::glam::UVec2>| { + |mut _self: Mut<::bevy_camera::Viewport>, size: Val<::bevy_math::UVec2>| { let output: () = { { let output: () = ::bevy_camera::Viewport::clamp_to_size( - &mut _self, - size.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(size), + ); + safe_transmute(output) } }; output @@ -946,11 +902,10 @@ pub(crate) fn register_viewport_functions(world: &mut World) { |_self: Ref<::bevy_camera::Viewport>| { let output: Val<::bevy_camera::Viewport> = { { - let output: Val<::bevy_camera::Viewport> = <::bevy_camera::Viewport as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::Viewport = <::bevy_camera::Viewport as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -987,11 +942,10 @@ pub(crate) fn register_sub_camera_view_functions(world: &mut World) { |_self: Ref<::bevy_camera::SubCameraView>| { let output: Val<::bevy_camera::SubCameraView> = { { - let output: Val<::bevy_camera::SubCameraView> = <::bevy_camera::SubCameraView as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::SubCameraView = <::bevy_camera::SubCameraView as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1009,9 +963,8 @@ pub(crate) fn register_sub_camera_view_functions(world: &mut World) { { let output: bool = <::bevy_camera::SubCameraView as ::std::cmp::PartialEq< ::bevy_camera::SubCameraView, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1036,11 +989,10 @@ pub(crate) fn register_exposure_functions(world: &mut World) { |_self: Ref<::bevy_camera::Exposure>| { let output: Val<::bevy_camera::Exposure> = { { - let output: Val<::bevy_camera::Exposure> = <::bevy_camera::Exposure as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::Exposure = <::bevy_camera::Exposure as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1053,9 +1005,10 @@ pub(crate) fn register_exposure_functions(world: &mut World) { |_self: Ref<::bevy_camera::Exposure>| { let output: f32 = { { - let output: f32 = ::bevy_camera::Exposure::exposure(&_self) - .into(); - output + let output: f32 = ::bevy_camera::Exposure::exposure( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1080,11 +1033,10 @@ pub(crate) fn register_camera_main_texture_usages_functions(world: &mut World) { |_self: Ref<::bevy_camera::CameraMainTextureUsages>| { let output: Val<::bevy_camera::CameraMainTextureUsages> = { { - let output: Val<::bevy_camera::CameraMainTextureUsages> = <::bevy_camera::CameraMainTextureUsages as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::CameraMainTextureUsages = <::bevy_camera::CameraMainTextureUsages as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1109,11 +1061,10 @@ pub(crate) fn register_render_target_functions(world: &mut World) { |_self: Ref<::bevy_camera::RenderTarget>| { let output: Val<::bevy_camera::RenderTarget> = { { - let output: Val<::bevy_camera::RenderTarget> = <::bevy_camera::RenderTarget as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::RenderTarget = <::bevy_camera::RenderTarget as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1139,10 +1090,9 @@ pub(crate) fn register_image_render_target_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_camera::ImageRenderTarget as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1155,11 +1105,10 @@ pub(crate) fn register_image_render_target_functions(world: &mut World) { |_self: Ref<::bevy_camera::ImageRenderTarget>| { let output: Val<::bevy_camera::ImageRenderTarget> = { { - let output: Val<::bevy_camera::ImageRenderTarget> = <::bevy_camera::ImageRenderTarget as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::ImageRenderTarget = <::bevy_camera::ImageRenderTarget as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1177,9 +1126,8 @@ pub(crate) fn register_image_render_target_functions(world: &mut World) { { let output: bool = <::bevy_camera::ImageRenderTarget as ::std::cmp::PartialEq< ::bevy_camera::ImageRenderTarget, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1205,10 +1153,9 @@ pub(crate) fn register_manual_texture_view_handle_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_camera::ManualTextureViewHandle as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1221,11 +1168,10 @@ pub(crate) fn register_manual_texture_view_handle_functions(world: &mut World) { |_self: Ref<::bevy_camera::ManualTextureViewHandle>| { let output: Val<::bevy_camera::ManualTextureViewHandle> = { { - let output: Val<::bevy_camera::ManualTextureViewHandle> = <::bevy_camera::ManualTextureViewHandle as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::ManualTextureViewHandle = <::bevy_camera::ManualTextureViewHandle as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1243,9 +1189,8 @@ pub(crate) fn register_manual_texture_view_handle_functions(world: &mut World) { { let output: bool = <::bevy_camera::ManualTextureViewHandle as ::std::cmp::PartialEq< ::bevy_camera::ManualTextureViewHandle, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1271,10 +1216,9 @@ pub(crate) fn register_normalized_render_target_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_camera::NormalizedRenderTarget as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1287,11 +1231,10 @@ pub(crate) fn register_normalized_render_target_functions(world: &mut World) { |_self: Ref<::bevy_camera::NormalizedRenderTarget>| { let output: Val<::bevy_camera::NormalizedRenderTarget> = { { - let output: Val<::bevy_camera::NormalizedRenderTarget> = <::bevy_camera::NormalizedRenderTarget as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::NormalizedRenderTarget = <::bevy_camera::NormalizedRenderTarget as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1309,9 +1252,8 @@ pub(crate) fn register_normalized_render_target_functions(world: &mut World) { { let output: bool = <::bevy_camera::NormalizedRenderTarget as ::std::cmp::PartialEq< ::bevy_camera::NormalizedRenderTarget, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1336,11 +1278,10 @@ pub(crate) fn register_camera_3_d_depth_load_op_functions(world: &mut World) { |_self: Ref<::bevy_camera::Camera3dDepthLoadOp>| { let output: Val<::bevy_camera::Camera3dDepthLoadOp> = { { - let output: Val<::bevy_camera::Camera3dDepthLoadOp> = <::bevy_camera::Camera3dDepthLoadOp as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::Camera3dDepthLoadOp = <::bevy_camera::Camera3dDepthLoadOp as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1365,11 +1306,10 @@ pub(crate) fn register_camera_3_d_depth_texture_usage_functions(world: &mut Worl |_self: Ref<::bevy_camera::Camera3dDepthTextureUsage>| { let output: Val<::bevy_camera::Camera3dDepthTextureUsage> = { { - let output: Val<::bevy_camera::Camera3dDepthTextureUsage> = <::bevy_camera::Camera3dDepthTextureUsage as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::Camera3dDepthTextureUsage = <::bevy_camera::Camera3dDepthTextureUsage as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1394,11 +1334,10 @@ pub(crate) fn register_screen_space_transmission_quality_functions(world: &mut W |_self: Ref<::bevy_camera::ScreenSpaceTransmissionQuality>| { let output: Val<::bevy_camera::ScreenSpaceTransmissionQuality> = { { - let output: Val<::bevy_camera::ScreenSpaceTransmissionQuality> = <::bevy_camera::ScreenSpaceTransmissionQuality as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::ScreenSpaceTransmissionQuality = <::bevy_camera::ScreenSpaceTransmissionQuality as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1416,9 +1355,8 @@ pub(crate) fn register_screen_space_transmission_quality_functions(world: &mut W { let output: bool = <::bevy_camera::ScreenSpaceTransmissionQuality as ::std::cmp::PartialEq< ::bevy_camera::ScreenSpaceTransmissionQuality, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1443,11 +1381,10 @@ pub(crate) fn register_aabb_functions(world: &mut World) { |_self: Ref<::bevy_camera::primitives::Aabb>| { let output: Val<::bevy_camera::primitives::Aabb> = { { - let output: Val<::bevy_camera::primitives::Aabb> = <::bevy_camera::primitives::Aabb as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::primitives::Aabb = <::bevy_camera::primitives::Aabb as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1465,9 +1402,8 @@ pub(crate) fn register_aabb_functions(world: &mut World) { { let output: bool = <::bevy_camera::primitives::Aabb as ::std::cmp::PartialEq< ::bevy_camera::primitives::Aabb, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1477,15 +1413,14 @@ pub(crate) fn register_aabb_functions(world: &mut World) { ) .register_documented( "from_min_max", - |minimum: Val<::glam::Vec3>, maximum: Val<::glam::Vec3>| { + |minimum: Val<::bevy_math::Vec3>, maximum: Val<::bevy_math::Vec3>| { let output: Val<::bevy_camera::primitives::Aabb> = { { - let output: Val<::bevy_camera::primitives::Aabb> = ::bevy_camera::primitives::Aabb::from_min_max( - minimum.into_inner(), - maximum.into_inner(), - ) - .into(); - output + let output: ::bevy_camera::primitives::Aabb = ::bevy_camera::primitives::Aabb::from_min_max( + safe_transmute(minimum), + safe_transmute(maximum), + ); + safe_transmute(output) } }; output @@ -1496,13 +1431,12 @@ pub(crate) fn register_aabb_functions(world: &mut World) { .register_documented( "max", |_self: Ref<::bevy_camera::primitives::Aabb>| { - let output: Val<::glam::Vec3A> = { + let output: Val<::bevy_math::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::bevy_camera::primitives::Aabb::max( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec3A = ::bevy_camera::primitives::Aabb::max( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1513,13 +1447,12 @@ pub(crate) fn register_aabb_functions(world: &mut World) { .register_documented( "min", |_self: Ref<::bevy_camera::primitives::Aabb>| { - let output: Val<::glam::Vec3A> = { + let output: Val<::bevy_math::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::bevy_camera::primitives::Aabb::min( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec3A = ::bevy_camera::primitives::Aabb::min( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1531,18 +1464,17 @@ pub(crate) fn register_aabb_functions(world: &mut World) { "relative_radius", | _self: Ref<::bevy_camera::primitives::Aabb>, - p_normal: Ref<::glam::Vec3A>, - world_from_local: Ref<::glam::Mat3A>| + p_normal: Ref<::bevy_math::Vec3A>, + world_from_local: Ref<::bevy_math::Mat3A>| { let output: f32 = { { let output: f32 = ::bevy_camera::primitives::Aabb::relative_radius( - &_self, - &p_normal, - &world_from_local, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(p_normal), + safe_transmute(world_from_local), + ); + safe_transmute(output) } }; output @@ -1567,11 +1499,10 @@ pub(crate) fn register_cubemap_frusta_functions(world: &mut World) { |_self: Ref<::bevy_camera::primitives::CubemapFrusta>| { let output: Val<::bevy_camera::primitives::CubemapFrusta> = { { - let output: Val<::bevy_camera::primitives::CubemapFrusta> = <::bevy_camera::primitives::CubemapFrusta as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::primitives::CubemapFrusta = <::bevy_camera::primitives::CubemapFrusta as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1596,11 +1527,10 @@ pub(crate) fn register_cubemap_layout_functions(world: &mut World) { |_self: Ref<::bevy_camera::primitives::CubemapLayout>| { let output: Val<::bevy_camera::primitives::CubemapLayout> = { { - let output: Val<::bevy_camera::primitives::CubemapLayout> = <::bevy_camera::primitives::CubemapLayout as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::primitives::CubemapLayout = <::bevy_camera::primitives::CubemapLayout as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1625,11 +1555,10 @@ pub(crate) fn register_cascades_frusta_functions(world: &mut World) { |_self: Ref<::bevy_camera::primitives::CascadesFrusta>| { let output: Val<::bevy_camera::primitives::CascadesFrusta> = { { - let output: Val<::bevy_camera::primitives::CascadesFrusta> = <::bevy_camera::primitives::CascadesFrusta as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::primitives::CascadesFrusta = <::bevy_camera::primitives::CascadesFrusta as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1654,11 +1583,10 @@ pub(crate) fn register_custom_projection_functions(world: &mut World) { |_self: Ref<::bevy_camera::CustomProjection>| { let output: Val<::bevy_camera::CustomProjection> = { { - let output: Val<::bevy_camera::CustomProjection> = <::bevy_camera::CustomProjection as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::CustomProjection = <::bevy_camera::CustomProjection as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1683,11 +1611,10 @@ pub(crate) fn register_scaling_mode_functions(world: &mut World) { |_self: Ref<::bevy_camera::ScalingMode>| { let output: Val<::bevy_camera::ScalingMode> = { { - let output: Val<::bevy_camera::ScalingMode> = <::bevy_camera::ScalingMode as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::ScalingMode = <::bevy_camera::ScalingMode as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1712,11 +1639,10 @@ pub(crate) fn register_visibility_class_functions(world: &mut World) { |_self: Ref<::bevy_camera::visibility::VisibilityClass>| { let output: Val<::bevy_camera::visibility::VisibilityClass> = { { - let output: Val<::bevy_camera::visibility::VisibilityClass> = <::bevy_camera::visibility::VisibilityClass as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::visibility::VisibilityClass = <::bevy_camera::visibility::VisibilityClass as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1753,13 +1679,10 @@ pub(crate) fn register_visible_mesh_entities_functions(world: &mut World) { |_self: Ref<::bevy_camera::visibility::VisibleMeshEntities>| { let output: Val<::bevy_camera::visibility::VisibleMeshEntities> = { { - let output: Val< - ::bevy_camera::visibility::VisibleMeshEntities, - > = <::bevy_camera::visibility::VisibleMeshEntities as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::visibility::VisibleMeshEntities = <::bevy_camera::visibility::VisibleMeshEntities as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1784,13 +1707,10 @@ pub(crate) fn register_cubemap_visible_entities_functions(world: &mut World) { |_self: Ref<::bevy_camera::visibility::CubemapVisibleEntities>| { let output: Val<::bevy_camera::visibility::CubemapVisibleEntities> = { { - let output: Val< - ::bevy_camera::visibility::CubemapVisibleEntities, - > = <::bevy_camera::visibility::CubemapVisibleEntities as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::visibility::CubemapVisibleEntities = <::bevy_camera::visibility::CubemapVisibleEntities as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1815,13 +1735,10 @@ pub(crate) fn register_cascades_visible_entities_functions(world: &mut World) { |_self: Ref<::bevy_camera::visibility::CascadesVisibleEntities>| { let output: Val<::bevy_camera::visibility::CascadesVisibleEntities> = { { - let output: Val< - ::bevy_camera::visibility::CascadesVisibleEntities, - > = <::bevy_camera::visibility::CascadesVisibleEntities as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::visibility::CascadesVisibleEntities = <::bevy_camera::visibility::CascadesVisibleEntities as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1847,10 +1764,9 @@ pub(crate) fn register_render_layers_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_camera::visibility::RenderLayers as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1863,11 +1779,10 @@ pub(crate) fn register_render_layers_functions(world: &mut World) { |_self: Ref<::bevy_camera::visibility::RenderLayers>| { let output: Val<::bevy_camera::visibility::RenderLayers> = { { - let output: Val<::bevy_camera::visibility::RenderLayers> = <::bevy_camera::visibility::RenderLayers as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::visibility::RenderLayers = <::bevy_camera::visibility::RenderLayers as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1885,9 +1800,8 @@ pub(crate) fn register_render_layers_functions(world: &mut World) { { let output: bool = <::bevy_camera::visibility::RenderLayers as ::std::cmp::PartialEq< ::bevy_camera::visibility::RenderLayers, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1903,12 +1817,11 @@ pub(crate) fn register_render_layers_functions(world: &mut World) { { let output: Val<::bevy_camera::visibility::RenderLayers> = { { - let output: Val<::bevy_camera::visibility::RenderLayers> = ::bevy_camera::visibility::RenderLayers::intersection( - &_self, - &other, - ) - .into(); - output + let output: ::bevy_camera::visibility::RenderLayers = ::bevy_camera::visibility::RenderLayers::intersection( + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -1925,11 +1838,10 @@ pub(crate) fn register_render_layers_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_camera::visibility::RenderLayers::intersects( - &_self, - &other, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -1942,11 +1854,10 @@ pub(crate) fn register_render_layers_functions(world: &mut World) { |n: usize| { let output: Val<::bevy_camera::visibility::RenderLayers> = { { - let output: Val<::bevy_camera::visibility::RenderLayers> = ::bevy_camera::visibility::RenderLayers::layer( - n, - ) - .into(); - output + let output: ::bevy_camera::visibility::RenderLayers = ::bevy_camera::visibility::RenderLayers::layer( + safe_transmute(n), + ); + safe_transmute(output) } }; output @@ -1959,9 +1870,8 @@ pub(crate) fn register_render_layers_functions(world: &mut World) { || { let output: Val<::bevy_camera::visibility::RenderLayers> = { { - let output: Val<::bevy_camera::visibility::RenderLayers> = ::bevy_camera::visibility::RenderLayers::none() - .into(); - output + let output: ::bevy_camera::visibility::RenderLayers = ::bevy_camera::visibility::RenderLayers::none(); + safe_transmute(output) } }; output @@ -1977,12 +1887,11 @@ pub(crate) fn register_render_layers_functions(world: &mut World) { { let output: Val<::bevy_camera::visibility::RenderLayers> = { { - let output: Val<::bevy_camera::visibility::RenderLayers> = ::bevy_camera::visibility::RenderLayers::symmetric_difference( - &_self, - &other, - ) - .into(); - output + let output: ::bevy_camera::visibility::RenderLayers = ::bevy_camera::visibility::RenderLayers::symmetric_difference( + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -1998,12 +1907,11 @@ pub(crate) fn register_render_layers_functions(world: &mut World) { { let output: Val<::bevy_camera::visibility::RenderLayers> = { { - let output: Val<::bevy_camera::visibility::RenderLayers> = ::bevy_camera::visibility::RenderLayers::union( - &_self, - &other, - ) - .into(); - output + let output: ::bevy_camera::visibility::RenderLayers = ::bevy_camera::visibility::RenderLayers::union( + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -2016,12 +1924,11 @@ pub(crate) fn register_render_layers_functions(world: &mut World) { |_self: Val<::bevy_camera::visibility::RenderLayers>, layer: usize| { let output: Val<::bevy_camera::visibility::RenderLayers> = { { - let output: Val<::bevy_camera::visibility::RenderLayers> = ::bevy_camera::visibility::RenderLayers::with( - _self.into_inner(), - layer, - ) - .into(); - output + let output: ::bevy_camera::visibility::RenderLayers = ::bevy_camera::visibility::RenderLayers::with( + safe_transmute(_self), + safe_transmute(layer), + ); + safe_transmute(output) } }; output @@ -2034,12 +1941,11 @@ pub(crate) fn register_render_layers_functions(world: &mut World) { |_self: Val<::bevy_camera::visibility::RenderLayers>, layer: usize| { let output: Val<::bevy_camera::visibility::RenderLayers> = { { - let output: Val<::bevy_camera::visibility::RenderLayers> = ::bevy_camera::visibility::RenderLayers::without( - _self.into_inner(), - layer, - ) - .into(); - output + let output: ::bevy_camera::visibility::RenderLayers = ::bevy_camera::visibility::RenderLayers::without( + safe_transmute(_self), + safe_transmute(layer), + ); + safe_transmute(output) } }; output @@ -2064,12 +1970,11 @@ pub(crate) fn register_visibility_range_functions(world: &mut World) { |start: f32, end: f32| { let output: Val<::bevy_camera::visibility::VisibilityRange> = { { - let output: Val<::bevy_camera::visibility::VisibilityRange> = ::bevy_camera::visibility::VisibilityRange::abrupt( - start, - end, - ) - .into(); - output + let output: ::bevy_camera::visibility::VisibilityRange = ::bevy_camera::visibility::VisibilityRange::abrupt( + safe_transmute(start), + safe_transmute(end), + ); + safe_transmute(output) } }; output @@ -2082,11 +1987,10 @@ pub(crate) fn register_visibility_range_functions(world: &mut World) { |_self: Ref<::bevy_camera::visibility::VisibilityRange>| { let output: Val<::bevy_camera::visibility::VisibilityRange> = { { - let output: Val<::bevy_camera::visibility::VisibilityRange> = <::bevy_camera::visibility::VisibilityRange as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_camera::visibility::VisibilityRange = <::bevy_camera::visibility::VisibilityRange as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2104,9 +2008,8 @@ pub(crate) fn register_visibility_range_functions(world: &mut World) { { let output: bool = <::bevy_camera::visibility::VisibilityRange as ::std::cmp::PartialEq< ::bevy_camera::visibility::VisibilityRange, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2120,10 +2023,9 @@ pub(crate) fn register_visibility_range_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_camera::visibility::VisibilityRange::is_abrupt( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2140,11 +2042,10 @@ pub(crate) fn register_visibility_range_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_camera::visibility::VisibilityRange::is_culled( - &_self, - camera_distance, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(camera_distance), + ); + safe_transmute(output) } }; output @@ -2161,11 +2062,10 @@ pub(crate) fn register_visibility_range_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_camera::visibility::VisibilityRange::is_visible_at_all( - &_self, - camera_distance, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(camera_distance), + ); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_color_bms_bindings/src/lib.rs b/crates/bindings/bevy_color_bms_bindings/src/lib.rs index 7d513da6ea..af91f7ca28 100644 --- a/crates/bindings/bevy_color_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_color_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -24,11 +24,10 @@ pub(crate) fn register_color_functions(world: &mut World) { |_self: Ref<::bevy_color::Color>| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = <::bevy_color::Color as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_color::Color = <::bevy_color::Color as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -43,9 +42,8 @@ pub(crate) fn register_color_functions(world: &mut World) { { let output: bool = <::bevy_color::Color as ::core::cmp::PartialEq< ::bevy_color::Color, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -58,13 +56,12 @@ pub(crate) fn register_color_functions(world: &mut World) { |hue: f32, saturation: f32, lightness: f32| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = ::bevy_color::Color::hsl( - hue, - saturation, - lightness, - ) - .into(); - output + let output: ::bevy_color::Color = ::bevy_color::Color::hsl( + safe_transmute(hue), + safe_transmute(saturation), + safe_transmute(lightness), + ); + safe_transmute(output) } }; output @@ -77,14 +74,13 @@ pub(crate) fn register_color_functions(world: &mut World) { |hue: f32, saturation: f32, lightness: f32, alpha: f32| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = ::bevy_color::Color::hsla( - hue, - saturation, - lightness, - alpha, - ) - .into(); - output + let output: ::bevy_color::Color = ::bevy_color::Color::hsla( + safe_transmute(hue), + safe_transmute(saturation), + safe_transmute(lightness), + safe_transmute(alpha), + ); + safe_transmute(output) } }; output @@ -97,13 +93,12 @@ pub(crate) fn register_color_functions(world: &mut World) { |hue: f32, saturation: f32, value: f32| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = ::bevy_color::Color::hsv( - hue, - saturation, - value, - ) - .into(); - output + let output: ::bevy_color::Color = ::bevy_color::Color::hsv( + safe_transmute(hue), + safe_transmute(saturation), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -116,14 +111,13 @@ pub(crate) fn register_color_functions(world: &mut World) { |hue: f32, saturation: f32, value: f32, alpha: f32| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = ::bevy_color::Color::hsva( - hue, - saturation, - value, - alpha, - ) - .into(); - output + let output: ::bevy_color::Color = ::bevy_color::Color::hsva( + safe_transmute(hue), + safe_transmute(saturation), + safe_transmute(value), + safe_transmute(alpha), + ); + safe_transmute(output) } }; output @@ -136,13 +130,12 @@ pub(crate) fn register_color_functions(world: &mut World) { |hue: f32, whiteness: f32, blackness: f32| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = ::bevy_color::Color::hwb( - hue, - whiteness, - blackness, - ) - .into(); - output + let output: ::bevy_color::Color = ::bevy_color::Color::hwb( + safe_transmute(hue), + safe_transmute(whiteness), + safe_transmute(blackness), + ); + safe_transmute(output) } }; output @@ -155,14 +148,13 @@ pub(crate) fn register_color_functions(world: &mut World) { |hue: f32, whiteness: f32, blackness: f32, alpha: f32| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = ::bevy_color::Color::hwba( - hue, - whiteness, - blackness, - alpha, - ) - .into(); - output + let output: ::bevy_color::Color = ::bevy_color::Color::hwba( + safe_transmute(hue), + safe_transmute(whiteness), + safe_transmute(blackness), + safe_transmute(alpha), + ); + safe_transmute(output) } }; output @@ -175,13 +167,12 @@ pub(crate) fn register_color_functions(world: &mut World) { |lightness: f32, a: f32, b: f32| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = ::bevy_color::Color::lab( - lightness, - a, - b, - ) - .into(); - output + let output: ::bevy_color::Color = ::bevy_color::Color::lab( + safe_transmute(lightness), + safe_transmute(a), + safe_transmute(b), + ); + safe_transmute(output) } }; output @@ -194,14 +185,13 @@ pub(crate) fn register_color_functions(world: &mut World) { |lightness: f32, a: f32, b: f32, alpha: f32| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = ::bevy_color::Color::laba( - lightness, - a, - b, - alpha, - ) - .into(); - output + let output: ::bevy_color::Color = ::bevy_color::Color::laba( + safe_transmute(lightness), + safe_transmute(a), + safe_transmute(b), + safe_transmute(alpha), + ); + safe_transmute(output) } }; output @@ -214,13 +204,12 @@ pub(crate) fn register_color_functions(world: &mut World) { |lightness: f32, chroma: f32, hue: f32| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = ::bevy_color::Color::lch( - lightness, - chroma, - hue, - ) - .into(); - output + let output: ::bevy_color::Color = ::bevy_color::Color::lch( + safe_transmute(lightness), + safe_transmute(chroma), + safe_transmute(hue), + ); + safe_transmute(output) } }; output @@ -233,14 +222,13 @@ pub(crate) fn register_color_functions(world: &mut World) { |lightness: f32, chroma: f32, hue: f32, alpha: f32| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = ::bevy_color::Color::lcha( - lightness, - chroma, - hue, - alpha, - ) - .into(); - output + let output: ::bevy_color::Color = ::bevy_color::Color::lcha( + safe_transmute(lightness), + safe_transmute(chroma), + safe_transmute(hue), + safe_transmute(alpha), + ); + safe_transmute(output) } }; output @@ -253,13 +241,12 @@ pub(crate) fn register_color_functions(world: &mut World) { |red: f32, green: f32, blue: f32| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = ::bevy_color::Color::linear_rgb( - red, - green, - blue, - ) - .into(); - output + let output: ::bevy_color::Color = ::bevy_color::Color::linear_rgb( + safe_transmute(red), + safe_transmute(green), + safe_transmute(blue), + ); + safe_transmute(output) } }; output @@ -272,14 +259,13 @@ pub(crate) fn register_color_functions(world: &mut World) { |red: f32, green: f32, blue: f32, alpha: f32| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = ::bevy_color::Color::linear_rgba( - red, - green, - blue, - alpha, - ) - .into(); - output + let output: ::bevy_color::Color = ::bevy_color::Color::linear_rgba( + safe_transmute(red), + safe_transmute(green), + safe_transmute(blue), + safe_transmute(alpha), + ); + safe_transmute(output) } }; output @@ -292,13 +278,12 @@ pub(crate) fn register_color_functions(world: &mut World) { |lightness: f32, a: f32, b: f32| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = ::bevy_color::Color::oklab( - lightness, - a, - b, - ) - .into(); - output + let output: ::bevy_color::Color = ::bevy_color::Color::oklab( + safe_transmute(lightness), + safe_transmute(a), + safe_transmute(b), + ); + safe_transmute(output) } }; output @@ -311,14 +296,13 @@ pub(crate) fn register_color_functions(world: &mut World) { |lightness: f32, a: f32, b: f32, alpha: f32| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = ::bevy_color::Color::oklaba( - lightness, - a, - b, - alpha, - ) - .into(); - output + let output: ::bevy_color::Color = ::bevy_color::Color::oklaba( + safe_transmute(lightness), + safe_transmute(a), + safe_transmute(b), + safe_transmute(alpha), + ); + safe_transmute(output) } }; output @@ -331,13 +315,12 @@ pub(crate) fn register_color_functions(world: &mut World) { |lightness: f32, chroma: f32, hue: f32| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = ::bevy_color::Color::oklch( - lightness, - chroma, - hue, - ) - .into(); - output + let output: ::bevy_color::Color = ::bevy_color::Color::oklch( + safe_transmute(lightness), + safe_transmute(chroma), + safe_transmute(hue), + ); + safe_transmute(output) } }; output @@ -350,14 +333,13 @@ pub(crate) fn register_color_functions(world: &mut World) { |lightness: f32, chroma: f32, hue: f32, alpha: f32| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = ::bevy_color::Color::oklcha( - lightness, - chroma, - hue, - alpha, - ) - .into(); - output + let output: ::bevy_color::Color = ::bevy_color::Color::oklcha( + safe_transmute(lightness), + safe_transmute(chroma), + safe_transmute(hue), + safe_transmute(alpha), + ); + safe_transmute(output) } }; output @@ -370,13 +352,12 @@ pub(crate) fn register_color_functions(world: &mut World) { |red: f32, green: f32, blue: f32| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = ::bevy_color::Color::srgb( - red, - green, - blue, - ) - .into(); - output + let output: ::bevy_color::Color = ::bevy_color::Color::srgb( + safe_transmute(red), + safe_transmute(green), + safe_transmute(blue), + ); + safe_transmute(output) } }; output @@ -389,11 +370,10 @@ pub(crate) fn register_color_functions(world: &mut World) { |array: [f32; 3]| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = ::bevy_color::Color::srgb_from_array( - array, - ) - .into(); - output + let output: ::bevy_color::Color = ::bevy_color::Color::srgb_from_array( + safe_transmute(array), + ); + safe_transmute(output) } }; output @@ -406,13 +386,12 @@ pub(crate) fn register_color_functions(world: &mut World) { |red: u8, green: u8, blue: u8| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = ::bevy_color::Color::srgb_u8( - red, - green, - blue, - ) - .into(); - output + let output: ::bevy_color::Color = ::bevy_color::Color::srgb_u8( + safe_transmute(red), + safe_transmute(green), + safe_transmute(blue), + ); + safe_transmute(output) } }; output @@ -425,14 +404,13 @@ pub(crate) fn register_color_functions(world: &mut World) { |red: f32, green: f32, blue: f32, alpha: f32| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = ::bevy_color::Color::srgba( - red, - green, - blue, - alpha, - ) - .into(); - output + let output: ::bevy_color::Color = ::bevy_color::Color::srgba( + safe_transmute(red), + safe_transmute(green), + safe_transmute(blue), + safe_transmute(alpha), + ); + safe_transmute(output) } }; output @@ -445,14 +423,13 @@ pub(crate) fn register_color_functions(world: &mut World) { |red: u8, green: u8, blue: u8, alpha: u8| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = ::bevy_color::Color::srgba_u8( - red, - green, - blue, - alpha, - ) - .into(); - output + let output: ::bevy_color::Color = ::bevy_color::Color::srgba_u8( + safe_transmute(red), + safe_transmute(green), + safe_transmute(blue), + safe_transmute(alpha), + ); + safe_transmute(output) } }; output @@ -465,11 +442,10 @@ pub(crate) fn register_color_functions(world: &mut World) { |_self: Ref<::bevy_color::Color>| { let output: Val<::bevy_color::LinearRgba> = { { - let output: Val<::bevy_color::LinearRgba> = ::bevy_color::Color::to_linear( - &_self, - ) - .into(); - output + let output: ::bevy_color::LinearRgba = ::bevy_color::Color::to_linear( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -482,11 +458,10 @@ pub(crate) fn register_color_functions(world: &mut World) { |_self: Ref<::bevy_color::Color>| { let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::Srgba> = ::bevy_color::Color::to_srgba( - &_self, - ) - .into(); - output + let output: ::bevy_color::Srgba = ::bevy_color::Color::to_srgba( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -499,13 +474,12 @@ pub(crate) fn register_color_functions(world: &mut World) { |x: f32, y: f32, z: f32| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = ::bevy_color::Color::xyz( - x, - y, - z, - ) - .into(); - output + let output: ::bevy_color::Color = ::bevy_color::Color::xyz( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -518,14 +492,13 @@ pub(crate) fn register_color_functions(world: &mut World) { |x: f32, y: f32, z: f32, alpha: f32| { let output: Val<::bevy_color::Color> = { { - let output: Val<::bevy_color::Color> = ::bevy_color::Color::xyza( - x, - y, - z, - alpha, - ) - .into(); - output + let output: ::bevy_color::Color = ::bevy_color::Color::xyza( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + safe_transmute(alpha), + ); + safe_transmute(output) } }; output @@ -550,11 +523,10 @@ pub(crate) fn register_srgba_functions(world: &mut World) { |_self: Val<::bevy_color::Srgba>, rhs: Val<::bevy_color::Srgba>| { let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::Srgba> = <::bevy_color::Srgba as ::core::ops::Add< + let output: ::bevy_color::Srgba = <::bevy_color::Srgba as ::core::ops::Add< ::bevy_color::Srgba, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -567,11 +539,10 @@ pub(crate) fn register_srgba_functions(world: &mut World) { |_self: Ref<::bevy_color::Srgba>| { let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::Srgba> = <::bevy_color::Srgba as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_color::Srgba = <::bevy_color::Srgba as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -584,11 +555,10 @@ pub(crate) fn register_srgba_functions(world: &mut World) { |_self: Val<::bevy_color::Srgba>, rhs: f32| { let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::Srgba> = <::bevy_color::Srgba as ::core::ops::Div< + let output: ::bevy_color::Srgba = <::bevy_color::Srgba as ::core::ops::Div< f32, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -603,9 +573,8 @@ pub(crate) fn register_srgba_functions(world: &mut World) { { let output: bool = <::bevy_color::Srgba as ::core::cmp::PartialEq< ::bevy_color::Srgba, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -618,9 +587,10 @@ pub(crate) fn register_srgba_functions(world: &mut World) { |value: f32| { let output: f32 = { { - let output: f32 = ::bevy_color::Srgba::gamma_function(value) - .into(); - output + let output: f32 = ::bevy_color::Srgba::gamma_function( + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -634,10 +604,9 @@ pub(crate) fn register_srgba_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_color::Srgba::gamma_function_inverse( - value, - ) - .into(); - output + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -650,11 +619,10 @@ pub(crate) fn register_srgba_functions(world: &mut World) { |_self: Val<::bevy_color::Srgba>, rhs: f32| { let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::Srgba> = <::bevy_color::Srgba as ::core::ops::Mul< + let output: ::bevy_color::Srgba = <::bevy_color::Srgba as ::core::ops::Mul< f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -667,11 +635,10 @@ pub(crate) fn register_srgba_functions(world: &mut World) { |_self: Val<::bevy_color::Srgba>| { let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::Srgba> = <::bevy_color::Srgba as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_color::Srgba = <::bevy_color::Srgba as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -684,14 +651,13 @@ pub(crate) fn register_srgba_functions(world: &mut World) { |red: f32, green: f32, blue: f32, alpha: f32| { let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::Srgba> = ::bevy_color::Srgba::new( - red, - green, - blue, - alpha, - ) - .into(); - output + let output: ::bevy_color::Srgba = ::bevy_color::Srgba::new( + safe_transmute(red), + safe_transmute(green), + safe_transmute(blue), + safe_transmute(alpha), + ); + safe_transmute(output) } }; output @@ -704,13 +670,12 @@ pub(crate) fn register_srgba_functions(world: &mut World) { |red: f32, green: f32, blue: f32| { let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::Srgba> = ::bevy_color::Srgba::rgb( - red, - green, - blue, - ) - .into(); - output + let output: ::bevy_color::Srgba = ::bevy_color::Srgba::rgb( + safe_transmute(red), + safe_transmute(green), + safe_transmute(blue), + ); + safe_transmute(output) } }; output @@ -723,13 +688,12 @@ pub(crate) fn register_srgba_functions(world: &mut World) { |r: u8, g: u8, b: u8| { let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::Srgba> = ::bevy_color::Srgba::rgb_u8( - r, - g, - b, - ) - .into(); - output + let output: ::bevy_color::Srgba = ::bevy_color::Srgba::rgb_u8( + safe_transmute(r), + safe_transmute(g), + safe_transmute(b), + ); + safe_transmute(output) } }; output @@ -742,14 +706,13 @@ pub(crate) fn register_srgba_functions(world: &mut World) { |r: u8, g: u8, b: u8, a: u8| { let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::Srgba> = ::bevy_color::Srgba::rgba_u8( - r, - g, - b, - a, - ) - .into(); - output + let output: ::bevy_color::Srgba = ::bevy_color::Srgba::rgba_u8( + safe_transmute(r), + safe_transmute(g), + safe_transmute(b), + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -762,11 +725,10 @@ pub(crate) fn register_srgba_functions(world: &mut World) { |_self: Val<::bevy_color::Srgba>, rhs: Val<::bevy_color::Srgba>| { let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::Srgba> = <::bevy_color::Srgba as ::core::ops::Sub< + let output: ::bevy_color::Srgba = <::bevy_color::Srgba as ::core::ops::Sub< ::bevy_color::Srgba, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -780,10 +742,9 @@ pub(crate) fn register_srgba_functions(world: &mut World) { let output: ::std::string::String = { { let output: ::std::string::String = ::bevy_color::Srgba::to_hex( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -796,12 +757,11 @@ pub(crate) fn register_srgba_functions(world: &mut World) { |_self: Val<::bevy_color::Srgba>, blue: f32| { let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::Srgba> = ::bevy_color::Srgba::with_blue( - _self.into_inner(), - blue, - ) - .into(); - output + let output: ::bevy_color::Srgba = ::bevy_color::Srgba::with_blue( + safe_transmute(_self), + safe_transmute(blue), + ); + safe_transmute(output) } }; output @@ -814,12 +774,11 @@ pub(crate) fn register_srgba_functions(world: &mut World) { |_self: Val<::bevy_color::Srgba>, green: f32| { let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::Srgba> = ::bevy_color::Srgba::with_green( - _self.into_inner(), - green, - ) - .into(); - output + let output: ::bevy_color::Srgba = ::bevy_color::Srgba::with_green( + safe_transmute(_self), + safe_transmute(green), + ); + safe_transmute(output) } }; output @@ -832,12 +791,11 @@ pub(crate) fn register_srgba_functions(world: &mut World) { |_self: Val<::bevy_color::Srgba>, red: f32| { let output: Val<::bevy_color::Srgba> = { { - let output: Val<::bevy_color::Srgba> = ::bevy_color::Srgba::with_red( - _self.into_inner(), - red, - ) - .into(); - output + let output: ::bevy_color::Srgba = ::bevy_color::Srgba::with_red( + safe_transmute(_self), + safe_transmute(red), + ); + safe_transmute(output) } }; output @@ -862,11 +820,10 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { |_self: Val<::bevy_color::LinearRgba>, rhs: Val<::bevy_color::LinearRgba>| { let output: Val<::bevy_color::LinearRgba> = { { - let output: Val<::bevy_color::LinearRgba> = <::bevy_color::LinearRgba as ::core::ops::Add< + let output: ::bevy_color::LinearRgba = <::bevy_color::LinearRgba as ::core::ops::Add< ::bevy_color::LinearRgba, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -879,9 +836,10 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { |_self: Ref<::bevy_color::LinearRgba>| { let output: u32 = { { - let output: u32 = ::bevy_color::LinearRgba::as_u32(&_self) - .into(); - output + let output: u32 = ::bevy_color::LinearRgba::as_u32( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -894,11 +852,10 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { |_self: Ref<::bevy_color::LinearRgba>| { let output: Val<::bevy_color::LinearRgba> = { { - let output: Val<::bevy_color::LinearRgba> = <::bevy_color::LinearRgba as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_color::LinearRgba = <::bevy_color::LinearRgba as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -911,11 +868,10 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { |_self: Val<::bevy_color::LinearRgba>, rhs: f32| { let output: Val<::bevy_color::LinearRgba> = { { - let output: Val<::bevy_color::LinearRgba> = <::bevy_color::LinearRgba as ::core::ops::Div< + let output: ::bevy_color::LinearRgba = <::bevy_color::LinearRgba as ::core::ops::Div< f32, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -930,9 +886,8 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { { let output: bool = <::bevy_color::LinearRgba as ::core::cmp::PartialEq< ::bevy_color::LinearRgba, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -945,11 +900,10 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { |_self: Val<::bevy_color::LinearRgba>, rhs: f32| { let output: Val<::bevy_color::LinearRgba> = { { - let output: Val<::bevy_color::LinearRgba> = <::bevy_color::LinearRgba as ::core::ops::Mul< + let output: ::bevy_color::LinearRgba = <::bevy_color::LinearRgba as ::core::ops::Mul< f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -962,11 +916,10 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { |_self: Val<::bevy_color::LinearRgba>| { let output: Val<::bevy_color::LinearRgba> = { { - let output: Val<::bevy_color::LinearRgba> = <::bevy_color::LinearRgba as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_color::LinearRgba = <::bevy_color::LinearRgba as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -979,14 +932,13 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { |red: f32, green: f32, blue: f32, alpha: f32| { let output: Val<::bevy_color::LinearRgba> = { { - let output: Val<::bevy_color::LinearRgba> = ::bevy_color::LinearRgba::new( - red, - green, - blue, - alpha, - ) - .into(); - output + let output: ::bevy_color::LinearRgba = ::bevy_color::LinearRgba::new( + safe_transmute(red), + safe_transmute(green), + safe_transmute(blue), + safe_transmute(alpha), + ); + safe_transmute(output) } }; output @@ -999,13 +951,12 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { |red: f32, green: f32, blue: f32| { let output: Val<::bevy_color::LinearRgba> = { { - let output: Val<::bevy_color::LinearRgba> = ::bevy_color::LinearRgba::rgb( - red, - green, - blue, - ) - .into(); - output + let output: ::bevy_color::LinearRgba = ::bevy_color::LinearRgba::rgb( + safe_transmute(red), + safe_transmute(green), + safe_transmute(blue), + ); + safe_transmute(output) } }; output @@ -1018,11 +969,10 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { |_self: Val<::bevy_color::LinearRgba>, rhs: Val<::bevy_color::LinearRgba>| { let output: Val<::bevy_color::LinearRgba> = { { - let output: Val<::bevy_color::LinearRgba> = <::bevy_color::LinearRgba as ::core::ops::Sub< + let output: ::bevy_color::LinearRgba = <::bevy_color::LinearRgba as ::core::ops::Sub< ::bevy_color::LinearRgba, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -1035,12 +985,11 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { |_self: Val<::bevy_color::LinearRgba>, blue: f32| { let output: Val<::bevy_color::LinearRgba> = { { - let output: Val<::bevy_color::LinearRgba> = ::bevy_color::LinearRgba::with_blue( - _self.into_inner(), - blue, - ) - .into(); - output + let output: ::bevy_color::LinearRgba = ::bevy_color::LinearRgba::with_blue( + safe_transmute(_self), + safe_transmute(blue), + ); + safe_transmute(output) } }; output @@ -1053,12 +1002,11 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { |_self: Val<::bevy_color::LinearRgba>, green: f32| { let output: Val<::bevy_color::LinearRgba> = { { - let output: Val<::bevy_color::LinearRgba> = ::bevy_color::LinearRgba::with_green( - _self.into_inner(), - green, - ) - .into(); - output + let output: ::bevy_color::LinearRgba = ::bevy_color::LinearRgba::with_green( + safe_transmute(_self), + safe_transmute(green), + ); + safe_transmute(output) } }; output @@ -1071,12 +1019,11 @@ pub(crate) fn register_linear_rgba_functions(world: &mut World) { |_self: Val<::bevy_color::LinearRgba>, red: f32| { let output: Val<::bevy_color::LinearRgba> = { { - let output: Val<::bevy_color::LinearRgba> = ::bevy_color::LinearRgba::with_red( - _self.into_inner(), - red, - ) - .into(); - output + let output: ::bevy_color::LinearRgba = ::bevy_color::LinearRgba::with_red( + safe_transmute(_self), + safe_transmute(red), + ); + safe_transmute(output) } }; output @@ -1101,11 +1048,10 @@ pub(crate) fn register_hsla_functions(world: &mut World) { |_self: Ref<::bevy_color::Hsla>| { let output: Val<::bevy_color::Hsla> = { { - let output: Val<::bevy_color::Hsla> = <::bevy_color::Hsla as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_color::Hsla = <::bevy_color::Hsla as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1120,9 +1066,8 @@ pub(crate) fn register_hsla_functions(world: &mut World) { { let output: bool = <::bevy_color::Hsla as ::core::cmp::PartialEq< ::bevy_color::Hsla, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1135,13 +1080,12 @@ pub(crate) fn register_hsla_functions(world: &mut World) { |hue: f32, saturation: f32, lightness: f32| { let output: Val<::bevy_color::Hsla> = { { - let output: Val<::bevy_color::Hsla> = ::bevy_color::Hsla::hsl( - hue, - saturation, - lightness, - ) - .into(); - output + let output: ::bevy_color::Hsla = ::bevy_color::Hsla::hsl( + safe_transmute(hue), + safe_transmute(saturation), + safe_transmute(lightness), + ); + safe_transmute(output) } }; output @@ -1154,14 +1098,13 @@ pub(crate) fn register_hsla_functions(world: &mut World) { |hue: f32, saturation: f32, lightness: f32, alpha: f32| { let output: Val<::bevy_color::Hsla> = { { - let output: Val<::bevy_color::Hsla> = ::bevy_color::Hsla::new( - hue, - saturation, - lightness, - alpha, - ) - .into(); - output + let output: ::bevy_color::Hsla = ::bevy_color::Hsla::new( + safe_transmute(hue), + safe_transmute(saturation), + safe_transmute(lightness), + safe_transmute(alpha), + ); + safe_transmute(output) } }; output @@ -1174,11 +1117,10 @@ pub(crate) fn register_hsla_functions(world: &mut World) { |index: u32| { let output: Val<::bevy_color::Hsla> = { { - let output: Val<::bevy_color::Hsla> = ::bevy_color::Hsla::sequential_dispersed( - index, - ) - .into(); - output + let output: ::bevy_color::Hsla = ::bevy_color::Hsla::sequential_dispersed( + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -1191,12 +1133,11 @@ pub(crate) fn register_hsla_functions(world: &mut World) { |_self: Val<::bevy_color::Hsla>, lightness: f32| { let output: Val<::bevy_color::Hsla> = { { - let output: Val<::bevy_color::Hsla> = ::bevy_color::Hsla::with_lightness( - _self.into_inner(), - lightness, - ) - .into(); - output + let output: ::bevy_color::Hsla = ::bevy_color::Hsla::with_lightness( + safe_transmute(_self), + safe_transmute(lightness), + ); + safe_transmute(output) } }; output @@ -1209,12 +1150,11 @@ pub(crate) fn register_hsla_functions(world: &mut World) { |_self: Val<::bevy_color::Hsla>, saturation: f32| { let output: Val<::bevy_color::Hsla> = { { - let output: Val<::bevy_color::Hsla> = ::bevy_color::Hsla::with_saturation( - _self.into_inner(), - saturation, - ) - .into(); - output + let output: ::bevy_color::Hsla = ::bevy_color::Hsla::with_saturation( + safe_transmute(_self), + safe_transmute(saturation), + ); + safe_transmute(output) } }; output @@ -1239,11 +1179,10 @@ pub(crate) fn register_hsva_functions(world: &mut World) { |_self: Ref<::bevy_color::Hsva>| { let output: Val<::bevy_color::Hsva> = { { - let output: Val<::bevy_color::Hsva> = <::bevy_color::Hsva as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_color::Hsva = <::bevy_color::Hsva as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1258,9 +1197,8 @@ pub(crate) fn register_hsva_functions(world: &mut World) { { let output: bool = <::bevy_color::Hsva as ::core::cmp::PartialEq< ::bevy_color::Hsva, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1273,13 +1211,12 @@ pub(crate) fn register_hsva_functions(world: &mut World) { |hue: f32, saturation: f32, value: f32| { let output: Val<::bevy_color::Hsva> = { { - let output: Val<::bevy_color::Hsva> = ::bevy_color::Hsva::hsv( - hue, - saturation, - value, - ) - .into(); - output + let output: ::bevy_color::Hsva = ::bevy_color::Hsva::hsv( + safe_transmute(hue), + safe_transmute(saturation), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -1292,14 +1229,13 @@ pub(crate) fn register_hsva_functions(world: &mut World) { |hue: f32, saturation: f32, value: f32, alpha: f32| { let output: Val<::bevy_color::Hsva> = { { - let output: Val<::bevy_color::Hsva> = ::bevy_color::Hsva::new( - hue, - saturation, - value, - alpha, - ) - .into(); - output + let output: ::bevy_color::Hsva = ::bevy_color::Hsva::new( + safe_transmute(hue), + safe_transmute(saturation), + safe_transmute(value), + safe_transmute(alpha), + ); + safe_transmute(output) } }; output @@ -1312,12 +1248,11 @@ pub(crate) fn register_hsva_functions(world: &mut World) { |_self: Val<::bevy_color::Hsva>, saturation: f32| { let output: Val<::bevy_color::Hsva> = { { - let output: Val<::bevy_color::Hsva> = ::bevy_color::Hsva::with_saturation( - _self.into_inner(), - saturation, - ) - .into(); - output + let output: ::bevy_color::Hsva = ::bevy_color::Hsva::with_saturation( + safe_transmute(_self), + safe_transmute(saturation), + ); + safe_transmute(output) } }; output @@ -1330,12 +1265,11 @@ pub(crate) fn register_hsva_functions(world: &mut World) { |_self: Val<::bevy_color::Hsva>, value: f32| { let output: Val<::bevy_color::Hsva> = { { - let output: Val<::bevy_color::Hsva> = ::bevy_color::Hsva::with_value( - _self.into_inner(), - value, - ) - .into(); - output + let output: ::bevy_color::Hsva = ::bevy_color::Hsva::with_value( + safe_transmute(_self), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -1360,11 +1294,10 @@ pub(crate) fn register_hwba_functions(world: &mut World) { |_self: Ref<::bevy_color::Hwba>| { let output: Val<::bevy_color::Hwba> = { { - let output: Val<::bevy_color::Hwba> = <::bevy_color::Hwba as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_color::Hwba = <::bevy_color::Hwba as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1379,9 +1312,8 @@ pub(crate) fn register_hwba_functions(world: &mut World) { { let output: bool = <::bevy_color::Hwba as ::core::cmp::PartialEq< ::bevy_color::Hwba, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1394,13 +1326,12 @@ pub(crate) fn register_hwba_functions(world: &mut World) { |hue: f32, whiteness: f32, blackness: f32| { let output: Val<::bevy_color::Hwba> = { { - let output: Val<::bevy_color::Hwba> = ::bevy_color::Hwba::hwb( - hue, - whiteness, - blackness, - ) - .into(); - output + let output: ::bevy_color::Hwba = ::bevy_color::Hwba::hwb( + safe_transmute(hue), + safe_transmute(whiteness), + safe_transmute(blackness), + ); + safe_transmute(output) } }; output @@ -1413,14 +1344,13 @@ pub(crate) fn register_hwba_functions(world: &mut World) { |hue: f32, whiteness: f32, blackness: f32, alpha: f32| { let output: Val<::bevy_color::Hwba> = { { - let output: Val<::bevy_color::Hwba> = ::bevy_color::Hwba::new( - hue, - whiteness, - blackness, - alpha, - ) - .into(); - output + let output: ::bevy_color::Hwba = ::bevy_color::Hwba::new( + safe_transmute(hue), + safe_transmute(whiteness), + safe_transmute(blackness), + safe_transmute(alpha), + ); + safe_transmute(output) } }; output @@ -1433,12 +1363,11 @@ pub(crate) fn register_hwba_functions(world: &mut World) { |_self: Val<::bevy_color::Hwba>, blackness: f32| { let output: Val<::bevy_color::Hwba> = { { - let output: Val<::bevy_color::Hwba> = ::bevy_color::Hwba::with_blackness( - _self.into_inner(), - blackness, - ) - .into(); - output + let output: ::bevy_color::Hwba = ::bevy_color::Hwba::with_blackness( + safe_transmute(_self), + safe_transmute(blackness), + ); + safe_transmute(output) } }; output @@ -1451,12 +1380,11 @@ pub(crate) fn register_hwba_functions(world: &mut World) { |_self: Val<::bevy_color::Hwba>, whiteness: f32| { let output: Val<::bevy_color::Hwba> = { { - let output: Val<::bevy_color::Hwba> = ::bevy_color::Hwba::with_whiteness( - _self.into_inner(), - whiteness, - ) - .into(); - output + let output: ::bevy_color::Hwba = ::bevy_color::Hwba::with_whiteness( + safe_transmute(_self), + safe_transmute(whiteness), + ); + safe_transmute(output) } }; output @@ -1481,11 +1409,10 @@ pub(crate) fn register_laba_functions(world: &mut World) { |_self: Val<::bevy_color::Laba>, rhs: Val<::bevy_color::Laba>| { let output: Val<::bevy_color::Laba> = { { - let output: Val<::bevy_color::Laba> = <::bevy_color::Laba as ::core::ops::Add< + let output: ::bevy_color::Laba = <::bevy_color::Laba as ::core::ops::Add< ::bevy_color::Laba, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -1498,11 +1425,10 @@ pub(crate) fn register_laba_functions(world: &mut World) { |_self: Ref<::bevy_color::Laba>| { let output: Val<::bevy_color::Laba> = { { - let output: Val<::bevy_color::Laba> = <::bevy_color::Laba as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_color::Laba = <::bevy_color::Laba as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1515,11 +1441,10 @@ pub(crate) fn register_laba_functions(world: &mut World) { |_self: Val<::bevy_color::Laba>, rhs: f32| { let output: Val<::bevy_color::Laba> = { { - let output: Val<::bevy_color::Laba> = <::bevy_color::Laba as ::core::ops::Div< + let output: ::bevy_color::Laba = <::bevy_color::Laba as ::core::ops::Div< f32, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -1534,9 +1459,8 @@ pub(crate) fn register_laba_functions(world: &mut World) { { let output: bool = <::bevy_color::Laba as ::core::cmp::PartialEq< ::bevy_color::Laba, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1549,13 +1473,12 @@ pub(crate) fn register_laba_functions(world: &mut World) { |lightness: f32, a: f32, b: f32| { let output: Val<::bevy_color::Laba> = { { - let output: Val<::bevy_color::Laba> = ::bevy_color::Laba::lab( - lightness, - a, - b, - ) - .into(); - output + let output: ::bevy_color::Laba = ::bevy_color::Laba::lab( + safe_transmute(lightness), + safe_transmute(a), + safe_transmute(b), + ); + safe_transmute(output) } }; output @@ -1568,11 +1491,10 @@ pub(crate) fn register_laba_functions(world: &mut World) { |_self: Val<::bevy_color::Laba>, rhs: f32| { let output: Val<::bevy_color::Laba> = { { - let output: Val<::bevy_color::Laba> = <::bevy_color::Laba as ::core::ops::Mul< + let output: ::bevy_color::Laba = <::bevy_color::Laba as ::core::ops::Mul< f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -1585,11 +1507,10 @@ pub(crate) fn register_laba_functions(world: &mut World) { |_self: Val<::bevy_color::Laba>| { let output: Val<::bevy_color::Laba> = { { - let output: Val<::bevy_color::Laba> = <::bevy_color::Laba as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_color::Laba = <::bevy_color::Laba as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1602,14 +1523,13 @@ pub(crate) fn register_laba_functions(world: &mut World) { |lightness: f32, a: f32, b: f32, alpha: f32| { let output: Val<::bevy_color::Laba> = { { - let output: Val<::bevy_color::Laba> = ::bevy_color::Laba::new( - lightness, - a, - b, - alpha, - ) - .into(); - output + let output: ::bevy_color::Laba = ::bevy_color::Laba::new( + safe_transmute(lightness), + safe_transmute(a), + safe_transmute(b), + safe_transmute(alpha), + ); + safe_transmute(output) } }; output @@ -1622,11 +1542,10 @@ pub(crate) fn register_laba_functions(world: &mut World) { |_self: Val<::bevy_color::Laba>, rhs: Val<::bevy_color::Laba>| { let output: Val<::bevy_color::Laba> = { { - let output: Val<::bevy_color::Laba> = <::bevy_color::Laba as ::core::ops::Sub< + let output: ::bevy_color::Laba = <::bevy_color::Laba as ::core::ops::Sub< ::bevy_color::Laba, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -1639,12 +1558,11 @@ pub(crate) fn register_laba_functions(world: &mut World) { |_self: Val<::bevy_color::Laba>, lightness: f32| { let output: Val<::bevy_color::Laba> = { { - let output: Val<::bevy_color::Laba> = ::bevy_color::Laba::with_lightness( - _self.into_inner(), - lightness, - ) - .into(); - output + let output: ::bevy_color::Laba = ::bevy_color::Laba::with_lightness( + safe_transmute(_self), + safe_transmute(lightness), + ); + safe_transmute(output) } }; output @@ -1669,11 +1587,10 @@ pub(crate) fn register_lcha_functions(world: &mut World) { |_self: Ref<::bevy_color::Lcha>| { let output: Val<::bevy_color::Lcha> = { { - let output: Val<::bevy_color::Lcha> = <::bevy_color::Lcha as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_color::Lcha = <::bevy_color::Lcha as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1688,9 +1605,8 @@ pub(crate) fn register_lcha_functions(world: &mut World) { { let output: bool = <::bevy_color::Lcha as ::core::cmp::PartialEq< ::bevy_color::Lcha, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1703,13 +1619,12 @@ pub(crate) fn register_lcha_functions(world: &mut World) { |lightness: f32, chroma: f32, hue: f32| { let output: Val<::bevy_color::Lcha> = { { - let output: Val<::bevy_color::Lcha> = ::bevy_color::Lcha::lch( - lightness, - chroma, - hue, - ) - .into(); - output + let output: ::bevy_color::Lcha = ::bevy_color::Lcha::lch( + safe_transmute(lightness), + safe_transmute(chroma), + safe_transmute(hue), + ); + safe_transmute(output) } }; output @@ -1722,14 +1637,13 @@ pub(crate) fn register_lcha_functions(world: &mut World) { |lightness: f32, chroma: f32, hue: f32, alpha: f32| { let output: Val<::bevy_color::Lcha> = { { - let output: Val<::bevy_color::Lcha> = ::bevy_color::Lcha::new( - lightness, - chroma, - hue, - alpha, - ) - .into(); - output + let output: ::bevy_color::Lcha = ::bevy_color::Lcha::new( + safe_transmute(lightness), + safe_transmute(chroma), + safe_transmute(hue), + safe_transmute(alpha), + ); + safe_transmute(output) } }; output @@ -1742,11 +1656,10 @@ pub(crate) fn register_lcha_functions(world: &mut World) { |index: u32| { let output: Val<::bevy_color::Lcha> = { { - let output: Val<::bevy_color::Lcha> = ::bevy_color::Lcha::sequential_dispersed( - index, - ) - .into(); - output + let output: ::bevy_color::Lcha = ::bevy_color::Lcha::sequential_dispersed( + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -1759,12 +1672,11 @@ pub(crate) fn register_lcha_functions(world: &mut World) { |_self: Val<::bevy_color::Lcha>, chroma: f32| { let output: Val<::bevy_color::Lcha> = { { - let output: Val<::bevy_color::Lcha> = ::bevy_color::Lcha::with_chroma( - _self.into_inner(), - chroma, - ) - .into(); - output + let output: ::bevy_color::Lcha = ::bevy_color::Lcha::with_chroma( + safe_transmute(_self), + safe_transmute(chroma), + ); + safe_transmute(output) } }; output @@ -1777,12 +1689,11 @@ pub(crate) fn register_lcha_functions(world: &mut World) { |_self: Val<::bevy_color::Lcha>, lightness: f32| { let output: Val<::bevy_color::Lcha> = { { - let output: Val<::bevy_color::Lcha> = ::bevy_color::Lcha::with_lightness( - _self.into_inner(), - lightness, - ) - .into(); - output + let output: ::bevy_color::Lcha = ::bevy_color::Lcha::with_lightness( + safe_transmute(_self), + safe_transmute(lightness), + ); + safe_transmute(output) } }; output @@ -1807,11 +1718,10 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { |_self: Val<::bevy_color::Oklaba>, rhs: Val<::bevy_color::Oklaba>| { let output: Val<::bevy_color::Oklaba> = { { - let output: Val<::bevy_color::Oklaba> = <::bevy_color::Oklaba as ::core::ops::Add< + let output: ::bevy_color::Oklaba = <::bevy_color::Oklaba as ::core::ops::Add< ::bevy_color::Oklaba, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -1824,11 +1734,10 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { |_self: Ref<::bevy_color::Oklaba>| { let output: Val<::bevy_color::Oklaba> = { { - let output: Val<::bevy_color::Oklaba> = <::bevy_color::Oklaba as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_color::Oklaba = <::bevy_color::Oklaba as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1841,11 +1750,10 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { |_self: Val<::bevy_color::Oklaba>, rhs: f32| { let output: Val<::bevy_color::Oklaba> = { { - let output: Val<::bevy_color::Oklaba> = <::bevy_color::Oklaba as ::core::ops::Div< + let output: ::bevy_color::Oklaba = <::bevy_color::Oklaba as ::core::ops::Div< f32, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -1860,9 +1768,8 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { { let output: bool = <::bevy_color::Oklaba as ::core::cmp::PartialEq< ::bevy_color::Oklaba, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1875,13 +1782,12 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { |lightness: f32, a: f32, b: f32| { let output: Val<::bevy_color::Oklaba> = { { - let output: Val<::bevy_color::Oklaba> = ::bevy_color::Oklaba::lab( - lightness, - a, - b, - ) - .into(); - output + let output: ::bevy_color::Oklaba = ::bevy_color::Oklaba::lab( + safe_transmute(lightness), + safe_transmute(a), + safe_transmute(b), + ); + safe_transmute(output) } }; output @@ -1894,11 +1800,10 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { |_self: Val<::bevy_color::Oklaba>, rhs: f32| { let output: Val<::bevy_color::Oklaba> = { { - let output: Val<::bevy_color::Oklaba> = <::bevy_color::Oklaba as ::core::ops::Mul< + let output: ::bevy_color::Oklaba = <::bevy_color::Oklaba as ::core::ops::Mul< f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -1911,11 +1816,10 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { |_self: Val<::bevy_color::Oklaba>| { let output: Val<::bevy_color::Oklaba> = { { - let output: Val<::bevy_color::Oklaba> = <::bevy_color::Oklaba as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_color::Oklaba = <::bevy_color::Oklaba as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1928,14 +1832,13 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { |lightness: f32, a: f32, b: f32, alpha: f32| { let output: Val<::bevy_color::Oklaba> = { { - let output: Val<::bevy_color::Oklaba> = ::bevy_color::Oklaba::new( - lightness, - a, - b, - alpha, - ) - .into(); - output + let output: ::bevy_color::Oklaba = ::bevy_color::Oklaba::new( + safe_transmute(lightness), + safe_transmute(a), + safe_transmute(b), + safe_transmute(alpha), + ); + safe_transmute(output) } }; output @@ -1948,11 +1851,10 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { |_self: Val<::bevy_color::Oklaba>, rhs: Val<::bevy_color::Oklaba>| { let output: Val<::bevy_color::Oklaba> = { { - let output: Val<::bevy_color::Oklaba> = <::bevy_color::Oklaba as ::core::ops::Sub< + let output: ::bevy_color::Oklaba = <::bevy_color::Oklaba as ::core::ops::Sub< ::bevy_color::Oklaba, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -1965,12 +1867,11 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { |_self: Val<::bevy_color::Oklaba>, a: f32| { let output: Val<::bevy_color::Oklaba> = { { - let output: Val<::bevy_color::Oklaba> = ::bevy_color::Oklaba::with_a( - _self.into_inner(), - a, - ) - .into(); - output + let output: ::bevy_color::Oklaba = ::bevy_color::Oklaba::with_a( + safe_transmute(_self), + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -1983,12 +1884,11 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { |_self: Val<::bevy_color::Oklaba>, b: f32| { let output: Val<::bevy_color::Oklaba> = { { - let output: Val<::bevy_color::Oklaba> = ::bevy_color::Oklaba::with_b( - _self.into_inner(), - b, - ) - .into(); - output + let output: ::bevy_color::Oklaba = ::bevy_color::Oklaba::with_b( + safe_transmute(_self), + safe_transmute(b), + ); + safe_transmute(output) } }; output @@ -2001,12 +1901,11 @@ pub(crate) fn register_oklaba_functions(world: &mut World) { |_self: Val<::bevy_color::Oklaba>, lightness: f32| { let output: Val<::bevy_color::Oklaba> = { { - let output: Val<::bevy_color::Oklaba> = ::bevy_color::Oklaba::with_lightness( - _self.into_inner(), - lightness, - ) - .into(); - output + let output: ::bevy_color::Oklaba = ::bevy_color::Oklaba::with_lightness( + safe_transmute(_self), + safe_transmute(lightness), + ); + safe_transmute(output) } }; output @@ -2031,11 +1930,10 @@ pub(crate) fn register_oklcha_functions(world: &mut World) { |_self: Ref<::bevy_color::Oklcha>| { let output: Val<::bevy_color::Oklcha> = { { - let output: Val<::bevy_color::Oklcha> = <::bevy_color::Oklcha as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_color::Oklcha = <::bevy_color::Oklcha as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2050,9 +1948,8 @@ pub(crate) fn register_oklcha_functions(world: &mut World) { { let output: bool = <::bevy_color::Oklcha as ::core::cmp::PartialEq< ::bevy_color::Oklcha, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2065,13 +1962,12 @@ pub(crate) fn register_oklcha_functions(world: &mut World) { |lightness: f32, chroma: f32, hue: f32| { let output: Val<::bevy_color::Oklcha> = { { - let output: Val<::bevy_color::Oklcha> = ::bevy_color::Oklcha::lch( - lightness, - chroma, - hue, - ) - .into(); - output + let output: ::bevy_color::Oklcha = ::bevy_color::Oklcha::lch( + safe_transmute(lightness), + safe_transmute(chroma), + safe_transmute(hue), + ); + safe_transmute(output) } }; output @@ -2084,14 +1980,13 @@ pub(crate) fn register_oklcha_functions(world: &mut World) { |lightness: f32, chroma: f32, hue: f32, alpha: f32| { let output: Val<::bevy_color::Oklcha> = { { - let output: Val<::bevy_color::Oklcha> = ::bevy_color::Oklcha::new( - lightness, - chroma, - hue, - alpha, - ) - .into(); - output + let output: ::bevy_color::Oklcha = ::bevy_color::Oklcha::new( + safe_transmute(lightness), + safe_transmute(chroma), + safe_transmute(hue), + safe_transmute(alpha), + ); + safe_transmute(output) } }; output @@ -2104,11 +1999,10 @@ pub(crate) fn register_oklcha_functions(world: &mut World) { |index: u32| { let output: Val<::bevy_color::Oklcha> = { { - let output: Val<::bevy_color::Oklcha> = ::bevy_color::Oklcha::sequential_dispersed( - index, - ) - .into(); - output + let output: ::bevy_color::Oklcha = ::bevy_color::Oklcha::sequential_dispersed( + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -2121,12 +2015,11 @@ pub(crate) fn register_oklcha_functions(world: &mut World) { |_self: Val<::bevy_color::Oklcha>, chroma: f32| { let output: Val<::bevy_color::Oklcha> = { { - let output: Val<::bevy_color::Oklcha> = ::bevy_color::Oklcha::with_chroma( - _self.into_inner(), - chroma, - ) - .into(); - output + let output: ::bevy_color::Oklcha = ::bevy_color::Oklcha::with_chroma( + safe_transmute(_self), + safe_transmute(chroma), + ); + safe_transmute(output) } }; output @@ -2139,12 +2032,11 @@ pub(crate) fn register_oklcha_functions(world: &mut World) { |_self: Val<::bevy_color::Oklcha>, lightness: f32| { let output: Val<::bevy_color::Oklcha> = { { - let output: Val<::bevy_color::Oklcha> = ::bevy_color::Oklcha::with_lightness( - _self.into_inner(), - lightness, - ) - .into(); - output + let output: ::bevy_color::Oklcha = ::bevy_color::Oklcha::with_lightness( + safe_transmute(_self), + safe_transmute(lightness), + ); + safe_transmute(output) } }; output @@ -2169,11 +2061,10 @@ pub(crate) fn register_xyza_functions(world: &mut World) { |_self: Val<::bevy_color::Xyza>, rhs: Val<::bevy_color::Xyza>| { let output: Val<::bevy_color::Xyza> = { { - let output: Val<::bevy_color::Xyza> = <::bevy_color::Xyza as ::core::ops::Add< + let output: ::bevy_color::Xyza = <::bevy_color::Xyza as ::core::ops::Add< ::bevy_color::Xyza, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -2186,11 +2077,10 @@ pub(crate) fn register_xyza_functions(world: &mut World) { |_self: Ref<::bevy_color::Xyza>| { let output: Val<::bevy_color::Xyza> = { { - let output: Val<::bevy_color::Xyza> = <::bevy_color::Xyza as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_color::Xyza = <::bevy_color::Xyza as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2203,11 +2093,10 @@ pub(crate) fn register_xyza_functions(world: &mut World) { |_self: Val<::bevy_color::Xyza>, rhs: f32| { let output: Val<::bevy_color::Xyza> = { { - let output: Val<::bevy_color::Xyza> = <::bevy_color::Xyza as ::core::ops::Div< + let output: ::bevy_color::Xyza = <::bevy_color::Xyza as ::core::ops::Div< f32, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -2222,9 +2111,8 @@ pub(crate) fn register_xyza_functions(world: &mut World) { { let output: bool = <::bevy_color::Xyza as ::core::cmp::PartialEq< ::bevy_color::Xyza, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2237,11 +2125,10 @@ pub(crate) fn register_xyza_functions(world: &mut World) { |_self: Val<::bevy_color::Xyza>, rhs: f32| { let output: Val<::bevy_color::Xyza> = { { - let output: Val<::bevy_color::Xyza> = <::bevy_color::Xyza as ::core::ops::Mul< + let output: ::bevy_color::Xyza = <::bevy_color::Xyza as ::core::ops::Mul< f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -2254,11 +2141,10 @@ pub(crate) fn register_xyza_functions(world: &mut World) { |_self: Val<::bevy_color::Xyza>| { let output: Val<::bevy_color::Xyza> = { { - let output: Val<::bevy_color::Xyza> = <::bevy_color::Xyza as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_color::Xyza = <::bevy_color::Xyza as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2271,14 +2157,13 @@ pub(crate) fn register_xyza_functions(world: &mut World) { |x: f32, y: f32, z: f32, alpha: f32| { let output: Val<::bevy_color::Xyza> = { { - let output: Val<::bevy_color::Xyza> = ::bevy_color::Xyza::new( - x, - y, - z, - alpha, - ) - .into(); - output + let output: ::bevy_color::Xyza = ::bevy_color::Xyza::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + safe_transmute(alpha), + ); + safe_transmute(output) } }; output @@ -2291,11 +2176,10 @@ pub(crate) fn register_xyza_functions(world: &mut World) { |_self: Val<::bevy_color::Xyza>, rhs: Val<::bevy_color::Xyza>| { let output: Val<::bevy_color::Xyza> = { { - let output: Val<::bevy_color::Xyza> = <::bevy_color::Xyza as ::core::ops::Sub< + let output: ::bevy_color::Xyza = <::bevy_color::Xyza as ::core::ops::Sub< ::bevy_color::Xyza, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -2308,12 +2192,11 @@ pub(crate) fn register_xyza_functions(world: &mut World) { |_self: Val<::bevy_color::Xyza>, x: f32| { let output: Val<::bevy_color::Xyza> = { { - let output: Val<::bevy_color::Xyza> = ::bevy_color::Xyza::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::bevy_color::Xyza = ::bevy_color::Xyza::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -2326,12 +2209,11 @@ pub(crate) fn register_xyza_functions(world: &mut World) { |_self: Val<::bevy_color::Xyza>, y: f32| { let output: Val<::bevy_color::Xyza> = { { - let output: Val<::bevy_color::Xyza> = ::bevy_color::Xyza::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::bevy_color::Xyza = ::bevy_color::Xyza::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -2344,12 +2226,11 @@ pub(crate) fn register_xyza_functions(world: &mut World) { |_self: Val<::bevy_color::Xyza>, z: f32| { let output: Val<::bevy_color::Xyza> = { { - let output: Val<::bevy_color::Xyza> = ::bevy_color::Xyza::with_z( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::bevy_color::Xyza = ::bevy_color::Xyza::with_z( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -2362,13 +2243,12 @@ pub(crate) fn register_xyza_functions(world: &mut World) { |x: f32, y: f32, z: f32| { let output: Val<::bevy_color::Xyza> = { { - let output: Val<::bevy_color::Xyza> = ::bevy_color::Xyza::xyz( - x, - y, - z, - ) - .into(); - output + let output: ::bevy_color::Xyza = ::bevy_color::Xyza::xyz( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + ); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_core_pipeline_bms_bindings/src/lib.rs b/crates/bindings/bevy_core_pipeline_bms_bindings/src/lib.rs index b554da9d4d..a655d790b9 100644 --- a/crates/bindings/bevy_core_pipeline_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_core_pipeline_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -24,11 +24,10 @@ pub(crate) fn register_skybox_functions(world: &mut World) { |_self: Ref<::bevy_core_pipeline::Skybox>| { let output: Val<::bevy_core_pipeline::Skybox> = { { - let output: Val<::bevy_core_pipeline::Skybox> = <::bevy_core_pipeline::Skybox as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_core_pipeline::Skybox = <::bevy_core_pipeline::Skybox as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -54,10 +53,9 @@ pub(crate) fn register_tonemapping_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_core_pipeline::tonemapping::Tonemapping as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -70,13 +68,10 @@ pub(crate) fn register_tonemapping_functions(world: &mut World) { |_self: Ref<::bevy_core_pipeline::tonemapping::Tonemapping>| { let output: Val<::bevy_core_pipeline::tonemapping::Tonemapping> = { { - let output: Val< - ::bevy_core_pipeline::tonemapping::Tonemapping, - > = <::bevy_core_pipeline::tonemapping::Tonemapping as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_core_pipeline::tonemapping::Tonemapping = <::bevy_core_pipeline::tonemapping::Tonemapping as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -94,9 +89,8 @@ pub(crate) fn register_tonemapping_functions(world: &mut World) { { let output: bool = <::bevy_core_pipeline::tonemapping::Tonemapping as ::std::cmp::PartialEq< ::bevy_core_pipeline::tonemapping::Tonemapping, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -110,10 +104,9 @@ pub(crate) fn register_tonemapping_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_core_pipeline::tonemapping::Tonemapping::is_enabled( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -139,10 +132,9 @@ pub(crate) fn register_deband_dither_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_core_pipeline::tonemapping::DebandDither as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -155,13 +147,10 @@ pub(crate) fn register_deband_dither_functions(world: &mut World) { |_self: Ref<::bevy_core_pipeline::tonemapping::DebandDither>| { let output: Val<::bevy_core_pipeline::tonemapping::DebandDither> = { { - let output: Val< - ::bevy_core_pipeline::tonemapping::DebandDither, - > = <::bevy_core_pipeline::tonemapping::DebandDither as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_core_pipeline::tonemapping::DebandDither = <::bevy_core_pipeline::tonemapping::DebandDither as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -179,9 +168,8 @@ pub(crate) fn register_deband_dither_functions(world: &mut World) { { let output: bool = <::bevy_core_pipeline::tonemapping::DebandDither as ::std::cmp::PartialEq< ::bevy_core_pipeline::tonemapping::DebandDither, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -218,11 +206,10 @@ pub(crate) fn register_depth_prepass_functions(world: &mut World) { |_self: Ref<::bevy_core_pipeline::prepass::DepthPrepass>| { let output: Val<::bevy_core_pipeline::prepass::DepthPrepass> = { { - let output: Val<::bevy_core_pipeline::prepass::DepthPrepass> = <::bevy_core_pipeline::prepass::DepthPrepass as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_core_pipeline::prepass::DepthPrepass = <::bevy_core_pipeline::prepass::DepthPrepass as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -247,13 +234,10 @@ pub(crate) fn register_motion_vector_prepass_functions(world: &mut World) { |_self: Ref<::bevy_core_pipeline::prepass::MotionVectorPrepass>| { let output: Val<::bevy_core_pipeline::prepass::MotionVectorPrepass> = { { - let output: Val< - ::bevy_core_pipeline::prepass::MotionVectorPrepass, - > = <::bevy_core_pipeline::prepass::MotionVectorPrepass as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_core_pipeline::prepass::MotionVectorPrepass = <::bevy_core_pipeline::prepass::MotionVectorPrepass as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -278,11 +262,10 @@ pub(crate) fn register_normal_prepass_functions(world: &mut World) { |_self: Ref<::bevy_core_pipeline::prepass::NormalPrepass>| { let output: Val<::bevy_core_pipeline::prepass::NormalPrepass> = { { - let output: Val<::bevy_core_pipeline::prepass::NormalPrepass> = <::bevy_core_pipeline::prepass::NormalPrepass as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_core_pipeline::prepass::NormalPrepass = <::bevy_core_pipeline::prepass::NormalPrepass as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -315,13 +298,10 @@ pub(crate) fn register_order_independent_transparency_settings_functions( ::bevy_core_pipeline::oit::OrderIndependentTransparencySettings, > = { { - let output: Val< - ::bevy_core_pipeline::oit::OrderIndependentTransparencySettings, - > = <::bevy_core_pipeline::oit::OrderIndependentTransparencySettings as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_core_pipeline::oit::OrderIndependentTransparencySettings = <::bevy_core_pipeline::oit::OrderIndependentTransparencySettings as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_ecs_bms_bindings/src/lib.rs b/crates/bindings/bevy_ecs_bms_bindings/src/lib.rs index 54b59c65d9..d0cde7975e 100644 --- a/crates/bindings/bevy_ecs_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_ecs_bms_bindings/src/lib.rs @@ -1,18 +1,16 @@ - #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] - - +use bevy_app::{App, Plugin}; +use bevy_ecs::prelude::*; use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Ref, Mut, Val}, + from::{Mut, Ref, Val}, + glue::safe_transmute, namespace::NamespaceBuilder, }, }; -use bevy_ecs::prelude::*; -use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyEcsScriptingPlugin; pub(crate) fn register_entity_functions(world: &mut World) { @@ -24,11 +22,10 @@ pub(crate) fn register_entity_functions(world: &mut World) { |_self: Ref<::bevy_ecs::entity::Entity>| { let output: Val<::bevy_ecs::entity::Entity> = { { - let output: Val<::bevy_ecs::entity::Entity> = <::bevy_ecs::entity::Entity as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ecs::entity::Entity = <::bevy_ecs::entity::Entity as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -46,9 +43,8 @@ pub(crate) fn register_entity_functions(world: &mut World) { { let output: bool = <::bevy_ecs::entity::Entity as ::core::cmp::PartialEq< ::bevy_ecs::entity::Entity, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -61,11 +57,10 @@ pub(crate) fn register_entity_functions(world: &mut World) { |bits: u64| { let output: Val<::bevy_ecs::entity::Entity> = { { - let output: Val<::bevy_ecs::entity::Entity> = ::bevy_ecs::entity::Entity::from_bits( - bits, - ) - .into(); - output + let output: ::bevy_ecs::entity::Entity = ::bevy_ecs::entity::Entity::from_bits( + safe_transmute(bits), + ); + safe_transmute(output) } }; output @@ -78,11 +73,10 @@ pub(crate) fn register_entity_functions(world: &mut World) { |row: Val<::bevy_ecs::entity::EntityRow>| { let output: Val<::bevy_ecs::entity::Entity> = { { - let output: Val<::bevy_ecs::entity::Entity> = ::bevy_ecs::entity::Entity::from_row( - row.into_inner(), - ) - .into(); - output + let output: ::bevy_ecs::entity::Entity = ::bevy_ecs::entity::Entity::from_row( + safe_transmute(row), + ); + safe_transmute(output) } }; output @@ -98,12 +92,11 @@ pub(crate) fn register_entity_functions(world: &mut World) { { let output: Val<::bevy_ecs::entity::Entity> = { { - let output: Val<::bevy_ecs::entity::Entity> = ::bevy_ecs::entity::Entity::from_row_and_generation( - row.into_inner(), - generation.into_inner(), - ) - .into(); - output + let output: ::bevy_ecs::entity::Entity = ::bevy_ecs::entity::Entity::from_row_and_generation( + safe_transmute(row), + safe_transmute(generation), + ); + safe_transmute(output) } }; output @@ -116,11 +109,10 @@ pub(crate) fn register_entity_functions(world: &mut World) { |_self: Val<::bevy_ecs::entity::Entity>| { let output: Val<::bevy_ecs::entity::EntityGeneration> = { { - let output: Val<::bevy_ecs::entity::EntityGeneration> = ::bevy_ecs::entity::Entity::generation( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_ecs::entity::EntityGeneration = ::bevy_ecs::entity::Entity::generation( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -134,10 +126,9 @@ pub(crate) fn register_entity_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::bevy_ecs::entity::Entity::index( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -150,11 +141,10 @@ pub(crate) fn register_entity_functions(world: &mut World) { |_self: Val<::bevy_ecs::entity::Entity>| { let output: Val<::bevy_ecs::entity::EntityRow> = { { - let output: Val<::bevy_ecs::entity::EntityRow> = ::bevy_ecs::entity::Entity::row( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_ecs::entity::EntityRow = ::bevy_ecs::entity::Entity::row( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -168,10 +158,9 @@ pub(crate) fn register_entity_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::bevy_ecs::entity::Entity::to_bits( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -197,10 +186,9 @@ pub(crate) fn register_child_of_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ecs::hierarchy::ChildOf as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -213,11 +201,10 @@ pub(crate) fn register_child_of_functions(world: &mut World) { |_self: Ref<::bevy_ecs::hierarchy::ChildOf>| { let output: Val<::bevy_ecs::hierarchy::ChildOf> = { { - let output: Val<::bevy_ecs::hierarchy::ChildOf> = <::bevy_ecs::hierarchy::ChildOf as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ecs::hierarchy::ChildOf = <::bevy_ecs::hierarchy::ChildOf as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -235,9 +222,8 @@ pub(crate) fn register_child_of_functions(world: &mut World) { { let output: bool = <::bevy_ecs::hierarchy::ChildOf as ::core::cmp::PartialEq< ::bevy_ecs::hierarchy::ChildOf, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -250,11 +236,10 @@ pub(crate) fn register_child_of_functions(world: &mut World) { |_self: Ref<::bevy_ecs::hierarchy::ChildOf>| { let output: Val<::bevy_ecs::entity::Entity> = { { - let output: Val<::bevy_ecs::entity::Entity> = ::bevy_ecs::hierarchy::ChildOf::parent( - &_self, - ) - .into(); - output + let output: ::bevy_ecs::entity::Entity = ::bevy_ecs::hierarchy::ChildOf::parent( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -280,10 +265,9 @@ pub(crate) fn register_children_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ecs::hierarchy::Children as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -301,9 +285,8 @@ pub(crate) fn register_children_functions(world: &mut World) { { let output: bool = <::bevy_ecs::hierarchy::Children as ::core::cmp::PartialEq< ::bevy_ecs::hierarchy::Children, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -321,12 +304,11 @@ pub(crate) fn register_children_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_ecs::hierarchy::Children::swap( - &mut _self, - a_index, - b_index, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(a_index), + safe_transmute(b_index), + ); + safe_transmute(output) } }; output @@ -351,11 +333,10 @@ pub(crate) fn register_add_functions(world: &mut World) { |_self: Ref<::bevy_ecs::lifecycle::Add>| { let output: Val<::bevy_ecs::lifecycle::Add> = { { - let output: Val<::bevy_ecs::lifecycle::Add> = <::bevy_ecs::lifecycle::Add as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ecs::lifecycle::Add = <::bevy_ecs::lifecycle::Add as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -375,23 +356,23 @@ pub(crate) fn register_despawn_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_ecs::lifecycle::Despawn, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ecs::lifecycle::Despawn>| { - let output: Val<::bevy_ecs::lifecycle::Despawn> = { - { - let output: Val<::bevy_ecs::lifecycle::Despawn> = <::bevy_ecs::lifecycle::Despawn as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_ecs::lifecycle::Despawn>| { + let output: Val<::bevy_ecs::lifecycle::Despawn> = { + { + let output: ::bevy_ecs::lifecycle::Despawn = + <::bevy_ecs::lifecycle::Despawn as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -404,23 +385,23 @@ pub(crate) fn register_insert_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_ecs::lifecycle::Insert, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ecs::lifecycle::Insert>| { - let output: Val<::bevy_ecs::lifecycle::Insert> = { - { - let output: Val<::bevy_ecs::lifecycle::Insert> = <::bevy_ecs::lifecycle::Insert as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_ecs::lifecycle::Insert>| { + let output: Val<::bevy_ecs::lifecycle::Insert> = { + { + let output: ::bevy_ecs::lifecycle::Insert = + <::bevy_ecs::lifecycle::Insert as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -433,23 +414,23 @@ pub(crate) fn register_remove_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_ecs::lifecycle::Remove, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ecs::lifecycle::Remove>| { - let output: Val<::bevy_ecs::lifecycle::Remove> = { - { - let output: Val<::bevy_ecs::lifecycle::Remove> = <::bevy_ecs::lifecycle::Remove as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_ecs::lifecycle::Remove>| { + let output: Val<::bevy_ecs::lifecycle::Remove> = { + { + let output: ::bevy_ecs::lifecycle::Remove = + <::bevy_ecs::lifecycle::Remove as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -462,23 +443,23 @@ pub(crate) fn register_replace_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_ecs::lifecycle::Replace, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ecs::lifecycle::Replace>| { - let output: Val<::bevy_ecs::lifecycle::Replace> = { - { - let output: Val<::bevy_ecs::lifecycle::Replace> = <::bevy_ecs::lifecycle::Replace as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_ecs::lifecycle::Replace>| { + let output: Val<::bevy_ecs::lifecycle::Replace> = { + { + let output: ::bevy_ecs::lifecycle::Replace = + <::bevy_ecs::lifecycle::Replace as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -496,11 +477,10 @@ pub(crate) fn register_name_functions(world: &mut World) { |_self: Ref<::bevy_ecs::name::Name>| { let output: Val<::bevy_ecs::name::Name> = { { - let output: Val<::bevy_ecs::name::Name> = <::bevy_ecs::name::Name as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ecs::name::Name = <::bevy_ecs::name::Name as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -515,9 +495,8 @@ pub(crate) fn register_name_functions(world: &mut World) { { let output: bool = <::bevy_ecs::name::Name as ::core::cmp::PartialEq< ::bevy_ecs::name::Name, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -528,10 +507,8 @@ pub(crate) fn register_name_functions(world: &mut World) { let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::< - ::bevy_ecs::name::Name, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); + .register_type_data::<::bevy_ecs::name::Name, bevy_mod_scripting_bindings::MarkAsGenerated>( + ); } pub(crate) fn register_default_query_filters_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -542,11 +519,8 @@ pub(crate) fn register_default_query_filters_functions(world: &mut World) { || { let output: Val<::bevy_ecs::entity_disabling::DefaultQueryFilters> = { { - let output: Val< - ::bevy_ecs::entity_disabling::DefaultQueryFilters, - > = ::bevy_ecs::entity_disabling::DefaultQueryFilters::empty() - .into(); - output + let output: ::bevy_ecs::entity_disabling::DefaultQueryFilters = ::bevy_ecs::entity_disabling::DefaultQueryFilters::empty(); + safe_transmute(output) } }; output @@ -563,11 +537,10 @@ pub(crate) fn register_default_query_filters_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_ecs::entity_disabling::DefaultQueryFilters::register_disabling_component( - &mut _self, - component_id.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(component_id), + ); + safe_transmute(output) } }; output @@ -593,10 +566,9 @@ pub(crate) fn register_component_id_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ecs::component::ComponentId as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -609,11 +581,10 @@ pub(crate) fn register_component_id_functions(world: &mut World) { |_self: Ref<::bevy_ecs::component::ComponentId>| { let output: Val<::bevy_ecs::component::ComponentId> = { { - let output: Val<::bevy_ecs::component::ComponentId> = <::bevy_ecs::component::ComponentId as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ecs::component::ComponentId = <::bevy_ecs::component::ComponentId as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -631,9 +602,8 @@ pub(crate) fn register_component_id_functions(world: &mut World) { { let output: bool = <::bevy_ecs::component::ComponentId as ::core::cmp::PartialEq< ::bevy_ecs::component::ComponentId, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -647,10 +617,9 @@ pub(crate) fn register_component_id_functions(world: &mut World) { let output: usize = { { let output: usize = ::bevy_ecs::component::ComponentId::index( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -663,11 +632,10 @@ pub(crate) fn register_component_id_functions(world: &mut World) { |index: usize| { let output: Val<::bevy_ecs::component::ComponentId> = { { - let output: Val<::bevy_ecs::component::ComponentId> = ::bevy_ecs::component::ComponentId::new( - index, - ) - .into(); - output + let output: ::bevy_ecs::component::ComponentId = ::bevy_ecs::component::ComponentId::new( + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -693,10 +661,9 @@ pub(crate) fn register_tick_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ecs::component::Tick as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -709,11 +676,10 @@ pub(crate) fn register_tick_functions(world: &mut World) { |_self: Ref<::bevy_ecs::component::Tick>| { let output: Val<::bevy_ecs::component::Tick> = { { - let output: Val<::bevy_ecs::component::Tick> = <::bevy_ecs::component::Tick as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ecs::component::Tick = <::bevy_ecs::component::Tick as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -731,9 +697,8 @@ pub(crate) fn register_tick_functions(world: &mut World) { { let output: bool = <::bevy_ecs::component::Tick as ::core::cmp::PartialEq< ::bevy_ecs::component::Tick, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -747,10 +712,9 @@ pub(crate) fn register_tick_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::bevy_ecs::component::Tick::get( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -768,12 +732,11 @@ pub(crate) fn register_tick_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_ecs::component::Tick::is_newer_than( - _self.into_inner(), - last_run.into_inner(), - this_run.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(last_run), + safe_transmute(this_run), + ); + safe_transmute(output) } }; output @@ -786,11 +749,10 @@ pub(crate) fn register_tick_functions(world: &mut World) { |tick: u32| { let output: Val<::bevy_ecs::component::Tick> = { { - let output: Val<::bevy_ecs::component::Tick> = ::bevy_ecs::component::Tick::new( - tick, - ) - .into(); - output + let output: ::bevy_ecs::component::Tick = ::bevy_ecs::component::Tick::new( + safe_transmute(tick), + ); + safe_transmute(output) } }; output @@ -804,11 +766,10 @@ pub(crate) fn register_tick_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_ecs::component::Tick::set( - &mut _self, - tick, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(tick), + ); + safe_transmute(output) } }; output @@ -833,11 +794,10 @@ pub(crate) fn register_component_ticks_functions(world: &mut World) { |_self: Ref<::bevy_ecs::component::ComponentTicks>| { let output: Val<::bevy_ecs::component::ComponentTicks> = { { - let output: Val<::bevy_ecs::component::ComponentTicks> = <::bevy_ecs::component::ComponentTicks as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ecs::component::ComponentTicks = <::bevy_ecs::component::ComponentTicks as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -855,12 +815,11 @@ pub(crate) fn register_component_ticks_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_ecs::component::ComponentTicks::is_added( - &_self, - last_run.into_inner(), - this_run.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(last_run), + safe_transmute(this_run), + ); + safe_transmute(output) } }; output @@ -878,12 +837,11 @@ pub(crate) fn register_component_ticks_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_ecs::component::ComponentTicks::is_changed( - &_self, - last_run.into_inner(), - this_run.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(last_run), + safe_transmute(this_run), + ); + safe_transmute(output) } }; output @@ -896,11 +854,10 @@ pub(crate) fn register_component_ticks_functions(world: &mut World) { |change_tick: Val<::bevy_ecs::component::Tick>| { let output: Val<::bevy_ecs::component::ComponentTicks> = { { - let output: Val<::bevy_ecs::component::ComponentTicks> = ::bevy_ecs::component::ComponentTicks::new( - change_tick.into_inner(), - ) - .into(); - output + let output: ::bevy_ecs::component::ComponentTicks = ::bevy_ecs::component::ComponentTicks::new( + safe_transmute(change_tick), + ); + safe_transmute(output) } }; output @@ -917,11 +874,10 @@ pub(crate) fn register_component_ticks_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_ecs::component::ComponentTicks::set_changed( - &mut _self, - change_tick.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(change_tick), + ); + safe_transmute(output) } }; output @@ -947,10 +903,9 @@ pub(crate) fn register_entity_hash_set_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ecs::entity::EntityHashSet as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -963,11 +918,10 @@ pub(crate) fn register_entity_hash_set_functions(world: &mut World) { |_self: Ref<::bevy_ecs::entity::EntityHashSet>| { let output: Val<::bevy_ecs::entity::EntityHashSet> = { { - let output: Val<::bevy_ecs::entity::EntityHashSet> = <::bevy_ecs::entity::EntityHashSet as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ecs::entity::EntityHashSet = <::bevy_ecs::entity::EntityHashSet as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -985,9 +939,8 @@ pub(crate) fn register_entity_hash_set_functions(world: &mut World) { { let output: bool = <::bevy_ecs::entity::EntityHashSet as ::core::cmp::PartialEq< ::bevy_ecs::entity::EntityHashSet, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1001,10 +954,9 @@ pub(crate) fn register_entity_hash_set_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_ecs::entity::EntityHashSet::is_empty( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1018,10 +970,9 @@ pub(crate) fn register_entity_hash_set_functions(world: &mut World) { let output: usize = { { let output: usize = ::bevy_ecs::entity::EntityHashSet::len( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1034,9 +985,8 @@ pub(crate) fn register_entity_hash_set_functions(world: &mut World) { || { let output: Val<::bevy_ecs::entity::EntityHashSet> = { { - let output: Val<::bevy_ecs::entity::EntityHashSet> = ::bevy_ecs::entity::EntityHashSet::new() - .into(); - output + let output: ::bevy_ecs::entity::EntityHashSet = ::bevy_ecs::entity::EntityHashSet::new(); + safe_transmute(output) } }; output @@ -1049,11 +999,10 @@ pub(crate) fn register_entity_hash_set_functions(world: &mut World) { |n: usize| { let output: Val<::bevy_ecs::entity::EntityHashSet> = { { - let output: Val<::bevy_ecs::entity::EntityHashSet> = ::bevy_ecs::entity::EntityHashSet::with_capacity( - n, - ) - .into(); - output + let output: ::bevy_ecs::entity::EntityHashSet = ::bevy_ecs::entity::EntityHashSet::with_capacity( + safe_transmute(n), + ); + safe_transmute(output) } }; output @@ -1079,10 +1028,9 @@ pub(crate) fn register_entity_row_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ecs::entity::EntityRow as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1095,11 +1043,10 @@ pub(crate) fn register_entity_row_functions(world: &mut World) { |_self: Ref<::bevy_ecs::entity::EntityRow>| { let output: Val<::bevy_ecs::entity::EntityRow> = { { - let output: Val<::bevy_ecs::entity::EntityRow> = <::bevy_ecs::entity::EntityRow as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ecs::entity::EntityRow = <::bevy_ecs::entity::EntityRow as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1117,9 +1064,8 @@ pub(crate) fn register_entity_row_functions(world: &mut World) { { let output: bool = <::bevy_ecs::entity::EntityRow as ::core::cmp::PartialEq< ::bevy_ecs::entity::EntityRow, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1133,10 +1079,9 @@ pub(crate) fn register_entity_row_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::bevy_ecs::entity::EntityRow::index( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1161,12 +1106,11 @@ pub(crate) fn register_entity_generation_functions(world: &mut World) { |_self: Val<::bevy_ecs::entity::EntityGeneration>, versions: u32| { let output: Val<::bevy_ecs::entity::EntityGeneration> = { { - let output: Val<::bevy_ecs::entity::EntityGeneration> = ::bevy_ecs::entity::EntityGeneration::after_versions( - _self.into_inner(), - versions, - ) - .into(); - output + let output: ::bevy_ecs::entity::EntityGeneration = ::bevy_ecs::entity::EntityGeneration::after_versions( + safe_transmute(_self), + safe_transmute(versions), + ); + safe_transmute(output) } }; output @@ -1180,10 +1124,9 @@ pub(crate) fn register_entity_generation_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ecs::entity::EntityGeneration as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1196,11 +1139,10 @@ pub(crate) fn register_entity_generation_functions(world: &mut World) { |_self: Ref<::bevy_ecs::entity::EntityGeneration>| { let output: Val<::bevy_ecs::entity::EntityGeneration> = { { - let output: Val<::bevy_ecs::entity::EntityGeneration> = <::bevy_ecs::entity::EntityGeneration as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ecs::entity::EntityGeneration = <::bevy_ecs::entity::EntityGeneration as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1218,9 +1160,8 @@ pub(crate) fn register_entity_generation_functions(world: &mut World) { { let output: bool = <::bevy_ecs::entity::EntityGeneration as ::core::cmp::PartialEq< ::bevy_ecs::entity::EntityGeneration, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1233,11 +1174,10 @@ pub(crate) fn register_entity_generation_functions(world: &mut World) { |bits: u32| { let output: Val<::bevy_ecs::entity::EntityGeneration> = { { - let output: Val<::bevy_ecs::entity::EntityGeneration> = ::bevy_ecs::entity::EntityGeneration::from_bits( - bits, - ) - .into(); - output + let output: ::bevy_ecs::entity::EntityGeneration = ::bevy_ecs::entity::EntityGeneration::from_bits( + safe_transmute(bits), + ); + safe_transmute(output) } }; output @@ -1251,10 +1191,9 @@ pub(crate) fn register_entity_generation_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::bevy_ecs::entity::EntityGeneration::to_bits( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1274,23 +1213,23 @@ pub(crate) fn register_entity_hash_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_ecs::entity::EntityHash, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ecs::entity::EntityHash>| { - let output: Val<::bevy_ecs::entity::EntityHash> = { - { - let output: Val<::bevy_ecs::entity::EntityHash> = <::bevy_ecs::entity::EntityHash as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_ecs::entity::EntityHash>| { + let output: Val<::bevy_ecs::entity::EntityHash> = { + { + let output: ::bevy_ecs::entity::EntityHash = + <::bevy_ecs::entity::EntityHash as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1303,23 +1242,23 @@ pub(crate) fn register_disabled_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_ecs::entity_disabling::Disabled, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ecs::entity_disabling::Disabled>| { - let output: Val<::bevy_ecs::entity_disabling::Disabled> = { - { - let output: Val<::bevy_ecs::entity_disabling::Disabled> = <::bevy_ecs::entity_disabling::Disabled as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_ecs::entity_disabling::Disabled>| { + let output: Val<::bevy_ecs::entity_disabling::Disabled> = { + { + let output: ::bevy_ecs::entity_disabling::Disabled = + <::bevy_ecs::entity_disabling::Disabled as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1332,23 +1271,23 @@ pub(crate) fn register_internal_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< ::bevy_ecs::entity_disabling::Internal, >::new(world) - .register_documented( - "clone", - |_self: Ref<::bevy_ecs::entity_disabling::Internal>| { - let output: Val<::bevy_ecs::entity_disabling::Internal> = { - { - let output: Val<::bevy_ecs::entity_disabling::Internal> = <::bevy_ecs::entity_disabling::Internal as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ); + .register_documented( + "clone", + |_self: Ref<::bevy_ecs::entity_disabling::Internal>| { + let output: Val<::bevy_ecs::entity_disabling::Internal> = { + { + let output: ::bevy_ecs::entity_disabling::Internal = + <::bevy_ecs::entity_disabling::Internal as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry @@ -1366,11 +1305,10 @@ pub(crate) fn register_removed_component_entity_functions(world: &mut World) { |_self: Ref<::bevy_ecs::lifecycle::RemovedComponentEntity>| { let output: Val<::bevy_ecs::lifecycle::RemovedComponentEntity> = { { - let output: Val<::bevy_ecs::lifecycle::RemovedComponentEntity> = <::bevy_ecs::lifecycle::RemovedComponentEntity as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ecs::lifecycle::RemovedComponentEntity = <::bevy_ecs::lifecycle::RemovedComponentEntity as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_gizmos_bms_bindings/src/lib.rs b/crates/bindings/bevy_gizmos_bms_bindings/src/lib.rs index b56509a878..4798c42d44 100644 --- a/crates/bindings/bevy_gizmos_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_gizmos_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -24,11 +24,10 @@ pub(crate) fn register_aabb_gizmo_config_group_functions(world: &mut World) { |_self: Ref<::bevy_gizmos::aabb::AabbGizmoConfigGroup>| { let output: Val<::bevy_gizmos::aabb::AabbGizmoConfigGroup> = { { - let output: Val<::bevy_gizmos::aabb::AabbGizmoConfigGroup> = <::bevy_gizmos::aabb::AabbGizmoConfigGroup as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_gizmos::aabb::AabbGizmoConfigGroup = <::bevy_gizmos::aabb::AabbGizmoConfigGroup as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -77,11 +76,10 @@ pub(crate) fn register_gizmo_config_functions(world: &mut World) { |_self: Ref<::bevy_gizmos::config::GizmoConfig>| { let output: Val<::bevy_gizmos::config::GizmoConfig> = { { - let output: Val<::bevy_gizmos::config::GizmoConfig> = <::bevy_gizmos::config::GizmoConfig as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_gizmos::config::GizmoConfig = <::bevy_gizmos::config::GizmoConfig as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -118,11 +116,10 @@ pub(crate) fn register_gizmo_line_config_functions(world: &mut World) { |_self: Ref<::bevy_gizmos::config::GizmoLineConfig>| { let output: Val<::bevy_gizmos::config::GizmoLineConfig> = { { - let output: Val<::bevy_gizmos::config::GizmoLineConfig> = <::bevy_gizmos::config::GizmoLineConfig as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_gizmos::config::GizmoLineConfig = <::bevy_gizmos::config::GizmoLineConfig as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -148,10 +145,9 @@ pub(crate) fn register_gizmo_line_joint_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_gizmos::config::GizmoLineJoint as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -164,11 +160,10 @@ pub(crate) fn register_gizmo_line_joint_functions(world: &mut World) { |_self: Ref<::bevy_gizmos::config::GizmoLineJoint>| { let output: Val<::bevy_gizmos::config::GizmoLineJoint> = { { - let output: Val<::bevy_gizmos::config::GizmoLineJoint> = <::bevy_gizmos::config::GizmoLineJoint as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_gizmos::config::GizmoLineJoint = <::bevy_gizmos::config::GizmoLineJoint as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -186,9 +181,8 @@ pub(crate) fn register_gizmo_line_joint_functions(world: &mut World) { { let output: bool = <::bevy_gizmos::config::GizmoLineJoint as ::std::cmp::PartialEq< ::bevy_gizmos::config::GizmoLineJoint, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -213,11 +207,10 @@ pub(crate) fn register_gizmo_line_style_functions(world: &mut World) { |_self: Ref<::bevy_gizmos::config::GizmoLineStyle>| { let output: Val<::bevy_gizmos::config::GizmoLineStyle> = { { - let output: Val<::bevy_gizmos::config::GizmoLineStyle> = <::bevy_gizmos::config::GizmoLineStyle as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_gizmos::config::GizmoLineStyle = <::bevy_gizmos::config::GizmoLineStyle as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -235,9 +228,8 @@ pub(crate) fn register_gizmo_line_style_functions(world: &mut World) { { let output: bool = <::bevy_gizmos::config::GizmoLineStyle as ::std::cmp::PartialEq< ::bevy_gizmos::config::GizmoLineStyle, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -262,11 +254,10 @@ pub(crate) fn register_gizmo_functions(world: &mut World) { |_self: Ref<::bevy_gizmos::retained::Gizmo>| { let output: Val<::bevy_gizmos::retained::Gizmo> = { { - let output: Val<::bevy_gizmos::retained::Gizmo> = <::bevy_gizmos::retained::Gizmo as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_gizmos::retained::Gizmo = <::bevy_gizmos::retained::Gizmo as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -291,11 +282,10 @@ pub(crate) fn register_light_gizmo_color_functions(world: &mut World) { |_self: Ref<::bevy_gizmos::light::LightGizmoColor>| { let output: Val<::bevy_gizmos::light::LightGizmoColor> = { { - let output: Val<::bevy_gizmos::light::LightGizmoColor> = <::bevy_gizmos::light::LightGizmoColor as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_gizmos::light::LightGizmoColor = <::bevy_gizmos::light::LightGizmoColor as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -320,11 +310,10 @@ pub(crate) fn register_light_gizmo_config_group_functions(world: &mut World) { |_self: Ref<::bevy_gizmos::light::LightGizmoConfigGroup>| { let output: Val<::bevy_gizmos::light::LightGizmoConfigGroup> = { { - let output: Val<::bevy_gizmos::light::LightGizmoConfigGroup> = <::bevy_gizmos::light::LightGizmoConfigGroup as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_gizmos::light::LightGizmoConfigGroup = <::bevy_gizmos::light::LightGizmoConfigGroup as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -361,11 +350,10 @@ pub(crate) fn register_erased_gizmo_config_group_functions(world: &mut World) { |_self: Ref<::bevy_gizmos::config::ErasedGizmoConfigGroup>| { let output: Val<::bevy_gizmos::config::ErasedGizmoConfigGroup> = { { - let output: Val<::bevy_gizmos::config::ErasedGizmoConfigGroup> = <::bevy_gizmos::config::ErasedGizmoConfigGroup as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_gizmos::config::ErasedGizmoConfigGroup = <::bevy_gizmos::config::ErasedGizmoConfigGroup as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_gltf_bms_bindings/src/lib.rs b/crates/bindings/bevy_gltf_bms_bindings/src/lib.rs index 8fa50833ee..79a59b45fe 100644 --- a/crates/bindings/bevy_gltf_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_gltf_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -24,11 +24,10 @@ pub(crate) fn register_gltf_extras_functions(world: &mut World) { |_self: Ref<::bevy_gltf::GltfExtras>| { let output: Val<::bevy_gltf::GltfExtras> = { { - let output: Val<::bevy_gltf::GltfExtras> = <::bevy_gltf::GltfExtras as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_gltf::GltfExtras = <::bevy_gltf::GltfExtras as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -53,11 +52,10 @@ pub(crate) fn register_gltf_scene_extras_functions(world: &mut World) { |_self: Ref<::bevy_gltf::GltfSceneExtras>| { let output: Val<::bevy_gltf::GltfSceneExtras> = { { - let output: Val<::bevy_gltf::GltfSceneExtras> = <::bevy_gltf::GltfSceneExtras as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_gltf::GltfSceneExtras = <::bevy_gltf::GltfSceneExtras as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -82,11 +80,10 @@ pub(crate) fn register_gltf_mesh_extras_functions(world: &mut World) { |_self: Ref<::bevy_gltf::GltfMeshExtras>| { let output: Val<::bevy_gltf::GltfMeshExtras> = { { - let output: Val<::bevy_gltf::GltfMeshExtras> = <::bevy_gltf::GltfMeshExtras as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_gltf::GltfMeshExtras = <::bevy_gltf::GltfMeshExtras as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -111,11 +108,10 @@ pub(crate) fn register_gltf_mesh_name_functions(world: &mut World) { |_self: Ref<::bevy_gltf::GltfMeshName>| { let output: Val<::bevy_gltf::GltfMeshName> = { { - let output: Val<::bevy_gltf::GltfMeshName> = <::bevy_gltf::GltfMeshName as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_gltf::GltfMeshName = <::bevy_gltf::GltfMeshName as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -140,11 +136,10 @@ pub(crate) fn register_gltf_material_extras_functions(world: &mut World) { |_self: Ref<::bevy_gltf::GltfMaterialExtras>| { let output: Val<::bevy_gltf::GltfMaterialExtras> = { { - let output: Val<::bevy_gltf::GltfMaterialExtras> = <::bevy_gltf::GltfMaterialExtras as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_gltf::GltfMaterialExtras = <::bevy_gltf::GltfMaterialExtras as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -169,11 +164,10 @@ pub(crate) fn register_gltf_material_name_functions(world: &mut World) { |_self: Ref<::bevy_gltf::GltfMaterialName>| { let output: Val<::bevy_gltf::GltfMaterialName> = { { - let output: Val<::bevy_gltf::GltfMaterialName> = <::bevy_gltf::GltfMaterialName as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_gltf::GltfMaterialName = <::bevy_gltf::GltfMaterialName as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_image_bms_bindings/src/lib.rs b/crates/bindings/bevy_image_bms_bindings/src/lib.rs index db93a339b6..f5decbe30c 100644 --- a/crates/bindings/bevy_image_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_image_bms_bindings/src/lib.rs @@ -1,18 +1,16 @@ - #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] - - +use bevy_app::{App, Plugin}; +use bevy_ecs::prelude::*; use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Ref, Mut, Val}, + from::{Mut, Ref, Val}, + glue::safe_transmute, namespace::NamespaceBuilder, }, }; -use bevy_ecs::prelude::*; -use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyImageScriptingPlugin; pub(crate) fn register_texture_atlas_functions(world: &mut World) { @@ -25,10 +23,9 @@ pub(crate) fn register_texture_atlas_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_image::TextureAtlas as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41,11 +38,10 @@ pub(crate) fn register_texture_atlas_functions(world: &mut World) { |_self: Ref<::bevy_image::TextureAtlas>| { let output: Val<::bevy_image::TextureAtlas> = { { - let output: Val<::bevy_image::TextureAtlas> = <::bevy_image::TextureAtlas as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_image::TextureAtlas = <::bevy_image::TextureAtlas as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -63,9 +59,8 @@ pub(crate) fn register_texture_atlas_functions(world: &mut World) { { let output: bool = <::bevy_image::TextureAtlas as ::std::cmp::PartialEq< ::bevy_image::TextureAtlas, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -78,12 +73,11 @@ pub(crate) fn register_texture_atlas_functions(world: &mut World) { |_self: Val<::bevy_image::TextureAtlas>, index: usize| { let output: Val<::bevy_image::TextureAtlas> = { { - let output: Val<::bevy_image::TextureAtlas> = ::bevy_image::TextureAtlas::with_index( - _self.into_inner(), - index, - ) - .into(); - output + let output: ::bevy_image::TextureAtlas = ::bevy_image::TextureAtlas::with_index( + safe_transmute(_self), + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -112,11 +106,10 @@ pub(crate) fn register_texture_atlas_layout_functions(world: &mut World) { let output: usize = { { let output: usize = ::bevy_image::TextureAtlasLayout::add_texture( - &mut _self, - rect.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rect), + ); + safe_transmute(output) } }; output @@ -130,10 +123,9 @@ pub(crate) fn register_texture_atlas_layout_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_image::TextureAtlasLayout as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -146,11 +138,10 @@ pub(crate) fn register_texture_atlas_layout_functions(world: &mut World) { |_self: Ref<::bevy_image::TextureAtlasLayout>| { let output: Val<::bevy_image::TextureAtlasLayout> = { { - let output: Val<::bevy_image::TextureAtlasLayout> = <::bevy_image::TextureAtlasLayout as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_image::TextureAtlasLayout = <::bevy_image::TextureAtlasLayout as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -168,9 +159,8 @@ pub(crate) fn register_texture_atlas_layout_functions(world: &mut World) { { let output: bool = <::bevy_image::TextureAtlasLayout as ::std::cmp::PartialEq< ::bevy_image::TextureAtlasLayout, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -184,10 +174,9 @@ pub(crate) fn register_texture_atlas_layout_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_image::TextureAtlasLayout::is_empty( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -200,9 +189,10 @@ pub(crate) fn register_texture_atlas_layout_functions(world: &mut World) { |_self: Ref<::bevy_image::TextureAtlasLayout>| { let output: usize = { { - let output: usize = ::bevy_image::TextureAtlasLayout::len(&_self) - .into(); - output + let output: usize = ::bevy_image::TextureAtlasLayout::len( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -212,14 +202,13 @@ pub(crate) fn register_texture_atlas_layout_functions(world: &mut World) { ) .register_documented( "new_empty", - |dimensions: Val<::glam::UVec2>| { + |dimensions: Val<::bevy_math::UVec2>| { let output: Val<::bevy_image::TextureAtlasLayout> = { { - let output: Val<::bevy_image::TextureAtlasLayout> = ::bevy_image::TextureAtlasLayout::new_empty( - dimensions.into_inner(), - ) - .into(); - output + let output: ::bevy_image::TextureAtlasLayout = ::bevy_image::TextureAtlasLayout::new_empty( + safe_transmute(dimensions), + ); + safe_transmute(output) } }; output @@ -244,11 +233,10 @@ pub(crate) fn register_image_functions(world: &mut World) { |_self: Ref<::bevy_image::Image>| { let output: Val<::bevy_math::AspectRatio> = { { - let output: Val<::bevy_math::AspectRatio> = ::bevy_image::Image::aspect_ratio( - &_self, - ) - .into(); - output + let output: ::bevy_math::AspectRatio = ::bevy_image::Image::aspect_ratio( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -261,11 +249,10 @@ pub(crate) fn register_image_functions(world: &mut World) { |_self: Ref<::bevy_image::Image>| { let output: Val<::bevy_image::Image> = { { - let output: Val<::bevy_image::Image> = <::bevy_image::Image as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_image::Image = <::bevy_image::Image as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -278,9 +265,8 @@ pub(crate) fn register_image_functions(world: &mut World) { || { let output: Val<::bevy_image::Image> = { { - let output: Val<::bevy_image::Image> = ::bevy_image::Image::default_uninit() - .into(); - output + let output: ::bevy_image::Image = ::bevy_image::Image::default_uninit(); + safe_transmute(output) } }; output @@ -295,9 +281,8 @@ pub(crate) fn register_image_functions(world: &mut World) { { let output: bool = <::bevy_image::Image as ::std::cmp::PartialEq< ::bevy_image::Image, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -310,8 +295,10 @@ pub(crate) fn register_image_functions(world: &mut World) { |_self: Ref<::bevy_image::Image>| { let output: u32 = { { - let output: u32 = ::bevy_image::Image::height(&_self).into(); - output + let output: u32 = ::bevy_image::Image::height( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -324,9 +311,10 @@ pub(crate) fn register_image_functions(world: &mut World) { |_self: Ref<::bevy_image::Image>| { let output: bool = { { - let output: bool = ::bevy_image::Image::is_compressed(&_self) - .into(); - output + let output: bool = ::bevy_image::Image::is_compressed( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -336,15 +324,14 @@ pub(crate) fn register_image_functions(world: &mut World) { ) .register_documented( "pixel_data_offset", - |_self: Ref<::bevy_image::Image>, coords: Val<::glam::UVec3>| { + |_self: Ref<::bevy_image::Image>, coords: Val<::bevy_math::UVec3>| { let output: ::std::option::Option = { { let output: ::std::option::Option = ::bevy_image::Image::pixel_data_offset( - &_self, - coords.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(coords), + ); + safe_transmute(output) } }; output @@ -358,11 +345,10 @@ pub(crate) fn register_image_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_image::Image::reinterpret_stacked_2d_as_array( - &mut _self, - layers, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(layers), + ); + safe_transmute(output) } }; output @@ -373,13 +359,12 @@ pub(crate) fn register_image_functions(world: &mut World) { .register_documented( "size", |_self: Ref<::bevy_image::Image>| { - let output: Val<::glam::UVec2> = { + let output: Val<::bevy_math::UVec2> = { { - let output: Val<::glam::UVec2> = ::bevy_image::Image::size( - &_self, - ) - .into(); - output + let output: ::bevy_math::UVec2 = ::bevy_image::Image::size( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -390,13 +375,12 @@ pub(crate) fn register_image_functions(world: &mut World) { .register_documented( "size_f32", |_self: Ref<::bevy_image::Image>| { - let output: Val<::glam::Vec2> = { + let output: Val<::bevy_math::Vec2> = { { - let output: Val<::glam::Vec2> = ::bevy_image::Image::size_f32( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_image::Image::size_f32( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -409,9 +393,8 @@ pub(crate) fn register_image_functions(world: &mut World) { || { let output: Val<::bevy_image::Image> = { { - let output: Val<::bevy_image::Image> = ::bevy_image::Image::transparent() - .into(); - output + let output: ::bevy_image::Image = ::bevy_image::Image::transparent(); + safe_transmute(output) } }; output @@ -424,8 +407,10 @@ pub(crate) fn register_image_functions(world: &mut World) { |_self: Ref<::bevy_image::Image>| { let output: u32 = { { - let output: u32 = ::bevy_image::Image::width(&_self).into(); - output + let output: u32 = ::bevy_image::Image::width( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -436,10 +421,7 @@ pub(crate) fn register_image_functions(world: &mut World) { let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::< - ::bevy_image::Image, - bevy_mod_scripting_bindings::MarkAsGenerated, - >(); + .register_type_data::<::bevy_image::Image, bevy_mod_scripting_bindings::MarkAsGenerated>(); } impl Plugin for BevyImageScriptingPlugin { fn build(&self, app: &mut App) { diff --git a/crates/bindings/bevy_input_bms_bindings/src/lib.rs b/crates/bindings/bevy_input_bms_bindings/src/lib.rs index 36947c4ba8..89d0b4a021 100644 --- a/crates/bindings/bevy_input_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_input_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -22,13 +22,12 @@ pub(crate) fn register_gamepad_functions(world: &mut World) { .register_documented( "dpad", |_self: Ref<::bevy_input::gamepad::Gamepad>| { - let output: Val<::glam::Vec2> = { + let output: Val<::bevy_math::Vec2> = { { - let output: Val<::glam::Vec2> = ::bevy_input::gamepad::Gamepad::dpad( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_input::gamepad::Gamepad::dpad( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45,11 +44,10 @@ pub(crate) fn register_gamepad_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_input::gamepad::Gamepad::just_pressed( - &_self, - button_type.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(button_type), + ); + safe_transmute(output) } }; output @@ -66,11 +64,10 @@ pub(crate) fn register_gamepad_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_input::gamepad::Gamepad::just_released( - &_self, - button_type.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(button_type), + ); + safe_transmute(output) } }; output @@ -81,13 +78,12 @@ pub(crate) fn register_gamepad_functions(world: &mut World) { .register_documented( "left_stick", |_self: Ref<::bevy_input::gamepad::Gamepad>| { - let output: Val<::glam::Vec2> = { + let output: Val<::bevy_math::Vec2> = { { - let output: Val<::glam::Vec2> = ::bevy_input::gamepad::Gamepad::left_stick( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_input::gamepad::Gamepad::left_stick( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -104,11 +100,10 @@ pub(crate) fn register_gamepad_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_input::gamepad::Gamepad::pressed( - &_self, - button_type.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(button_type), + ); + safe_transmute(output) } }; output @@ -122,10 +117,9 @@ pub(crate) fn register_gamepad_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::bevy_input::gamepad::Gamepad::product_id( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -136,13 +130,12 @@ pub(crate) fn register_gamepad_functions(world: &mut World) { .register_documented( "right_stick", |_self: Ref<::bevy_input::gamepad::Gamepad>| { - let output: Val<::glam::Vec2> = { + let output: Val<::bevy_math::Vec2> = { { - let output: Val<::glam::Vec2> = ::bevy_input::gamepad::Gamepad::right_stick( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_input::gamepad::Gamepad::right_stick( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -156,10 +149,9 @@ pub(crate) fn register_gamepad_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::bevy_input::gamepad::Gamepad::vendor_id( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -185,10 +177,9 @@ pub(crate) fn register_gamepad_axis_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_input::gamepad::GamepadAxis as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -201,11 +192,10 @@ pub(crate) fn register_gamepad_axis_functions(world: &mut World) { |_self: Ref<::bevy_input::gamepad::GamepadAxis>| { let output: Val<::bevy_input::gamepad::GamepadAxis> = { { - let output: Val<::bevy_input::gamepad::GamepadAxis> = <::bevy_input::gamepad::GamepadAxis as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::gamepad::GamepadAxis = <::bevy_input::gamepad::GamepadAxis as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -223,9 +213,8 @@ pub(crate) fn register_gamepad_axis_functions(world: &mut World) { { let output: bool = <::bevy_input::gamepad::GamepadAxis as ::core::cmp::PartialEq< ::bevy_input::gamepad::GamepadAxis, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -251,10 +240,9 @@ pub(crate) fn register_gamepad_button_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_input::gamepad::GamepadButton as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -267,11 +255,10 @@ pub(crate) fn register_gamepad_button_functions(world: &mut World) { |_self: Ref<::bevy_input::gamepad::GamepadButton>| { let output: Val<::bevy_input::gamepad::GamepadButton> = { { - let output: Val<::bevy_input::gamepad::GamepadButton> = <::bevy_input::gamepad::GamepadButton as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::gamepad::GamepadButton = <::bevy_input::gamepad::GamepadButton as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -289,9 +276,8 @@ pub(crate) fn register_gamepad_button_functions(world: &mut World) { { let output: bool = <::bevy_input::gamepad::GamepadButton as ::core::cmp::PartialEq< ::bevy_input::gamepad::GamepadButton, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -316,11 +302,10 @@ pub(crate) fn register_gamepad_settings_functions(world: &mut World) { |_self: Ref<::bevy_input::gamepad::GamepadSettings>| { let output: Val<::bevy_input::gamepad::GamepadSettings> = { { - let output: Val<::bevy_input::gamepad::GamepadSettings> = <::bevy_input::gamepad::GamepadSettings as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::gamepad::GamepadSettings = <::bevy_input::gamepad::GamepadSettings as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -346,10 +331,9 @@ pub(crate) fn register_key_code_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_input::keyboard::KeyCode as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -362,11 +346,10 @@ pub(crate) fn register_key_code_functions(world: &mut World) { |_self: Ref<::bevy_input::keyboard::KeyCode>| { let output: Val<::bevy_input::keyboard::KeyCode> = { { - let output: Val<::bevy_input::keyboard::KeyCode> = <::bevy_input::keyboard::KeyCode as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::keyboard::KeyCode = <::bevy_input::keyboard::KeyCode as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -384,9 +367,8 @@ pub(crate) fn register_key_code_functions(world: &mut World) { { let output: bool = <::bevy_input::keyboard::KeyCode as ::core::cmp::PartialEq< ::bevy_input::keyboard::KeyCode, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -412,10 +394,9 @@ pub(crate) fn register_mouse_button_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_input::mouse::MouseButton as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -428,11 +409,10 @@ pub(crate) fn register_mouse_button_functions(world: &mut World) { |_self: Ref<::bevy_input::mouse::MouseButton>| { let output: Val<::bevy_input::mouse::MouseButton> = { { - let output: Val<::bevy_input::mouse::MouseButton> = <::bevy_input::mouse::MouseButton as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::mouse::MouseButton = <::bevy_input::mouse::MouseButton as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -450,9 +430,8 @@ pub(crate) fn register_mouse_button_functions(world: &mut World) { { let output: bool = <::bevy_input::mouse::MouseButton as ::core::cmp::PartialEq< ::bevy_input::mouse::MouseButton, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -477,11 +456,10 @@ pub(crate) fn register_touch_input_functions(world: &mut World) { |_self: Ref<::bevy_input::touch::TouchInput>| { let output: Val<::bevy_input::touch::TouchInput> = { { - let output: Val<::bevy_input::touch::TouchInput> = <::bevy_input::touch::TouchInput as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::touch::TouchInput = <::bevy_input::touch::TouchInput as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -499,9 +477,8 @@ pub(crate) fn register_touch_input_functions(world: &mut World) { { let output: bool = <::bevy_input::touch::TouchInput as ::core::cmp::PartialEq< ::bevy_input::touch::TouchInput, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -527,10 +504,9 @@ pub(crate) fn register_key_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_input::keyboard::Key as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -543,11 +519,10 @@ pub(crate) fn register_key_functions(world: &mut World) { |_self: Ref<::bevy_input::keyboard::Key>| { let output: Val<::bevy_input::keyboard::Key> = { { - let output: Val<::bevy_input::keyboard::Key> = <::bevy_input::keyboard::Key as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::keyboard::Key = <::bevy_input::keyboard::Key as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -565,9 +540,8 @@ pub(crate) fn register_key_functions(world: &mut World) { { let output: bool = <::bevy_input::keyboard::Key as ::core::cmp::PartialEq< ::bevy_input::keyboard::Key, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -593,10 +567,9 @@ pub(crate) fn register_keyboard_focus_lost_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_input::keyboard::KeyboardFocusLost as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -609,11 +582,10 @@ pub(crate) fn register_keyboard_focus_lost_functions(world: &mut World) { |_self: Ref<::bevy_input::keyboard::KeyboardFocusLost>| { let output: Val<::bevy_input::keyboard::KeyboardFocusLost> = { { - let output: Val<::bevy_input::keyboard::KeyboardFocusLost> = <::bevy_input::keyboard::KeyboardFocusLost as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::keyboard::KeyboardFocusLost = <::bevy_input::keyboard::KeyboardFocusLost as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -631,9 +603,8 @@ pub(crate) fn register_keyboard_focus_lost_functions(world: &mut World) { { let output: bool = <::bevy_input::keyboard::KeyboardFocusLost as ::core::cmp::PartialEq< ::bevy_input::keyboard::KeyboardFocusLost, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -659,10 +630,9 @@ pub(crate) fn register_keyboard_input_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_input::keyboard::KeyboardInput as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -675,11 +645,10 @@ pub(crate) fn register_keyboard_input_functions(world: &mut World) { |_self: Ref<::bevy_input::keyboard::KeyboardInput>| { let output: Val<::bevy_input::keyboard::KeyboardInput> = { { - let output: Val<::bevy_input::keyboard::KeyboardInput> = <::bevy_input::keyboard::KeyboardInput as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::keyboard::KeyboardInput = <::bevy_input::keyboard::KeyboardInput as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -697,9 +666,8 @@ pub(crate) fn register_keyboard_input_functions(world: &mut World) { { let output: bool = <::bevy_input::keyboard::KeyboardInput as ::core::cmp::PartialEq< ::bevy_input::keyboard::KeyboardInput, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -724,11 +692,10 @@ pub(crate) fn register_accumulated_mouse_motion_functions(world: &mut World) { |_self: Ref<::bevy_input::mouse::AccumulatedMouseMotion>| { let output: Val<::bevy_input::mouse::AccumulatedMouseMotion> = { { - let output: Val<::bevy_input::mouse::AccumulatedMouseMotion> = <::bevy_input::mouse::AccumulatedMouseMotion as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::mouse::AccumulatedMouseMotion = <::bevy_input::mouse::AccumulatedMouseMotion as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -746,9 +713,8 @@ pub(crate) fn register_accumulated_mouse_motion_functions(world: &mut World) { { let output: bool = <::bevy_input::mouse::AccumulatedMouseMotion as ::core::cmp::PartialEq< ::bevy_input::mouse::AccumulatedMouseMotion, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -773,11 +739,10 @@ pub(crate) fn register_accumulated_mouse_scroll_functions(world: &mut World) { |_self: Ref<::bevy_input::mouse::AccumulatedMouseScroll>| { let output: Val<::bevy_input::mouse::AccumulatedMouseScroll> = { { - let output: Val<::bevy_input::mouse::AccumulatedMouseScroll> = <::bevy_input::mouse::AccumulatedMouseScroll as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::mouse::AccumulatedMouseScroll = <::bevy_input::mouse::AccumulatedMouseScroll as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -795,9 +760,8 @@ pub(crate) fn register_accumulated_mouse_scroll_functions(world: &mut World) { { let output: bool = <::bevy_input::mouse::AccumulatedMouseScroll as ::core::cmp::PartialEq< ::bevy_input::mouse::AccumulatedMouseScroll, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -823,10 +787,9 @@ pub(crate) fn register_mouse_button_input_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_input::mouse::MouseButtonInput as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -839,11 +802,10 @@ pub(crate) fn register_mouse_button_input_functions(world: &mut World) { |_self: Ref<::bevy_input::mouse::MouseButtonInput>| { let output: Val<::bevy_input::mouse::MouseButtonInput> = { { - let output: Val<::bevy_input::mouse::MouseButtonInput> = <::bevy_input::mouse::MouseButtonInput as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::mouse::MouseButtonInput = <::bevy_input::mouse::MouseButtonInput as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -861,9 +823,8 @@ pub(crate) fn register_mouse_button_input_functions(world: &mut World) { { let output: bool = <::bevy_input::mouse::MouseButtonInput as ::core::cmp::PartialEq< ::bevy_input::mouse::MouseButtonInput, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -888,11 +849,10 @@ pub(crate) fn register_mouse_motion_functions(world: &mut World) { |_self: Ref<::bevy_input::mouse::MouseMotion>| { let output: Val<::bevy_input::mouse::MouseMotion> = { { - let output: Val<::bevy_input::mouse::MouseMotion> = <::bevy_input::mouse::MouseMotion as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::mouse::MouseMotion = <::bevy_input::mouse::MouseMotion as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -910,9 +870,8 @@ pub(crate) fn register_mouse_motion_functions(world: &mut World) { { let output: bool = <::bevy_input::mouse::MouseMotion as ::core::cmp::PartialEq< ::bevy_input::mouse::MouseMotion, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -937,11 +896,10 @@ pub(crate) fn register_mouse_wheel_functions(world: &mut World) { |_self: Ref<::bevy_input::mouse::MouseWheel>| { let output: Val<::bevy_input::mouse::MouseWheel> = { { - let output: Val<::bevy_input::mouse::MouseWheel> = <::bevy_input::mouse::MouseWheel as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::mouse::MouseWheel = <::bevy_input::mouse::MouseWheel as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -959,9 +917,8 @@ pub(crate) fn register_mouse_wheel_functions(world: &mut World) { { let output: bool = <::bevy_input::mouse::MouseWheel as ::core::cmp::PartialEq< ::bevy_input::mouse::MouseWheel, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -986,13 +943,10 @@ pub(crate) fn register_gamepad_axis_changed_event_functions(world: &mut World) { |_self: Ref<::bevy_input::gamepad::GamepadAxisChangedEvent>| { let output: Val<::bevy_input::gamepad::GamepadAxisChangedEvent> = { { - let output: Val< - ::bevy_input::gamepad::GamepadAxisChangedEvent, - > = <::bevy_input::gamepad::GamepadAxisChangedEvent as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::gamepad::GamepadAxisChangedEvent = <::bevy_input::gamepad::GamepadAxisChangedEvent as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1010,9 +964,8 @@ pub(crate) fn register_gamepad_axis_changed_event_functions(world: &mut World) { { let output: bool = <::bevy_input::gamepad::GamepadAxisChangedEvent as ::core::cmp::PartialEq< ::bevy_input::gamepad::GamepadAxisChangedEvent, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1029,15 +982,12 @@ pub(crate) fn register_gamepad_axis_changed_event_functions(world: &mut World) { { let output: Val<::bevy_input::gamepad::GamepadAxisChangedEvent> = { { - let output: Val< - ::bevy_input::gamepad::GamepadAxisChangedEvent, - > = ::bevy_input::gamepad::GamepadAxisChangedEvent::new( - entity.into_inner(), - axis.into_inner(), - value, - ) - .into(); - output + let output: ::bevy_input::gamepad::GamepadAxisChangedEvent = ::bevy_input::gamepad::GamepadAxisChangedEvent::new( + safe_transmute(entity), + safe_transmute(axis), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -1062,13 +1012,10 @@ pub(crate) fn register_gamepad_button_changed_event_functions(world: &mut World) |_self: Ref<::bevy_input::gamepad::GamepadButtonChangedEvent>| { let output: Val<::bevy_input::gamepad::GamepadButtonChangedEvent> = { { - let output: Val< - ::bevy_input::gamepad::GamepadButtonChangedEvent, - > = <::bevy_input::gamepad::GamepadButtonChangedEvent as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::gamepad::GamepadButtonChangedEvent = <::bevy_input::gamepad::GamepadButtonChangedEvent as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1086,9 +1033,8 @@ pub(crate) fn register_gamepad_button_changed_event_functions(world: &mut World) { let output: bool = <::bevy_input::gamepad::GamepadButtonChangedEvent as ::core::cmp::PartialEq< ::bevy_input::gamepad::GamepadButtonChangedEvent, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1106,16 +1052,13 @@ pub(crate) fn register_gamepad_button_changed_event_functions(world: &mut World) { let output: Val<::bevy_input::gamepad::GamepadButtonChangedEvent> = { { - let output: Val< - ::bevy_input::gamepad::GamepadButtonChangedEvent, - > = ::bevy_input::gamepad::GamepadButtonChangedEvent::new( - entity.into_inner(), - button.into_inner(), - state.into_inner(), - value, - ) - .into(); - output + let output: ::bevy_input::gamepad::GamepadButtonChangedEvent = ::bevy_input::gamepad::GamepadButtonChangedEvent::new( + safe_transmute(entity), + safe_transmute(button), + safe_transmute(state), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -1141,10 +1084,9 @@ pub(crate) fn register_gamepad_button_state_changed_event_functions(world: &mut let output: () = { { let output: () = <::bevy_input::gamepad::GamepadButtonStateChangedEvent as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1157,13 +1099,10 @@ pub(crate) fn register_gamepad_button_state_changed_event_functions(world: &mut |_self: Ref<::bevy_input::gamepad::GamepadButtonStateChangedEvent>| { let output: Val<::bevy_input::gamepad::GamepadButtonStateChangedEvent> = { { - let output: Val< - ::bevy_input::gamepad::GamepadButtonStateChangedEvent, - > = <::bevy_input::gamepad::GamepadButtonStateChangedEvent as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::gamepad::GamepadButtonStateChangedEvent = <::bevy_input::gamepad::GamepadButtonStateChangedEvent as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1181,9 +1120,8 @@ pub(crate) fn register_gamepad_button_state_changed_event_functions(world: &mut { let output: bool = <::bevy_input::gamepad::GamepadButtonStateChangedEvent as ::core::cmp::PartialEq< ::bevy_input::gamepad::GamepadButtonStateChangedEvent, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1200,15 +1138,12 @@ pub(crate) fn register_gamepad_button_state_changed_event_functions(world: &mut { let output: Val<::bevy_input::gamepad::GamepadButtonStateChangedEvent> = { { - let output: Val< - ::bevy_input::gamepad::GamepadButtonStateChangedEvent, - > = ::bevy_input::gamepad::GamepadButtonStateChangedEvent::new( - entity.into_inner(), - button.into_inner(), - state.into_inner(), - ) - .into(); - output + let output: ::bevy_input::gamepad::GamepadButtonStateChangedEvent = ::bevy_input::gamepad::GamepadButtonStateChangedEvent::new( + safe_transmute(entity), + safe_transmute(button), + safe_transmute(state), + ); + safe_transmute(output) } }; output @@ -1233,11 +1168,10 @@ pub(crate) fn register_gamepad_connection_event_functions(world: &mut World) { |_self: Ref<::bevy_input::gamepad::GamepadConnectionEvent>| { let output: Val<::bevy_input::gamepad::GamepadConnectionEvent> = { { - let output: Val<::bevy_input::gamepad::GamepadConnectionEvent> = <::bevy_input::gamepad::GamepadConnectionEvent as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::gamepad::GamepadConnectionEvent = <::bevy_input::gamepad::GamepadConnectionEvent as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1251,10 +1185,9 @@ pub(crate) fn register_gamepad_connection_event_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_input::gamepad::GamepadConnectionEvent::connected( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1268,10 +1201,9 @@ pub(crate) fn register_gamepad_connection_event_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_input::gamepad::GamepadConnectionEvent::disconnected( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1289,9 +1221,8 @@ pub(crate) fn register_gamepad_connection_event_functions(world: &mut World) { { let output: bool = <::bevy_input::gamepad::GamepadConnectionEvent as ::core::cmp::PartialEq< ::bevy_input::gamepad::GamepadConnectionEvent, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1307,12 +1238,11 @@ pub(crate) fn register_gamepad_connection_event_functions(world: &mut World) { { let output: Val<::bevy_input::gamepad::GamepadConnectionEvent> = { { - let output: Val<::bevy_input::gamepad::GamepadConnectionEvent> = ::bevy_input::gamepad::GamepadConnectionEvent::new( - gamepad.into_inner(), - connection.into_inner(), - ) - .into(); - output + let output: ::bevy_input::gamepad::GamepadConnectionEvent = ::bevy_input::gamepad::GamepadConnectionEvent::new( + safe_transmute(gamepad), + safe_transmute(connection), + ); + safe_transmute(output) } }; output @@ -1337,11 +1267,10 @@ pub(crate) fn register_gamepad_event_functions(world: &mut World) { |_self: Ref<::bevy_input::gamepad::GamepadEvent>| { let output: Val<::bevy_input::gamepad::GamepadEvent> = { { - let output: Val<::bevy_input::gamepad::GamepadEvent> = <::bevy_input::gamepad::GamepadEvent as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::gamepad::GamepadEvent = <::bevy_input::gamepad::GamepadEvent as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1359,9 +1288,8 @@ pub(crate) fn register_gamepad_event_functions(world: &mut World) { { let output: bool = <::bevy_input::gamepad::GamepadEvent as ::core::cmp::PartialEq< ::bevy_input::gamepad::GamepadEvent, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1386,11 +1314,10 @@ pub(crate) fn register_gamepad_rumble_request_functions(world: &mut World) { |_self: Ref<::bevy_input::gamepad::GamepadRumbleRequest>| { let output: Val<::bevy_input::gamepad::GamepadRumbleRequest> = { { - let output: Val<::bevy_input::gamepad::GamepadRumbleRequest> = <::bevy_input::gamepad::GamepadRumbleRequest as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::gamepad::GamepadRumbleRequest = <::bevy_input::gamepad::GamepadRumbleRequest as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1403,11 +1330,10 @@ pub(crate) fn register_gamepad_rumble_request_functions(world: &mut World) { |_self: Ref<::bevy_input::gamepad::GamepadRumbleRequest>| { let output: Val<::bevy_ecs::entity::Entity> = { { - let output: Val<::bevy_ecs::entity::Entity> = ::bevy_input::gamepad::GamepadRumbleRequest::gamepad( - &_self, - ) - .into(); - output + let output: ::bevy_ecs::entity::Entity = ::bevy_input::gamepad::GamepadRumbleRequest::gamepad( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1432,13 +1358,10 @@ pub(crate) fn register_raw_gamepad_axis_changed_event_functions(world: &mut Worl |_self: Ref<::bevy_input::gamepad::RawGamepadAxisChangedEvent>| { let output: Val<::bevy_input::gamepad::RawGamepadAxisChangedEvent> = { { - let output: Val< - ::bevy_input::gamepad::RawGamepadAxisChangedEvent, - > = <::bevy_input::gamepad::RawGamepadAxisChangedEvent as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::gamepad::RawGamepadAxisChangedEvent = <::bevy_input::gamepad::RawGamepadAxisChangedEvent as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1456,9 +1379,8 @@ pub(crate) fn register_raw_gamepad_axis_changed_event_functions(world: &mut Worl { let output: bool = <::bevy_input::gamepad::RawGamepadAxisChangedEvent as ::core::cmp::PartialEq< ::bevy_input::gamepad::RawGamepadAxisChangedEvent, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1475,15 +1397,12 @@ pub(crate) fn register_raw_gamepad_axis_changed_event_functions(world: &mut Worl { let output: Val<::bevy_input::gamepad::RawGamepadAxisChangedEvent> = { { - let output: Val< - ::bevy_input::gamepad::RawGamepadAxisChangedEvent, - > = ::bevy_input::gamepad::RawGamepadAxisChangedEvent::new( - gamepad.into_inner(), - axis_type.into_inner(), - value, - ) - .into(); - output + let output: ::bevy_input::gamepad::RawGamepadAxisChangedEvent = ::bevy_input::gamepad::RawGamepadAxisChangedEvent::new( + safe_transmute(gamepad), + safe_transmute(axis_type), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -1508,13 +1427,10 @@ pub(crate) fn register_raw_gamepad_button_changed_event_functions(world: &mut Wo |_self: Ref<::bevy_input::gamepad::RawGamepadButtonChangedEvent>| { let output: Val<::bevy_input::gamepad::RawGamepadButtonChangedEvent> = { { - let output: Val< - ::bevy_input::gamepad::RawGamepadButtonChangedEvent, - > = <::bevy_input::gamepad::RawGamepadButtonChangedEvent as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::gamepad::RawGamepadButtonChangedEvent = <::bevy_input::gamepad::RawGamepadButtonChangedEvent as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1532,9 +1448,8 @@ pub(crate) fn register_raw_gamepad_button_changed_event_functions(world: &mut Wo { let output: bool = <::bevy_input::gamepad::RawGamepadButtonChangedEvent as ::core::cmp::PartialEq< ::bevy_input::gamepad::RawGamepadButtonChangedEvent, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1551,15 +1466,12 @@ pub(crate) fn register_raw_gamepad_button_changed_event_functions(world: &mut Wo { let output: Val<::bevy_input::gamepad::RawGamepadButtonChangedEvent> = { { - let output: Val< - ::bevy_input::gamepad::RawGamepadButtonChangedEvent, - > = ::bevy_input::gamepad::RawGamepadButtonChangedEvent::new( - gamepad.into_inner(), - button_type.into_inner(), - value, - ) - .into(); - output + let output: ::bevy_input::gamepad::RawGamepadButtonChangedEvent = ::bevy_input::gamepad::RawGamepadButtonChangedEvent::new( + safe_transmute(gamepad), + safe_transmute(button_type), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -1584,11 +1496,10 @@ pub(crate) fn register_raw_gamepad_event_functions(world: &mut World) { |_self: Ref<::bevy_input::gamepad::RawGamepadEvent>| { let output: Val<::bevy_input::gamepad::RawGamepadEvent> = { { - let output: Val<::bevy_input::gamepad::RawGamepadEvent> = <::bevy_input::gamepad::RawGamepadEvent as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::gamepad::RawGamepadEvent = <::bevy_input::gamepad::RawGamepadEvent as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1606,9 +1517,8 @@ pub(crate) fn register_raw_gamepad_event_functions(world: &mut World) { { let output: bool = <::bevy_input::gamepad::RawGamepadEvent as ::core::cmp::PartialEq< ::bevy_input::gamepad::RawGamepadEvent, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1633,11 +1543,10 @@ pub(crate) fn register_pinch_gesture_functions(world: &mut World) { |_self: Ref<::bevy_input::gestures::PinchGesture>| { let output: Val<::bevy_input::gestures::PinchGesture> = { { - let output: Val<::bevy_input::gestures::PinchGesture> = <::bevy_input::gestures::PinchGesture as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::gestures::PinchGesture = <::bevy_input::gestures::PinchGesture as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1655,9 +1564,8 @@ pub(crate) fn register_pinch_gesture_functions(world: &mut World) { { let output: bool = <::bevy_input::gestures::PinchGesture as ::core::cmp::PartialEq< ::bevy_input::gestures::PinchGesture, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1682,11 +1590,10 @@ pub(crate) fn register_rotation_gesture_functions(world: &mut World) { |_self: Ref<::bevy_input::gestures::RotationGesture>| { let output: Val<::bevy_input::gestures::RotationGesture> = { { - let output: Val<::bevy_input::gestures::RotationGesture> = <::bevy_input::gestures::RotationGesture as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::gestures::RotationGesture = <::bevy_input::gestures::RotationGesture as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1704,9 +1611,8 @@ pub(crate) fn register_rotation_gesture_functions(world: &mut World) { { let output: bool = <::bevy_input::gestures::RotationGesture as ::core::cmp::PartialEq< ::bevy_input::gestures::RotationGesture, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1731,11 +1637,10 @@ pub(crate) fn register_double_tap_gesture_functions(world: &mut World) { |_self: Ref<::bevy_input::gestures::DoubleTapGesture>| { let output: Val<::bevy_input::gestures::DoubleTapGesture> = { { - let output: Val<::bevy_input::gestures::DoubleTapGesture> = <::bevy_input::gestures::DoubleTapGesture as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::gestures::DoubleTapGesture = <::bevy_input::gestures::DoubleTapGesture as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1753,9 +1658,8 @@ pub(crate) fn register_double_tap_gesture_functions(world: &mut World) { { let output: bool = <::bevy_input::gestures::DoubleTapGesture as ::core::cmp::PartialEq< ::bevy_input::gestures::DoubleTapGesture, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1780,11 +1684,10 @@ pub(crate) fn register_pan_gesture_functions(world: &mut World) { |_self: Ref<::bevy_input::gestures::PanGesture>| { let output: Val<::bevy_input::gestures::PanGesture> = { { - let output: Val<::bevy_input::gestures::PanGesture> = <::bevy_input::gestures::PanGesture as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::gestures::PanGesture = <::bevy_input::gestures::PanGesture as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1802,9 +1705,8 @@ pub(crate) fn register_pan_gesture_functions(world: &mut World) { { let output: bool = <::bevy_input::gestures::PanGesture as ::core::cmp::PartialEq< ::bevy_input::gestures::PanGesture, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1830,10 +1732,9 @@ pub(crate) fn register_button_state_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_input::ButtonState as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1846,11 +1747,10 @@ pub(crate) fn register_button_state_functions(world: &mut World) { |_self: Ref<::bevy_input::ButtonState>| { let output: Val<::bevy_input::ButtonState> = { { - let output: Val<::bevy_input::ButtonState> = <::bevy_input::ButtonState as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::ButtonState = <::bevy_input::ButtonState as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1868,9 +1768,8 @@ pub(crate) fn register_button_state_functions(world: &mut World) { { let output: bool = <::bevy_input::ButtonState as ::core::cmp::PartialEq< ::bevy_input::ButtonState, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1883,9 +1782,10 @@ pub(crate) fn register_button_state_functions(world: &mut World) { |_self: Ref<::bevy_input::ButtonState>| { let output: bool = { { - let output: bool = ::bevy_input::ButtonState::is_pressed(&_self) - .into(); - output + let output: bool = ::bevy_input::ButtonState::is_pressed( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1910,11 +1810,10 @@ pub(crate) fn register_gamepad_connection_functions(world: &mut World) { |_self: Ref<::bevy_input::gamepad::GamepadConnection>| { let output: Val<::bevy_input::gamepad::GamepadConnection> = { { - let output: Val<::bevy_input::gamepad::GamepadConnection> = <::bevy_input::gamepad::GamepadConnection as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::gamepad::GamepadConnection = <::bevy_input::gamepad::GamepadConnection as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1932,9 +1831,8 @@ pub(crate) fn register_gamepad_connection_functions(world: &mut World) { { let output: bool = <::bevy_input::gamepad::GamepadConnection as ::core::cmp::PartialEq< ::bevy_input::gamepad::GamepadConnection, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1960,10 +1858,9 @@ pub(crate) fn register_gamepad_input_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_input::gamepad::GamepadInput as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1976,11 +1873,10 @@ pub(crate) fn register_gamepad_input_functions(world: &mut World) { |_self: Ref<::bevy_input::gamepad::GamepadInput>| { let output: Val<::bevy_input::gamepad::GamepadInput> = { { - let output: Val<::bevy_input::gamepad::GamepadInput> = <::bevy_input::gamepad::GamepadInput as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::gamepad::GamepadInput = <::bevy_input::gamepad::GamepadInput as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1998,9 +1894,8 @@ pub(crate) fn register_gamepad_input_functions(world: &mut World) { { let output: bool = <::bevy_input::gamepad::GamepadInput as ::core::cmp::PartialEq< ::bevy_input::gamepad::GamepadInput, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2025,11 +1920,10 @@ pub(crate) fn register_button_settings_functions(world: &mut World) { |_self: Ref<::bevy_input::gamepad::ButtonSettings>| { let output: Val<::bevy_input::gamepad::ButtonSettings> = { { - let output: Val<::bevy_input::gamepad::ButtonSettings> = <::bevy_input::gamepad::ButtonSettings as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::gamepad::ButtonSettings = <::bevy_input::gamepad::ButtonSettings as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2047,9 +1941,8 @@ pub(crate) fn register_button_settings_functions(world: &mut World) { { let output: bool = <::bevy_input::gamepad::ButtonSettings as ::core::cmp::PartialEq< ::bevy_input::gamepad::ButtonSettings, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2063,11 +1956,10 @@ pub(crate) fn register_button_settings_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_input::gamepad::ButtonSettings::is_pressed( - &_self, - value, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -2081,11 +1973,10 @@ pub(crate) fn register_button_settings_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_input::gamepad::ButtonSettings::is_released( - &_self, - value, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -2099,10 +1990,9 @@ pub(crate) fn register_button_settings_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_input::gamepad::ButtonSettings::press_threshold( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2116,10 +2006,9 @@ pub(crate) fn register_button_settings_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_input::gamepad::ButtonSettings::release_threshold( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2133,11 +2022,10 @@ pub(crate) fn register_button_settings_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_input::gamepad::ButtonSettings::set_press_threshold( - &mut _self, - value, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -2151,11 +2039,10 @@ pub(crate) fn register_button_settings_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_input::gamepad::ButtonSettings::set_release_threshold( - &mut _self, - value, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -2181,11 +2068,10 @@ pub(crate) fn register_axis_settings_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_input::gamepad::AxisSettings::clamp( - &_self, - raw_value, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(raw_value), + ); + safe_transmute(output) } }; output @@ -2198,11 +2084,10 @@ pub(crate) fn register_axis_settings_functions(world: &mut World) { |_self: Ref<::bevy_input::gamepad::AxisSettings>| { let output: Val<::bevy_input::gamepad::AxisSettings> = { { - let output: Val<::bevy_input::gamepad::AxisSettings> = <::bevy_input::gamepad::AxisSettings as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::gamepad::AxisSettings = <::bevy_input::gamepad::AxisSettings as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2216,10 +2101,9 @@ pub(crate) fn register_axis_settings_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_input::gamepad::AxisSettings::deadzone_lowerbound( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2233,10 +2117,9 @@ pub(crate) fn register_axis_settings_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_input::gamepad::AxisSettings::deadzone_upperbound( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2254,9 +2137,8 @@ pub(crate) fn register_axis_settings_functions(world: &mut World) { { let output: bool = <::bevy_input::gamepad::AxisSettings as ::core::cmp::PartialEq< ::bevy_input::gamepad::AxisSettings, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2270,10 +2152,9 @@ pub(crate) fn register_axis_settings_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_input::gamepad::AxisSettings::livezone_lowerbound( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2287,10 +2168,9 @@ pub(crate) fn register_axis_settings_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_input::gamepad::AxisSettings::livezone_upperbound( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2304,11 +2184,10 @@ pub(crate) fn register_axis_settings_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_input::gamepad::AxisSettings::set_deadzone_lowerbound( - &mut _self, - value, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -2322,11 +2201,10 @@ pub(crate) fn register_axis_settings_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_input::gamepad::AxisSettings::set_deadzone_upperbound( - &mut _self, - value, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -2340,11 +2218,10 @@ pub(crate) fn register_axis_settings_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_input::gamepad::AxisSettings::set_livezone_lowerbound( - &mut _self, - value, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -2358,11 +2235,10 @@ pub(crate) fn register_axis_settings_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_input::gamepad::AxisSettings::set_livezone_upperbound( - &mut _self, - value, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -2376,11 +2252,10 @@ pub(crate) fn register_axis_settings_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_input::gamepad::AxisSettings::set_threshold( - &mut _self, - value, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -2394,10 +2269,9 @@ pub(crate) fn register_axis_settings_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_input::gamepad::AxisSettings::threshold( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2422,11 +2296,10 @@ pub(crate) fn register_button_axis_settings_functions(world: &mut World) { |_self: Ref<::bevy_input::gamepad::ButtonAxisSettings>| { let output: Val<::bevy_input::gamepad::ButtonAxisSettings> = { { - let output: Val<::bevy_input::gamepad::ButtonAxisSettings> = <::bevy_input::gamepad::ButtonAxisSettings as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::gamepad::ButtonAxisSettings = <::bevy_input::gamepad::ButtonAxisSettings as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2451,11 +2324,10 @@ pub(crate) fn register_gamepad_rumble_intensity_functions(world: &mut World) { |_self: Ref<::bevy_input::gamepad::GamepadRumbleIntensity>| { let output: Val<::bevy_input::gamepad::GamepadRumbleIntensity> = { { - let output: Val<::bevy_input::gamepad::GamepadRumbleIntensity> = <::bevy_input::gamepad::GamepadRumbleIntensity as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::gamepad::GamepadRumbleIntensity = <::bevy_input::gamepad::GamepadRumbleIntensity as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2473,9 +2345,8 @@ pub(crate) fn register_gamepad_rumble_intensity_functions(world: &mut World) { { let output: bool = <::bevy_input::gamepad::GamepadRumbleIntensity as ::core::cmp::PartialEq< ::bevy_input::gamepad::GamepadRumbleIntensity, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2488,11 +2359,10 @@ pub(crate) fn register_gamepad_rumble_intensity_functions(world: &mut World) { |intensity: f32| { let output: Val<::bevy_input::gamepad::GamepadRumbleIntensity> = { { - let output: Val<::bevy_input::gamepad::GamepadRumbleIntensity> = ::bevy_input::gamepad::GamepadRumbleIntensity::strong_motor( - intensity, - ) - .into(); - output + let output: ::bevy_input::gamepad::GamepadRumbleIntensity = ::bevy_input::gamepad::GamepadRumbleIntensity::strong_motor( + safe_transmute(intensity), + ); + safe_transmute(output) } }; output @@ -2505,11 +2375,10 @@ pub(crate) fn register_gamepad_rumble_intensity_functions(world: &mut World) { |intensity: f32| { let output: Val<::bevy_input::gamepad::GamepadRumbleIntensity> = { { - let output: Val<::bevy_input::gamepad::GamepadRumbleIntensity> = ::bevy_input::gamepad::GamepadRumbleIntensity::weak_motor( - intensity, - ) - .into(); - output + let output: ::bevy_input::gamepad::GamepadRumbleIntensity = ::bevy_input::gamepad::GamepadRumbleIntensity::weak_motor( + safe_transmute(intensity), + ); + safe_transmute(output) } }; output @@ -2535,10 +2404,9 @@ pub(crate) fn register_native_key_code_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_input::keyboard::NativeKeyCode as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2551,11 +2419,10 @@ pub(crate) fn register_native_key_code_functions(world: &mut World) { |_self: Ref<::bevy_input::keyboard::NativeKeyCode>| { let output: Val<::bevy_input::keyboard::NativeKeyCode> = { { - let output: Val<::bevy_input::keyboard::NativeKeyCode> = <::bevy_input::keyboard::NativeKeyCode as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::keyboard::NativeKeyCode = <::bevy_input::keyboard::NativeKeyCode as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2573,9 +2440,8 @@ pub(crate) fn register_native_key_code_functions(world: &mut World) { { let output: bool = <::bevy_input::keyboard::NativeKeyCode as ::core::cmp::PartialEq< ::bevy_input::keyboard::NativeKeyCode, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2601,10 +2467,9 @@ pub(crate) fn register_native_key_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_input::keyboard::NativeKey as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2617,11 +2482,10 @@ pub(crate) fn register_native_key_functions(world: &mut World) { |_self: Ref<::bevy_input::keyboard::NativeKey>| { let output: Val<::bevy_input::keyboard::NativeKey> = { { - let output: Val<::bevy_input::keyboard::NativeKey> = <::bevy_input::keyboard::NativeKey as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::keyboard::NativeKey = <::bevy_input::keyboard::NativeKey as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2639,9 +2503,8 @@ pub(crate) fn register_native_key_functions(world: &mut World) { { let output: bool = <::bevy_input::keyboard::NativeKey as ::core::cmp::PartialEq< ::bevy_input::keyboard::NativeKey, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2667,10 +2530,9 @@ pub(crate) fn register_mouse_scroll_unit_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_input::mouse::MouseScrollUnit as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2683,11 +2545,10 @@ pub(crate) fn register_mouse_scroll_unit_functions(world: &mut World) { |_self: Ref<::bevy_input::mouse::MouseScrollUnit>| { let output: Val<::bevy_input::mouse::MouseScrollUnit> = { { - let output: Val<::bevy_input::mouse::MouseScrollUnit> = <::bevy_input::mouse::MouseScrollUnit as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::mouse::MouseScrollUnit = <::bevy_input::mouse::MouseScrollUnit as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2705,9 +2566,8 @@ pub(crate) fn register_mouse_scroll_unit_functions(world: &mut World) { { let output: bool = <::bevy_input::mouse::MouseScrollUnit as ::core::cmp::PartialEq< ::bevy_input::mouse::MouseScrollUnit, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2733,10 +2593,9 @@ pub(crate) fn register_touch_phase_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_input::touch::TouchPhase as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2749,11 +2608,10 @@ pub(crate) fn register_touch_phase_functions(world: &mut World) { |_self: Ref<::bevy_input::touch::TouchPhase>| { let output: Val<::bevy_input::touch::TouchPhase> = { { - let output: Val<::bevy_input::touch::TouchPhase> = <::bevy_input::touch::TouchPhase as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::touch::TouchPhase = <::bevy_input::touch::TouchPhase as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2771,9 +2629,8 @@ pub(crate) fn register_touch_phase_functions(world: &mut World) { { let output: bool = <::bevy_input::touch::TouchPhase as ::core::cmp::PartialEq< ::bevy_input::touch::TouchPhase, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2798,11 +2655,10 @@ pub(crate) fn register_force_touch_functions(world: &mut World) { |_self: Ref<::bevy_input::touch::ForceTouch>| { let output: Val<::bevy_input::touch::ForceTouch> = { { - let output: Val<::bevy_input::touch::ForceTouch> = <::bevy_input::touch::ForceTouch as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input::touch::ForceTouch = <::bevy_input::touch::ForceTouch as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2820,9 +2676,8 @@ pub(crate) fn register_force_touch_functions(world: &mut World) { { let output: bool = <::bevy_input::touch::ForceTouch as ::core::cmp::PartialEq< ::bevy_input::touch::ForceTouch, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_input_focus_bms_bindings/src/lib.rs b/crates/bindings/bevy_input_focus_bms_bindings/src/lib.rs index ee21c555a6..8cea3b4168 100644 --- a/crates/bindings/bevy_input_focus_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_input_focus_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -25,10 +25,9 @@ pub(crate) fn register_input_focus_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_input_focus::InputFocus::clear( - &mut _self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41,11 +40,10 @@ pub(crate) fn register_input_focus_functions(world: &mut World) { |_self: Ref<::bevy_input_focus::InputFocus>| { let output: Val<::bevy_input_focus::InputFocus> = { { - let output: Val<::bevy_input_focus::InputFocus> = <::bevy_input_focus::InputFocus as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input_focus::InputFocus = <::bevy_input_focus::InputFocus as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -58,11 +56,10 @@ pub(crate) fn register_input_focus_functions(world: &mut World) { |entity: Val<::bevy_ecs::entity::Entity>| { let output: Val<::bevy_input_focus::InputFocus> = { { - let output: Val<::bevy_input_focus::InputFocus> = ::bevy_input_focus::InputFocus::from_entity( - entity.into_inner(), - ) - .into(); - output + let output: ::bevy_input_focus::InputFocus = ::bevy_input_focus::InputFocus::from_entity( + safe_transmute(entity), + ); + safe_transmute(output) } }; output @@ -79,11 +76,10 @@ pub(crate) fn register_input_focus_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_input_focus::InputFocus::set( - &mut _self, - entity.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(entity), + ); + safe_transmute(output) } }; output @@ -108,11 +104,10 @@ pub(crate) fn register_input_focus_visible_functions(world: &mut World) { |_self: Ref<::bevy_input_focus::InputFocusVisible>| { let output: Val<::bevy_input_focus::InputFocusVisible> = { { - let output: Val<::bevy_input_focus::InputFocusVisible> = <::bevy_input_focus::InputFocusVisible as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input_focus::InputFocusVisible = <::bevy_input_focus::InputFocusVisible as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -137,11 +132,10 @@ pub(crate) fn register_auto_focus_functions(world: &mut World) { |_self: Ref<::bevy_input_focus::AutoFocus>| { let output: Val<::bevy_input_focus::AutoFocus> = { { - let output: Val<::bevy_input_focus::AutoFocus> = <::bevy_input_focus::AutoFocus as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input_focus::AutoFocus = <::bevy_input_focus::AutoFocus as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -174,13 +168,12 @@ pub(crate) fn register_directional_navigation_map_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_input_focus::directional_navigation::DirectionalNavigationMap::add_edge( - &mut _self, - a.into_inner(), - b.into_inner(), - direction.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(a), + safe_transmute(b), + safe_transmute(direction), + ); + safe_transmute(output) } }; output @@ -201,13 +194,12 @@ pub(crate) fn register_directional_navigation_map_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_input_focus::directional_navigation::DirectionalNavigationMap::add_symmetrical_edge( - &mut _self, - a.into_inner(), - b.into_inner(), - direction.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(a), + safe_transmute(b), + safe_transmute(direction), + ); + safe_transmute(output) } }; output @@ -225,10 +217,9 @@ pub(crate) fn register_directional_navigation_map_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_input_focus::directional_navigation::DirectionalNavigationMap::clear( - &mut _self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -247,13 +238,10 @@ pub(crate) fn register_directional_navigation_map_functions(world: &mut World) { ::bevy_input_focus::directional_navigation::DirectionalNavigationMap, > = { { - let output: Val< - ::bevy_input_focus::directional_navigation::DirectionalNavigationMap, - > = <::bevy_input_focus::directional_navigation::DirectionalNavigationMap as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input_focus::directional_navigation::DirectionalNavigationMap = <::bevy_input_focus::directional_navigation::DirectionalNavigationMap as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -275,9 +263,8 @@ pub(crate) fn register_directional_navigation_map_functions(world: &mut World) { { let output: bool = <::bevy_input_focus::directional_navigation::DirectionalNavigationMap as ::core::cmp::PartialEq< ::bevy_input_focus::directional_navigation::DirectionalNavigationMap, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -296,11 +283,10 @@ pub(crate) fn register_directional_navigation_map_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_input_focus::directional_navigation::DirectionalNavigationMap::remove( - &mut _self, - entity.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(entity), + ); + safe_transmute(output) } }; output @@ -319,11 +305,10 @@ pub(crate) fn register_directional_navigation_map_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_input_focus::directional_navigation::DirectionalNavigationMap::remove_multiple( - &mut _self, - entities.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(entities), + ); + safe_transmute(output) } }; output @@ -350,13 +335,10 @@ pub(crate) fn register_nav_neighbors_functions(world: &mut World) { ::bevy_input_focus::directional_navigation::NavNeighbors, > = { { - let output: Val< - ::bevy_input_focus::directional_navigation::NavNeighbors, - > = <::bevy_input_focus::directional_navigation::NavNeighbors as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input_focus::directional_navigation::NavNeighbors = <::bevy_input_focus::directional_navigation::NavNeighbors as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -374,9 +356,8 @@ pub(crate) fn register_nav_neighbors_functions(world: &mut World) { { let output: bool = <::bevy_input_focus::directional_navigation::NavNeighbors as ::core::cmp::PartialEq< ::bevy_input_focus::directional_navigation::NavNeighbors, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -394,12 +375,11 @@ pub(crate) fn register_nav_neighbors_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_input_focus::directional_navigation::NavNeighbors::set( - &mut _self, - octant.into_inner(), - entity.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(octant), + safe_transmute(entity), + ); + safe_transmute(output) } }; output @@ -425,10 +405,9 @@ pub(crate) fn register_tab_index_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_input_focus::tab_navigation::TabIndex as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -441,11 +420,10 @@ pub(crate) fn register_tab_index_functions(world: &mut World) { |_self: Ref<::bevy_input_focus::tab_navigation::TabIndex>| { let output: Val<::bevy_input_focus::tab_navigation::TabIndex> = { { - let output: Val<::bevy_input_focus::tab_navigation::TabIndex> = <::bevy_input_focus::tab_navigation::TabIndex as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input_focus::tab_navigation::TabIndex = <::bevy_input_focus::tab_navigation::TabIndex as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -463,9 +441,8 @@ pub(crate) fn register_tab_index_functions(world: &mut World) { { let output: bool = <::bevy_input_focus::tab_navigation::TabIndex as ::core::cmp::PartialEq< ::bevy_input_focus::tab_navigation::TabIndex, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -490,11 +467,10 @@ pub(crate) fn register_tab_group_functions(world: &mut World) { |_self: Ref<::bevy_input_focus::tab_navigation::TabGroup>| { let output: Val<::bevy_input_focus::tab_navigation::TabGroup> = { { - let output: Val<::bevy_input_focus::tab_navigation::TabGroup> = <::bevy_input_focus::tab_navigation::TabGroup as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_input_focus::tab_navigation::TabGroup = <::bevy_input_focus::tab_navigation::TabGroup as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -507,9 +483,8 @@ pub(crate) fn register_tab_group_functions(world: &mut World) { || { let output: Val<::bevy_input_focus::tab_navigation::TabGroup> = { { - let output: Val<::bevy_input_focus::tab_navigation::TabGroup> = ::bevy_input_focus::tab_navigation::TabGroup::modal() - .into(); - output + let output: ::bevy_input_focus::tab_navigation::TabGroup = ::bevy_input_focus::tab_navigation::TabGroup::modal(); + safe_transmute(output) } }; output @@ -522,11 +497,10 @@ pub(crate) fn register_tab_group_functions(world: &mut World) { |order: i32| { let output: Val<::bevy_input_focus::tab_navigation::TabGroup> = { { - let output: Val<::bevy_input_focus::tab_navigation::TabGroup> = ::bevy_input_focus::tab_navigation::TabGroup::new( - order, - ) - .into(); - output + let output: ::bevy_input_focus::tab_navigation::TabGroup = ::bevy_input_focus::tab_navigation::TabGroup::new( + safe_transmute(order), + ); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_light_bms_bindings/src/lib.rs b/crates/bindings/bevy_light_bms_bindings/src/lib.rs index 10efa9ee5f..f785278507 100644 --- a/crates/bindings/bevy_light_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_light_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -24,11 +24,10 @@ pub(crate) fn register_clustered_decal_functions(world: &mut World) { |_self: Ref<::bevy_light::ClusteredDecal>| { let output: Val<::bevy_light::ClusteredDecal> = { { - let output: Val<::bevy_light::ClusteredDecal> = <::bevy_light::ClusteredDecal as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::ClusteredDecal = <::bevy_light::ClusteredDecal as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -53,11 +52,10 @@ pub(crate) fn register_ambient_light_functions(world: &mut World) { |_self: Ref<::bevy_light::AmbientLight>| { let output: Val<::bevy_light::AmbientLight> = { { - let output: Val<::bevy_light::AmbientLight> = <::bevy_light::AmbientLight as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::AmbientLight = <::bevy_light::AmbientLight as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -82,11 +80,10 @@ pub(crate) fn register_environment_map_light_functions(world: &mut World) { |_self: Ref<::bevy_light::EnvironmentMapLight>| { let output: Val<::bevy_light::EnvironmentMapLight> = { { - let output: Val<::bevy_light::EnvironmentMapLight> = <::bevy_light::EnvironmentMapLight as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::EnvironmentMapLight = <::bevy_light::EnvironmentMapLight as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -111,11 +108,10 @@ pub(crate) fn register_generated_environment_map_light_functions(world: &mut Wor |_self: Ref<::bevy_light::GeneratedEnvironmentMapLight>| { let output: Val<::bevy_light::GeneratedEnvironmentMapLight> = { { - let output: Val<::bevy_light::GeneratedEnvironmentMapLight> = <::bevy_light::GeneratedEnvironmentMapLight as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::GeneratedEnvironmentMapLight = <::bevy_light::GeneratedEnvironmentMapLight as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -140,11 +136,10 @@ pub(crate) fn register_irradiance_volume_functions(world: &mut World) { |_self: Ref<::bevy_light::IrradianceVolume>| { let output: Val<::bevy_light::IrradianceVolume> = { { - let output: Val<::bevy_light::IrradianceVolume> = <::bevy_light::IrradianceVolume as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::IrradianceVolume = <::bevy_light::IrradianceVolume as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -169,11 +164,10 @@ pub(crate) fn register_light_probe_functions(world: &mut World) { |_self: Ref<::bevy_light::LightProbe>| { let output: Val<::bevy_light::LightProbe> = { { - let output: Val<::bevy_light::LightProbe> = <::bevy_light::LightProbe as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::LightProbe = <::bevy_light::LightProbe as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -186,9 +180,8 @@ pub(crate) fn register_light_probe_functions(world: &mut World) { || { let output: Val<::bevy_light::LightProbe> = { { - let output: Val<::bevy_light::LightProbe> = ::bevy_light::LightProbe::new() - .into(); - output + let output: ::bevy_light::LightProbe = ::bevy_light::LightProbe::new(); + safe_transmute(output) } }; output @@ -213,11 +206,10 @@ pub(crate) fn register_fog_volume_functions(world: &mut World) { |_self: Ref<::bevy_light::FogVolume>| { let output: Val<::bevy_light::FogVolume> = { { - let output: Val<::bevy_light::FogVolume> = <::bevy_light::FogVolume as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::FogVolume = <::bevy_light::FogVolume as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -242,11 +234,10 @@ pub(crate) fn register_volumetric_fog_functions(world: &mut World) { |_self: Ref<::bevy_light::VolumetricFog>| { let output: Val<::bevy_light::VolumetricFog> = { { - let output: Val<::bevy_light::VolumetricFog> = <::bevy_light::VolumetricFog as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::VolumetricFog = <::bevy_light::VolumetricFog as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -271,11 +262,10 @@ pub(crate) fn register_volumetric_light_functions(world: &mut World) { |_self: Ref<::bevy_light::VolumetricLight>| { let output: Val<::bevy_light::VolumetricLight> = { { - let output: Val<::bevy_light::VolumetricLight> = <::bevy_light::VolumetricLight as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::VolumetricLight = <::bevy_light::VolumetricLight as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -300,11 +290,10 @@ pub(crate) fn register_cascade_shadow_config_functions(world: &mut World) { |_self: Ref<::bevy_light::CascadeShadowConfig>| { let output: Val<::bevy_light::CascadeShadowConfig> = { { - let output: Val<::bevy_light::CascadeShadowConfig> = <::bevy_light::CascadeShadowConfig as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::CascadeShadowConfig = <::bevy_light::CascadeShadowConfig as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -329,11 +318,10 @@ pub(crate) fn register_cascades_functions(world: &mut World) { |_self: Ref<::bevy_light::Cascades>| { let output: Val<::bevy_light::Cascades> = { { - let output: Val<::bevy_light::Cascades> = <::bevy_light::Cascades as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::Cascades = <::bevy_light::Cascades as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -358,11 +346,10 @@ pub(crate) fn register_point_light_functions(world: &mut World) { |_self: Ref<::bevy_light::PointLight>| { let output: Val<::bevy_light::PointLight> = { { - let output: Val<::bevy_light::PointLight> = <::bevy_light::PointLight as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::PointLight = <::bevy_light::PointLight as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -387,11 +374,10 @@ pub(crate) fn register_point_light_shadow_map_functions(world: &mut World) { |_self: Ref<::bevy_light::PointLightShadowMap>| { let output: Val<::bevy_light::PointLightShadowMap> = { { - let output: Val<::bevy_light::PointLightShadowMap> = <::bevy_light::PointLightShadowMap as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::PointLightShadowMap = <::bevy_light::PointLightShadowMap as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -416,11 +402,10 @@ pub(crate) fn register_point_light_texture_functions(world: &mut World) { |_self: Ref<::bevy_light::PointLightTexture>| { let output: Val<::bevy_light::PointLightTexture> = { { - let output: Val<::bevy_light::PointLightTexture> = <::bevy_light::PointLightTexture as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::PointLightTexture = <::bevy_light::PointLightTexture as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -445,11 +430,10 @@ pub(crate) fn register_spot_light_functions(world: &mut World) { |_self: Ref<::bevy_light::SpotLight>| { let output: Val<::bevy_light::SpotLight> = { { - let output: Val<::bevy_light::SpotLight> = <::bevy_light::SpotLight as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::SpotLight = <::bevy_light::SpotLight as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -474,11 +458,10 @@ pub(crate) fn register_spot_light_texture_functions(world: &mut World) { |_self: Ref<::bevy_light::SpotLightTexture>| { let output: Val<::bevy_light::SpotLightTexture> = { { - let output: Val<::bevy_light::SpotLightTexture> = <::bevy_light::SpotLightTexture as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::SpotLightTexture = <::bevy_light::SpotLightTexture as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -503,11 +486,10 @@ pub(crate) fn register_directional_light_functions(world: &mut World) { |_self: Ref<::bevy_light::DirectionalLight>| { let output: Val<::bevy_light::DirectionalLight> = { { - let output: Val<::bevy_light::DirectionalLight> = <::bevy_light::DirectionalLight as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::DirectionalLight = <::bevy_light::DirectionalLight as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -532,11 +514,10 @@ pub(crate) fn register_directional_light_shadow_map_functions(world: &mut World) |_self: Ref<::bevy_light::DirectionalLightShadowMap>| { let output: Val<::bevy_light::DirectionalLightShadowMap> = { { - let output: Val<::bevy_light::DirectionalLightShadowMap> = <::bevy_light::DirectionalLightShadowMap as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::DirectionalLightShadowMap = <::bevy_light::DirectionalLightShadowMap as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -561,11 +542,10 @@ pub(crate) fn register_directional_light_texture_functions(world: &mut World) { |_self: Ref<::bevy_light::DirectionalLightTexture>| { let output: Val<::bevy_light::DirectionalLightTexture> = { { - let output: Val<::bevy_light::DirectionalLightTexture> = <::bevy_light::DirectionalLightTexture as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::DirectionalLightTexture = <::bevy_light::DirectionalLightTexture as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -590,11 +570,10 @@ pub(crate) fn register_not_shadow_caster_functions(world: &mut World) { |_self: Ref<::bevy_light::NotShadowCaster>| { let output: Val<::bevy_light::NotShadowCaster> = { { - let output: Val<::bevy_light::NotShadowCaster> = <::bevy_light::NotShadowCaster as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::NotShadowCaster = <::bevy_light::NotShadowCaster as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -612,9 +591,8 @@ pub(crate) fn register_not_shadow_caster_functions(world: &mut World) { { let output: bool = <::bevy_light::NotShadowCaster as ::std::cmp::PartialEq< ::bevy_light::NotShadowCaster, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -664,10 +642,9 @@ pub(crate) fn register_shadow_filtering_method_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_light::ShadowFilteringMethod as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -680,11 +657,10 @@ pub(crate) fn register_shadow_filtering_method_functions(world: &mut World) { |_self: Ref<::bevy_light::ShadowFilteringMethod>| { let output: Val<::bevy_light::ShadowFilteringMethod> = { { - let output: Val<::bevy_light::ShadowFilteringMethod> = <::bevy_light::ShadowFilteringMethod as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::ShadowFilteringMethod = <::bevy_light::ShadowFilteringMethod as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -702,9 +678,8 @@ pub(crate) fn register_shadow_filtering_method_functions(world: &mut World) { { let output: bool = <::bevy_light::ShadowFilteringMethod as ::std::cmp::PartialEq< ::bevy_light::ShadowFilteringMethod, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -729,11 +704,10 @@ pub(crate) fn register_cluster_far_z_mode_functions(world: &mut World) { |_self: Ref<::bevy_light::cluster::ClusterFarZMode>| { let output: Val<::bevy_light::cluster::ClusterFarZMode> = { { - let output: Val<::bevy_light::cluster::ClusterFarZMode> = <::bevy_light::cluster::ClusterFarZMode as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::cluster::ClusterFarZMode = <::bevy_light::cluster::ClusterFarZMode as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -758,11 +732,10 @@ pub(crate) fn register_cluster_z_config_functions(world: &mut World) { |_self: Ref<::bevy_light::cluster::ClusterZConfig>| { let output: Val<::bevy_light::cluster::ClusterZConfig> = { { - let output: Val<::bevy_light::cluster::ClusterZConfig> = <::bevy_light::cluster::ClusterZConfig as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::cluster::ClusterZConfig = <::bevy_light::cluster::ClusterZConfig as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -787,11 +760,10 @@ pub(crate) fn register_cluster_config_functions(world: &mut World) { |_self: Ref<::bevy_light::cluster::ClusterConfig>| { let output: Val<::bevy_light::cluster::ClusterConfig> = { { - let output: Val<::bevy_light::cluster::ClusterConfig> = <::bevy_light::cluster::ClusterConfig as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::cluster::ClusterConfig = <::bevy_light::cluster::ClusterConfig as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -816,11 +788,10 @@ pub(crate) fn register_cascade_functions(world: &mut World) { |_self: Ref<::bevy_light::cascade::Cascade>| { let output: Val<::bevy_light::cascade::Cascade> = { { - let output: Val<::bevy_light::cascade::Cascade> = <::bevy_light::cascade::Cascade as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_light::cascade::Cascade = <::bevy_light::cascade::Cascade as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_math_bms_bindings/src/lib.rs b/crates/bindings/bevy_math_bms_bindings/src/lib.rs index 223da5c7b9..52a7de2e7b 100644 --- a/crates/bindings/bevy_math_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_math_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -24,11 +24,10 @@ pub(crate) fn register_aspect_ratio_functions(world: &mut World) { |_self: Ref<::bevy_math::AspectRatio>| { let output: Val<::bevy_math::AspectRatio> = { { - let output: Val<::bevy_math::AspectRatio> = <::bevy_math::AspectRatio as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::AspectRatio = <::bevy_math::AspectRatio as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -43,9 +42,8 @@ pub(crate) fn register_aspect_ratio_functions(world: &mut World) { { let output: bool = <::bevy_math::AspectRatio as ::core::cmp::PartialEq< ::bevy_math::AspectRatio, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -58,11 +56,10 @@ pub(crate) fn register_aspect_ratio_functions(world: &mut World) { |_self: Ref<::bevy_math::AspectRatio>| { let output: Val<::bevy_math::AspectRatio> = { { - let output: Val<::bevy_math::AspectRatio> = ::bevy_math::AspectRatio::inverse( - &_self, - ) - .into(); - output + let output: ::bevy_math::AspectRatio = ::bevy_math::AspectRatio::inverse( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -75,9 +72,10 @@ pub(crate) fn register_aspect_ratio_functions(world: &mut World) { |_self: Ref<::bevy_math::AspectRatio>| { let output: bool = { { - let output: bool = ::bevy_math::AspectRatio::is_landscape(&_self) - .into(); - output + let output: bool = ::bevy_math::AspectRatio::is_landscape( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -90,9 +88,10 @@ pub(crate) fn register_aspect_ratio_functions(world: &mut World) { |_self: Ref<::bevy_math::AspectRatio>| { let output: bool = { { - let output: bool = ::bevy_math::AspectRatio::is_portrait(&_self) - .into(); - output + let output: bool = ::bevy_math::AspectRatio::is_portrait( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -105,9 +104,10 @@ pub(crate) fn register_aspect_ratio_functions(world: &mut World) { |_self: Ref<::bevy_math::AspectRatio>| { let output: bool = { { - let output: bool = ::bevy_math::AspectRatio::is_square(&_self) - .into(); - output + let output: bool = ::bevy_math::AspectRatio::is_square( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -120,8 +120,10 @@ pub(crate) fn register_aspect_ratio_functions(world: &mut World) { |_self: Ref<::bevy_math::AspectRatio>| { let output: f32 = { { - let output: f32 = ::bevy_math::AspectRatio::ratio(&_self).into(); - output + let output: f32 = ::bevy_math::AspectRatio::ratio( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -147,10 +149,9 @@ pub(crate) fn register_compass_octant_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_math::CompassOctant as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -163,11 +164,10 @@ pub(crate) fn register_compass_octant_functions(world: &mut World) { |_self: Ref<::bevy_math::CompassOctant>| { let output: Val<::bevy_math::CompassOctant> = { { - let output: Val<::bevy_math::CompassOctant> = <::bevy_math::CompassOctant as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::CompassOctant = <::bevy_math::CompassOctant as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -185,9 +185,8 @@ pub(crate) fn register_compass_octant_functions(world: &mut World) { { let output: bool = <::bevy_math::CompassOctant as ::core::cmp::PartialEq< ::bevy_math::CompassOctant, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -200,11 +199,10 @@ pub(crate) fn register_compass_octant_functions(world: &mut World) { |_self: Val<::bevy_math::CompassOctant>| { let output: Val<::bevy_math::CompassOctant> = { { - let output: Val<::bevy_math::CompassOctant> = <::bevy_math::CompassOctant as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_math::CompassOctant = <::bevy_math::CompassOctant as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -217,11 +215,10 @@ pub(crate) fn register_compass_octant_functions(world: &mut World) { |_self: Ref<::bevy_math::CompassOctant>| { let output: Val<::bevy_math::CompassOctant> = { { - let output: Val<::bevy_math::CompassOctant> = ::bevy_math::CompassOctant::opposite( - &_self, - ) - .into(); - output + let output: ::bevy_math::CompassOctant = ::bevy_math::CompassOctant::opposite( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -235,10 +232,9 @@ pub(crate) fn register_compass_octant_functions(world: &mut World) { let output: usize = { { let output: usize = ::bevy_math::CompassOctant::to_index( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -264,10 +260,9 @@ pub(crate) fn register_compass_quadrant_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_math::CompassQuadrant as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -280,11 +275,10 @@ pub(crate) fn register_compass_quadrant_functions(world: &mut World) { |_self: Ref<::bevy_math::CompassQuadrant>| { let output: Val<::bevy_math::CompassQuadrant> = { { - let output: Val<::bevy_math::CompassQuadrant> = <::bevy_math::CompassQuadrant as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::CompassQuadrant = <::bevy_math::CompassQuadrant as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -302,9 +296,8 @@ pub(crate) fn register_compass_quadrant_functions(world: &mut World) { { let output: bool = <::bevy_math::CompassQuadrant as ::core::cmp::PartialEq< ::bevy_math::CompassQuadrant, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -317,11 +310,10 @@ pub(crate) fn register_compass_quadrant_functions(world: &mut World) { |_self: Val<::bevy_math::CompassQuadrant>| { let output: Val<::bevy_math::CompassQuadrant> = { { - let output: Val<::bevy_math::CompassQuadrant> = <::bevy_math::CompassQuadrant as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_math::CompassQuadrant = <::bevy_math::CompassQuadrant as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -334,11 +326,10 @@ pub(crate) fn register_compass_quadrant_functions(world: &mut World) { |_self: Ref<::bevy_math::CompassQuadrant>| { let output: Val<::bevy_math::CompassQuadrant> = { { - let output: Val<::bevy_math::CompassQuadrant> = ::bevy_math::CompassQuadrant::opposite( - &_self, - ) - .into(); - output + let output: ::bevy_math::CompassQuadrant = ::bevy_math::CompassQuadrant::opposite( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -352,10 +343,9 @@ pub(crate) fn register_compass_quadrant_functions(world: &mut World) { let output: usize = { { let output: usize = ::bevy_math::CompassQuadrant::to_index( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -380,11 +370,10 @@ pub(crate) fn register_isometry_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::Isometry2d>| { let output: Val<::bevy_math::Isometry2d> = { { - let output: Val<::bevy_math::Isometry2d> = <::bevy_math::Isometry2d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::Isometry2d = <::bevy_math::Isometry2d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -399,9 +388,8 @@ pub(crate) fn register_isometry_2_d_functions(world: &mut World) { { let output: bool = <::bevy_math::Isometry2d as ::core::cmp::PartialEq< ::bevy_math::Isometry2d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -414,11 +402,10 @@ pub(crate) fn register_isometry_2_d_functions(world: &mut World) { |rotation: Val<::bevy_math::Rot2>| { let output: Val<::bevy_math::Isometry2d> = { { - let output: Val<::bevy_math::Isometry2d> = ::bevy_math::Isometry2d::from_rotation( - rotation.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Isometry2d = ::bevy_math::Isometry2d::from_rotation( + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -431,11 +418,10 @@ pub(crate) fn register_isometry_2_d_functions(world: &mut World) { |translation: Val<::bevy_math::Vec2>| { let output: Val<::bevy_math::Isometry2d> = { { - let output: Val<::bevy_math::Isometry2d> = ::bevy_math::Isometry2d::from_translation( - translation.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Isometry2d = ::bevy_math::Isometry2d::from_translation( + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -448,12 +434,11 @@ pub(crate) fn register_isometry_2_d_functions(world: &mut World) { |x: f32, y: f32| { let output: Val<::bevy_math::Isometry2d> = { { - let output: Val<::bevy_math::Isometry2d> = ::bevy_math::Isometry2d::from_xy( - x, - y, - ) - .into(); - output + let output: ::bevy_math::Isometry2d = ::bevy_math::Isometry2d::from_xy( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -466,11 +451,10 @@ pub(crate) fn register_isometry_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::Isometry2d>| { let output: Val<::bevy_math::Isometry2d> = { { - let output: Val<::bevy_math::Isometry2d> = ::bevy_math::Isometry2d::inverse( - &_self, - ) - .into(); - output + let output: ::bevy_math::Isometry2d = ::bevy_math::Isometry2d::inverse( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -483,12 +467,11 @@ pub(crate) fn register_isometry_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::Isometry2d>, rhs: Val<::bevy_math::Isometry2d>| { let output: Val<::bevy_math::Isometry2d> = { { - let output: Val<::bevy_math::Isometry2d> = ::bevy_math::Isometry2d::inverse_mul( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Isometry2d = ::bevy_math::Isometry2d::inverse_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -501,12 +484,11 @@ pub(crate) fn register_isometry_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::Isometry2d>, point: Val<::bevy_math::Vec2>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::Isometry2d::inverse_transform_point( - &_self, - point.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::Isometry2d::inverse_transform_point( + safe_transmute(_self), + safe_transmute(point), + ); + safe_transmute(output) } }; output @@ -519,11 +501,10 @@ pub(crate) fn register_isometry_2_d_functions(world: &mut World) { |_self: Val<::bevy_math::Isometry2d>, rhs: Val<::bevy_math::Dir2>| { let output: Val<::bevy_math::Dir2> = { { - let output: Val<::bevy_math::Dir2> = <::bevy_math::Isometry2d as ::core::ops::Mul< + let output: ::bevy_math::Dir2 = <::bevy_math::Isometry2d as ::core::ops::Mul< ::bevy_math::Dir2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -536,11 +517,10 @@ pub(crate) fn register_isometry_2_d_functions(world: &mut World) { |_self: Val<::bevy_math::Isometry2d>, rhs: Val<::bevy_math::Isometry2d>| { let output: Val<::bevy_math::Isometry2d> = { { - let output: Val<::bevy_math::Isometry2d> = <::bevy_math::Isometry2d as ::core::ops::Mul< + let output: ::bevy_math::Isometry2d = <::bevy_math::Isometry2d as ::core::ops::Mul< ::bevy_math::Isometry2d, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -553,11 +533,10 @@ pub(crate) fn register_isometry_2_d_functions(world: &mut World) { |_self: Val<::bevy_math::Isometry2d>, rhs: Val<::bevy_math::Vec2>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = <::bevy_math::Isometry2d as ::core::ops::Mul< + let output: ::bevy_math::Vec2 = <::bevy_math::Isometry2d as ::core::ops::Mul< ::bevy_math::Vec2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -570,12 +549,11 @@ pub(crate) fn register_isometry_2_d_functions(world: &mut World) { |translation: Val<::bevy_math::Vec2>, rotation: Val<::bevy_math::Rot2>| { let output: Val<::bevy_math::Isometry2d> = { { - let output: Val<::bevy_math::Isometry2d> = ::bevy_math::Isometry2d::new( - translation.into_inner(), - rotation.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Isometry2d = ::bevy_math::Isometry2d::new( + safe_transmute(translation), + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -588,12 +566,11 @@ pub(crate) fn register_isometry_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::Isometry2d>, point: Val<::bevy_math::Vec2>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::Isometry2d::transform_point( - &_self, - point.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::Isometry2d::transform_point( + safe_transmute(_self), + safe_transmute(point), + ); + safe_transmute(output) } }; output @@ -618,11 +595,10 @@ pub(crate) fn register_isometry_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::Isometry3d>| { let output: Val<::bevy_math::Isometry3d> = { { - let output: Val<::bevy_math::Isometry3d> = <::bevy_math::Isometry3d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::Isometry3d = <::bevy_math::Isometry3d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -637,9 +613,8 @@ pub(crate) fn register_isometry_3_d_functions(world: &mut World) { { let output: bool = <::bevy_math::Isometry3d as ::core::cmp::PartialEq< ::bevy_math::Isometry3d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -652,11 +627,10 @@ pub(crate) fn register_isometry_3_d_functions(world: &mut World) { |rotation: Val<::bevy_math::Quat>| { let output: Val<::bevy_math::Isometry3d> = { { - let output: Val<::bevy_math::Isometry3d> = ::bevy_math::Isometry3d::from_rotation( - rotation.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Isometry3d = ::bevy_math::Isometry3d::from_rotation( + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -669,13 +643,12 @@ pub(crate) fn register_isometry_3_d_functions(world: &mut World) { |x: f32, y: f32, z: f32| { let output: Val<::bevy_math::Isometry3d> = { { - let output: Val<::bevy_math::Isometry3d> = ::bevy_math::Isometry3d::from_xyz( - x, - y, - z, - ) - .into(); - output + let output: ::bevy_math::Isometry3d = ::bevy_math::Isometry3d::from_xyz( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -688,11 +661,10 @@ pub(crate) fn register_isometry_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::Isometry3d>| { let output: Val<::bevy_math::Isometry3d> = { { - let output: Val<::bevy_math::Isometry3d> = ::bevy_math::Isometry3d::inverse( - &_self, - ) - .into(); - output + let output: ::bevy_math::Isometry3d = ::bevy_math::Isometry3d::inverse( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -705,12 +677,11 @@ pub(crate) fn register_isometry_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::Isometry3d>, rhs: Val<::bevy_math::Isometry3d>| { let output: Val<::bevy_math::Isometry3d> = { { - let output: Val<::bevy_math::Isometry3d> = ::bevy_math::Isometry3d::inverse_mul( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Isometry3d = ::bevy_math::Isometry3d::inverse_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -723,11 +694,10 @@ pub(crate) fn register_isometry_3_d_functions(world: &mut World) { |_self: Val<::bevy_math::Isometry3d>, rhs: Val<::bevy_math::Dir3>| { let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::Dir3> = <::bevy_math::Isometry3d as ::core::ops::Mul< + let output: ::bevy_math::Dir3 = <::bevy_math::Isometry3d as ::core::ops::Mul< ::bevy_math::Dir3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -740,11 +710,10 @@ pub(crate) fn register_isometry_3_d_functions(world: &mut World) { |_self: Val<::bevy_math::Isometry3d>, rhs: Val<::bevy_math::Isometry3d>| { let output: Val<::bevy_math::Isometry3d> = { { - let output: Val<::bevy_math::Isometry3d> = <::bevy_math::Isometry3d as ::core::ops::Mul< + let output: ::bevy_math::Isometry3d = <::bevy_math::Isometry3d as ::core::ops::Mul< ::bevy_math::Isometry3d, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -757,11 +726,10 @@ pub(crate) fn register_isometry_3_d_functions(world: &mut World) { |_self: Val<::bevy_math::Isometry3d>, rhs: Val<::bevy_math::Vec3>| { let output: Val<::bevy_math::Vec3> = { { - let output: Val<::bevy_math::Vec3> = <::bevy_math::Isometry3d as ::core::ops::Mul< + let output: ::bevy_math::Vec3 = <::bevy_math::Isometry3d as ::core::ops::Mul< ::bevy_math::Vec3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -774,11 +742,10 @@ pub(crate) fn register_isometry_3_d_functions(world: &mut World) { |_self: Val<::bevy_math::Isometry3d>, rhs: Val<::bevy_math::Vec3A>| { let output: Val<::bevy_math::Vec3A> = { { - let output: Val<::bevy_math::Vec3A> = <::bevy_math::Isometry3d as ::core::ops::Mul< + let output: ::bevy_math::Vec3A = <::bevy_math::Isometry3d as ::core::ops::Mul< ::bevy_math::Vec3A, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -803,11 +770,10 @@ pub(crate) fn register_ray_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::Ray2d>| { let output: Val<::bevy_math::Ray2d> = { { - let output: Val<::bevy_math::Ray2d> = <::bevy_math::Ray2d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::Ray2d = <::bevy_math::Ray2d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -822,9 +788,8 @@ pub(crate) fn register_ray_2_d_functions(world: &mut World) { { let output: bool = <::bevy_math::Ray2d as ::core::cmp::PartialEq< ::bevy_math::Ray2d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -837,12 +802,11 @@ pub(crate) fn register_ray_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::Ray2d>, distance: f32| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::Ray2d::get_point( - &_self, - distance, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::Ray2d::get_point( + safe_transmute(_self), + safe_transmute(distance), + ); + safe_transmute(output) } }; output @@ -860,12 +824,11 @@ pub(crate) fn register_ray_2_d_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::bevy_math::Ray2d::intersect_plane( - &_self, - plane_origin.into_inner(), - plane.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(plane_origin), + safe_transmute(plane), + ); + safe_transmute(output) } }; output @@ -878,12 +841,11 @@ pub(crate) fn register_ray_2_d_functions(world: &mut World) { |origin: Val<::bevy_math::Vec2>, direction: Val<::bevy_math::Dir2>| { let output: Val<::bevy_math::Ray2d> = { { - let output: Val<::bevy_math::Ray2d> = ::bevy_math::Ray2d::new( - origin.into_inner(), - direction.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Ray2d = ::bevy_math::Ray2d::new( + safe_transmute(origin), + safe_transmute(direction), + ); + safe_transmute(output) } }; output @@ -908,11 +870,10 @@ pub(crate) fn register_ray_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::Ray3d>| { let output: Val<::bevy_math::Ray3d> = { { - let output: Val<::bevy_math::Ray3d> = <::bevy_math::Ray3d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::Ray3d = <::bevy_math::Ray3d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -927,9 +888,8 @@ pub(crate) fn register_ray_3_d_functions(world: &mut World) { { let output: bool = <::bevy_math::Ray3d as ::core::cmp::PartialEq< ::bevy_math::Ray3d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -942,12 +902,11 @@ pub(crate) fn register_ray_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::Ray3d>, distance: f32| { let output: Val<::bevy_math::Vec3> = { { - let output: Val<::bevy_math::Vec3> = ::bevy_math::Ray3d::get_point( - &_self, - distance, - ) - .into(); - output + let output: ::bevy_math::Vec3 = ::bevy_math::Ray3d::get_point( + safe_transmute(_self), + safe_transmute(distance), + ); + safe_transmute(output) } }; output @@ -965,12 +924,11 @@ pub(crate) fn register_ray_3_d_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::bevy_math::Ray3d::intersect_plane( - &_self, - plane_origin.into_inner(), - plane.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(plane_origin), + safe_transmute(plane), + ); + safe_transmute(output) } }; output @@ -983,12 +941,11 @@ pub(crate) fn register_ray_3_d_functions(world: &mut World) { |origin: Val<::bevy_math::Vec3>, direction: Val<::bevy_math::Dir3>| { let output: Val<::bevy_math::Ray3d> = { { - let output: Val<::bevy_math::Ray3d> = ::bevy_math::Ray3d::new( - origin.into_inner(), - direction.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Ray3d = ::bevy_math::Ray3d::new( + safe_transmute(origin), + safe_transmute(direction), + ); + safe_transmute(output) } }; output @@ -1014,11 +971,10 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::Rot2::angle_to( - _self.into_inner(), - other.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -1032,10 +988,9 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::Rot2::as_degrees( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1049,10 +1004,9 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::Rot2::as_radians( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1066,10 +1020,9 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::Rot2::as_turn_fraction( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1082,11 +1035,10 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { |_self: Ref<::bevy_math::Rot2>| { let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::Rot2> = <::bevy_math::Rot2 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::Rot2 = <::bevy_math::Rot2 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1099,11 +1051,10 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { |degrees: f32| { let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::Rot2> = ::bevy_math::Rot2::degrees( - degrees, - ) - .into(); - output + let output: ::bevy_math::Rot2 = ::bevy_math::Rot2::degrees( + safe_transmute(degrees), + ); + safe_transmute(output) } }; output @@ -1118,9 +1069,8 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { { let output: bool = <::bevy_math::Rot2 as ::core::cmp::PartialEq< ::bevy_math::Rot2, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1133,11 +1083,10 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { |_self: Val<::bevy_math::Rot2>| { let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::Rot2> = ::bevy_math::Rot2::fast_renormalize( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Rot2 = ::bevy_math::Rot2::fast_renormalize( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1150,12 +1099,11 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { |sin: f32, cos: f32| { let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::Rot2> = ::bevy_math::Rot2::from_sin_cos( - sin, - cos, - ) - .into(); - output + let output: ::bevy_math::Rot2 = ::bevy_math::Rot2::from_sin_cos( + safe_transmute(sin), + safe_transmute(cos), + ); + safe_transmute(output) } }; output @@ -1168,11 +1116,10 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { |_self: Val<::bevy_math::Rot2>| { let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::Rot2> = ::bevy_math::Rot2::inverse( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Rot2 = ::bevy_math::Rot2::inverse( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1186,10 +1133,9 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_math::Rot2::is_finite( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1202,9 +1148,10 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { |_self: Val<::bevy_math::Rot2>| { let output: bool = { { - let output: bool = ::bevy_math::Rot2::is_nan(_self.into_inner()) - .into(); - output + let output: bool = ::bevy_math::Rot2::is_nan( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1218,10 +1165,9 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_math::Rot2::is_near_identity( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1235,10 +1181,9 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_math::Rot2::is_normalized( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1251,9 +1196,10 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { |_self: Val<::bevy_math::Rot2>| { let output: f32 = { { - let output: f32 = ::bevy_math::Rot2::length(_self.into_inner()) - .into(); - output + let output: f32 = ::bevy_math::Rot2::length( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1267,10 +1213,9 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::Rot2::length_recip( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1284,10 +1229,9 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::Rot2::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1300,11 +1244,10 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { |_self: Val<::bevy_math::Rot2>, direction: Val<::bevy_math::Dir2>| { let output: Val<::bevy_math::Dir2> = { { - let output: Val<::bevy_math::Dir2> = <::bevy_math::Rot2 as ::core::ops::Mul< + let output: ::bevy_math::Dir2 = <::bevy_math::Rot2 as ::core::ops::Mul< ::bevy_math::Dir2, - >>::mul(_self.into_inner(), direction.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(direction)); + safe_transmute(output) } }; output @@ -1317,11 +1260,10 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { |_self: Val<::bevy_math::Rot2>, rhs: Val<::bevy_math::Rot2>| { let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::Rot2> = <::bevy_math::Rot2 as ::core::ops::Mul< + let output: ::bevy_math::Rot2 = <::bevy_math::Rot2 as ::core::ops::Mul< ::bevy_math::Rot2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -1334,11 +1276,10 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { |_self: Val<::bevy_math::Rot2>, rhs: Val<::bevy_math::Vec2>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = <::bevy_math::Rot2 as ::core::ops::Mul< + let output: ::bevy_math::Vec2 = <::bevy_math::Rot2 as ::core::ops::Mul< ::bevy_math::Vec2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -1351,13 +1292,12 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { |_self: Val<::bevy_math::Rot2>, end: Val<::bevy_math::Rot2>, s: f32| { let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::Rot2> = ::bevy_math::Rot2::nlerp( - _self.into_inner(), - end.into_inner(), - s, - ) - .into(); - output + let output: ::bevy_math::Rot2 = ::bevy_math::Rot2::nlerp( + safe_transmute(_self), + safe_transmute(end), + safe_transmute(s), + ); + safe_transmute(output) } }; output @@ -1370,11 +1310,10 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { |_self: Val<::bevy_math::Rot2>| { let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::Rot2> = ::bevy_math::Rot2::normalize( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Rot2 = ::bevy_math::Rot2::normalize( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1387,11 +1326,10 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { |radians: f32| { let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::Rot2> = ::bevy_math::Rot2::radians( - radians, - ) - .into(); - output + let output: ::bevy_math::Rot2 = ::bevy_math::Rot2::radians( + safe_transmute(radians), + ); + safe_transmute(output) } }; output @@ -1405,10 +1343,9 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { let output: (f32, f32) = { { let output: (f32, f32) = ::bevy_math::Rot2::sin_cos( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1421,13 +1358,12 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { |_self: Val<::bevy_math::Rot2>, end: Val<::bevy_math::Rot2>, s: f32| { let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::Rot2> = ::bevy_math::Rot2::slerp( - _self.into_inner(), - end.into_inner(), - s, - ) - .into(); - output + let output: ::bevy_math::Rot2 = ::bevy_math::Rot2::slerp( + safe_transmute(_self), + safe_transmute(end), + safe_transmute(s), + ); + safe_transmute(output) } }; output @@ -1440,11 +1376,10 @@ pub(crate) fn register_rot_2_functions(world: &mut World) { |fraction: f32| { let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::Rot2> = ::bevy_math::Rot2::turn_fraction( - fraction, - ) - .into(); - output + let output: ::bevy_math::Rot2 = ::bevy_math::Rot2::turn_fraction( + safe_transmute(fraction), + ); + safe_transmute(output) } }; output @@ -1469,11 +1404,10 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { |_self: Ref<::bevy_math::Dir2>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::Dir2::as_vec2( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::Dir2::as_vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1486,11 +1420,10 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { |_self: Ref<::bevy_math::Dir2>| { let output: Val<::bevy_math::Dir2> = { { - let output: Val<::bevy_math::Dir2> = <::bevy_math::Dir2 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::Dir2 = <::bevy_math::Dir2 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1505,9 +1438,8 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { { let output: bool = <::bevy_math::Dir2 as ::core::cmp::PartialEq< ::bevy_math::Dir2, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1520,11 +1452,10 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { |_self: Val<::bevy_math::Dir2>| { let output: Val<::bevy_math::Dir2> = { { - let output: Val<::bevy_math::Dir2> = ::bevy_math::Dir2::fast_renormalize( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Dir2 = ::bevy_math::Dir2::fast_renormalize( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1537,12 +1468,11 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { |x: f32, y: f32| { let output: Val<::bevy_math::Dir2> = { { - let output: Val<::bevy_math::Dir2> = ::bevy_math::Dir2::from_xy_unchecked( - x, - y, - ) - .into(); - output + let output: ::bevy_math::Dir2 = ::bevy_math::Dir2::from_xy_unchecked( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -1555,11 +1485,10 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { |_self: Val<::bevy_math::Dir2>, rhs: f32| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = <::bevy_math::Dir2 as ::core::ops::Mul< + let output: ::bevy_math::Vec2 = <::bevy_math::Dir2 as ::core::ops::Mul< f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -1572,11 +1501,10 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { |_self: Val<::bevy_math::Dir2>| { let output: Val<::bevy_math::Dir2> = { { - let output: Val<::bevy_math::Dir2> = <::bevy_math::Dir2 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Dir2 = <::bevy_math::Dir2 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1589,11 +1517,10 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { |value: Val<::bevy_math::Vec2>| { let output: Val<::bevy_math::Dir2> = { { - let output: Val<::bevy_math::Dir2> = ::bevy_math::Dir2::new_unchecked( - value.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Dir2 = ::bevy_math::Dir2::new_unchecked( + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -1606,12 +1533,11 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { |_self: Val<::bevy_math::Dir2>, other: Val<::bevy_math::Dir2>| { let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::Rot2> = ::bevy_math::Dir2::rotation_from( - _self.into_inner(), - other.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Rot2 = ::bevy_math::Dir2::rotation_from( + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -1624,11 +1550,10 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { |_self: Val<::bevy_math::Dir2>| { let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::Rot2> = ::bevy_math::Dir2::rotation_from_x( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Rot2 = ::bevy_math::Dir2::rotation_from_x( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1641,11 +1566,10 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { |_self: Val<::bevy_math::Dir2>| { let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::Rot2> = ::bevy_math::Dir2::rotation_from_y( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Rot2 = ::bevy_math::Dir2::rotation_from_y( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1658,12 +1582,11 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { |_self: Val<::bevy_math::Dir2>, other: Val<::bevy_math::Dir2>| { let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::Rot2> = ::bevy_math::Dir2::rotation_to( - _self.into_inner(), - other.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Rot2 = ::bevy_math::Dir2::rotation_to( + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -1676,11 +1599,10 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { |_self: Val<::bevy_math::Dir2>| { let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::Rot2> = ::bevy_math::Dir2::rotation_to_x( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Rot2 = ::bevy_math::Dir2::rotation_to_x( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1693,11 +1615,10 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { |_self: Val<::bevy_math::Dir2>| { let output: Val<::bevy_math::Rot2> = { { - let output: Val<::bevy_math::Rot2> = ::bevy_math::Dir2::rotation_to_y( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Rot2 = ::bevy_math::Dir2::rotation_to_y( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1710,13 +1631,12 @@ pub(crate) fn register_dir_2_functions(world: &mut World) { |_self: Val<::bevy_math::Dir2>, rhs: Val<::bevy_math::Dir2>, s: f32| { let output: Val<::bevy_math::Dir2> = { { - let output: Val<::bevy_math::Dir2> = ::bevy_math::Dir2::slerp( - _self.into_inner(), - rhs.into_inner(), - s, - ) - .into(); - output + let output: ::bevy_math::Dir2 = ::bevy_math::Dir2::slerp( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(s), + ); + safe_transmute(output) } }; output @@ -1741,11 +1661,10 @@ pub(crate) fn register_dir_3_functions(world: &mut World) { |_self: Ref<::bevy_math::Dir3>| { let output: Val<::bevy_math::Vec3> = { { - let output: Val<::bevy_math::Vec3> = ::bevy_math::Dir3::as_vec3( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec3 = ::bevy_math::Dir3::as_vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1758,11 +1677,10 @@ pub(crate) fn register_dir_3_functions(world: &mut World) { |_self: Ref<::bevy_math::Dir3>| { let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::Dir3> = <::bevy_math::Dir3 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::Dir3 = <::bevy_math::Dir3 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1777,9 +1695,8 @@ pub(crate) fn register_dir_3_functions(world: &mut World) { { let output: bool = <::bevy_math::Dir3 as ::core::cmp::PartialEq< ::bevy_math::Dir3, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1792,11 +1709,10 @@ pub(crate) fn register_dir_3_functions(world: &mut World) { |_self: Val<::bevy_math::Dir3>| { let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::Dir3> = ::bevy_math::Dir3::fast_renormalize( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Dir3 = ::bevy_math::Dir3::fast_renormalize( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1809,13 +1725,12 @@ pub(crate) fn register_dir_3_functions(world: &mut World) { |x: f32, y: f32, z: f32| { let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::Dir3> = ::bevy_math::Dir3::from_xyz_unchecked( - x, - y, - z, - ) - .into(); - output + let output: ::bevy_math::Dir3 = ::bevy_math::Dir3::from_xyz_unchecked( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -1828,11 +1743,10 @@ pub(crate) fn register_dir_3_functions(world: &mut World) { |_self: Val<::bevy_math::Dir3>, rhs: f32| { let output: Val<::bevy_math::Vec3> = { { - let output: Val<::bevy_math::Vec3> = <::bevy_math::Dir3 as ::core::ops::Mul< + let output: ::bevy_math::Vec3 = <::bevy_math::Dir3 as ::core::ops::Mul< f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -1845,11 +1759,10 @@ pub(crate) fn register_dir_3_functions(world: &mut World) { |_self: Val<::bevy_math::Dir3>| { let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::Dir3> = <::bevy_math::Dir3 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Dir3 = <::bevy_math::Dir3 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1862,11 +1775,10 @@ pub(crate) fn register_dir_3_functions(world: &mut World) { |value: Val<::bevy_math::Vec3>| { let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::Dir3> = ::bevy_math::Dir3::new_unchecked( - value.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Dir3 = ::bevy_math::Dir3::new_unchecked( + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -1879,13 +1791,12 @@ pub(crate) fn register_dir_3_functions(world: &mut World) { |_self: Val<::bevy_math::Dir3>, rhs: Val<::bevy_math::Dir3>, s: f32| { let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::Dir3> = ::bevy_math::Dir3::slerp( - _self.into_inner(), - rhs.into_inner(), - s, - ) - .into(); - output + let output: ::bevy_math::Dir3 = ::bevy_math::Dir3::slerp( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(s), + ); + safe_transmute(output) } }; output @@ -1910,11 +1821,10 @@ pub(crate) fn register_dir_3_a_functions(world: &mut World) { |_self: Ref<::bevy_math::Dir3A>| { let output: Val<::bevy_math::Vec3A> = { { - let output: Val<::bevy_math::Vec3A> = ::bevy_math::Dir3A::as_vec3a( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec3A = ::bevy_math::Dir3A::as_vec3a( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1927,11 +1837,10 @@ pub(crate) fn register_dir_3_a_functions(world: &mut World) { |_self: Ref<::bevy_math::Dir3A>| { let output: Val<::bevy_math::Dir3A> = { { - let output: Val<::bevy_math::Dir3A> = <::bevy_math::Dir3A as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::Dir3A = <::bevy_math::Dir3A as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1946,9 +1855,8 @@ pub(crate) fn register_dir_3_a_functions(world: &mut World) { { let output: bool = <::bevy_math::Dir3A as ::core::cmp::PartialEq< ::bevy_math::Dir3A, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1961,11 +1869,10 @@ pub(crate) fn register_dir_3_a_functions(world: &mut World) { |_self: Val<::bevy_math::Dir3A>| { let output: Val<::bevy_math::Dir3A> = { { - let output: Val<::bevy_math::Dir3A> = ::bevy_math::Dir3A::fast_renormalize( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Dir3A = ::bevy_math::Dir3A::fast_renormalize( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1978,13 +1885,12 @@ pub(crate) fn register_dir_3_a_functions(world: &mut World) { |x: f32, y: f32, z: f32| { let output: Val<::bevy_math::Dir3A> = { { - let output: Val<::bevy_math::Dir3A> = ::bevy_math::Dir3A::from_xyz_unchecked( - x, - y, - z, - ) - .into(); - output + let output: ::bevy_math::Dir3A = ::bevy_math::Dir3A::from_xyz_unchecked( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -1997,11 +1903,10 @@ pub(crate) fn register_dir_3_a_functions(world: &mut World) { |_self: Val<::bevy_math::Dir3A>, rhs: f32| { let output: Val<::bevy_math::Vec3A> = { { - let output: Val<::bevy_math::Vec3A> = <::bevy_math::Dir3A as ::core::ops::Mul< + let output: ::bevy_math::Vec3A = <::bevy_math::Dir3A as ::core::ops::Mul< f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -2014,11 +1919,10 @@ pub(crate) fn register_dir_3_a_functions(world: &mut World) { |_self: Val<::bevy_math::Dir3A>| { let output: Val<::bevy_math::Dir3A> = { { - let output: Val<::bevy_math::Dir3A> = <::bevy_math::Dir3A as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Dir3A = <::bevy_math::Dir3A as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2031,11 +1935,10 @@ pub(crate) fn register_dir_3_a_functions(world: &mut World) { |value: Val<::bevy_math::Vec3A>| { let output: Val<::bevy_math::Dir3A> = { { - let output: Val<::bevy_math::Dir3A> = ::bevy_math::Dir3A::new_unchecked( - value.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Dir3A = ::bevy_math::Dir3A::new_unchecked( + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -2048,13 +1951,12 @@ pub(crate) fn register_dir_3_a_functions(world: &mut World) { |_self: Val<::bevy_math::Dir3A>, rhs: Val<::bevy_math::Dir3A>, s: f32| { let output: Val<::bevy_math::Dir3A> = { { - let output: Val<::bevy_math::Dir3A> = ::bevy_math::Dir3A::slerp( - _self.into_inner(), - rhs.into_inner(), - s, - ) - .into(); - output + let output: ::bevy_math::Dir3A = ::bevy_math::Dir3A::slerp( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(s), + ); + safe_transmute(output) } }; output @@ -2079,11 +1981,10 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::IRect>| { let output: Val<::bevy_math::Rect> = { { - let output: Val<::bevy_math::Rect> = ::bevy_math::IRect::as_rect( - &_self, - ) - .into(); - output + let output: ::bevy_math::Rect = ::bevy_math::IRect::as_rect( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2096,11 +1997,10 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::IRect>| { let output: Val<::bevy_math::URect> = { { - let output: Val<::bevy_math::URect> = ::bevy_math::IRect::as_urect( - &_self, - ) - .into(); - output + let output: ::bevy_math::URect = ::bevy_math::IRect::as_urect( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2114,10 +2014,9 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_math::IRect as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2130,11 +2029,10 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::IRect>| { let output: Val<::bevy_math::IVec2> = { { - let output: Val<::bevy_math::IVec2> = ::bevy_math::IRect::center( - &_self, - ) - .into(); - output + let output: ::bevy_math::IVec2 = ::bevy_math::IRect::center( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2147,11 +2045,10 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::IRect>| { let output: Val<::bevy_math::IRect> = { { - let output: Val<::bevy_math::IRect> = <::bevy_math::IRect as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::IRect = <::bevy_math::IRect as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2165,11 +2062,10 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_math::IRect::contains( - &_self, - point.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(point), + ); + safe_transmute(output) } }; output @@ -2184,9 +2080,8 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { { let output: bool = <::bevy_math::IRect as ::core::cmp::PartialEq< ::bevy_math::IRect, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2199,12 +2094,11 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { |origin: Val<::bevy_math::IVec2>, half_size: Val<::bevy_math::IVec2>| { let output: Val<::bevy_math::IRect> = { { - let output: Val<::bevy_math::IRect> = ::bevy_math::IRect::from_center_half_size( - origin.into_inner(), - half_size.into_inner(), - ) - .into(); - output + let output: ::bevy_math::IRect = ::bevy_math::IRect::from_center_half_size( + safe_transmute(origin), + safe_transmute(half_size), + ); + safe_transmute(output) } }; output @@ -2217,12 +2111,11 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { |origin: Val<::bevy_math::IVec2>, size: Val<::bevy_math::IVec2>| { let output: Val<::bevy_math::IRect> = { { - let output: Val<::bevy_math::IRect> = ::bevy_math::IRect::from_center_size( - origin.into_inner(), - size.into_inner(), - ) - .into(); - output + let output: ::bevy_math::IRect = ::bevy_math::IRect::from_center_size( + safe_transmute(origin), + safe_transmute(size), + ); + safe_transmute(output) } }; output @@ -2235,12 +2128,11 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { |p0: Val<::bevy_math::IVec2>, p1: Val<::bevy_math::IVec2>| { let output: Val<::bevy_math::IRect> = { { - let output: Val<::bevy_math::IRect> = ::bevy_math::IRect::from_corners( - p0.into_inner(), - p1.into_inner(), - ) - .into(); - output + let output: ::bevy_math::IRect = ::bevy_math::IRect::from_corners( + safe_transmute(p0), + safe_transmute(p1), + ); + safe_transmute(output) } }; output @@ -2253,11 +2145,10 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::IRect>| { let output: Val<::bevy_math::IVec2> = { { - let output: Val<::bevy_math::IVec2> = ::bevy_math::IRect::half_size( - &_self, - ) - .into(); - output + let output: ::bevy_math::IVec2 = ::bevy_math::IRect::half_size( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2270,8 +2161,10 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::IRect>| { let output: i32 = { { - let output: i32 = ::bevy_math::IRect::height(&_self).into(); - output + let output: i32 = ::bevy_math::IRect::height( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2284,12 +2177,11 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::IRect>, expansion: i32| { let output: Val<::bevy_math::IRect> = { { - let output: Val<::bevy_math::IRect> = ::bevy_math::IRect::inflate( - &_self, - expansion, - ) - .into(); - output + let output: ::bevy_math::IRect = ::bevy_math::IRect::inflate( + safe_transmute(_self), + safe_transmute(expansion), + ); + safe_transmute(output) } }; output @@ -2302,12 +2194,11 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::IRect>, other: Val<::bevy_math::IRect>| { let output: Val<::bevy_math::IRect> = { { - let output: Val<::bevy_math::IRect> = ::bevy_math::IRect::intersect( - &_self, - other.into_inner(), - ) - .into(); - output + let output: ::bevy_math::IRect = ::bevy_math::IRect::intersect( + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -2320,8 +2211,10 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::IRect>| { let output: bool = { { - let output: bool = ::bevy_math::IRect::is_empty(&_self).into(); - output + let output: bool = ::bevy_math::IRect::is_empty( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2334,14 +2227,13 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { |x0: i32, y0: i32, x1: i32, y1: i32| { let output: Val<::bevy_math::IRect> = { { - let output: Val<::bevy_math::IRect> = ::bevy_math::IRect::new( - x0, - y0, - x1, - y1, - ) - .into(); - output + let output: ::bevy_math::IRect = ::bevy_math::IRect::new( + safe_transmute(x0), + safe_transmute(y0), + safe_transmute(x1), + safe_transmute(y1), + ); + safe_transmute(output) } }; output @@ -2354,11 +2246,10 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::IRect>| { let output: Val<::bevy_math::IVec2> = { { - let output: Val<::bevy_math::IVec2> = ::bevy_math::IRect::size( - &_self, - ) - .into(); - output + let output: ::bevy_math::IVec2 = ::bevy_math::IRect::size( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2371,12 +2262,11 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::IRect>, other: Val<::bevy_math::IRect>| { let output: Val<::bevy_math::IRect> = { { - let output: Val<::bevy_math::IRect> = ::bevy_math::IRect::union( - &_self, - other.into_inner(), - ) - .into(); - output + let output: ::bevy_math::IRect = ::bevy_math::IRect::union( + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -2389,12 +2279,11 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::IRect>, other: Val<::bevy_math::IVec2>| { let output: Val<::bevy_math::IRect> = { { - let output: Val<::bevy_math::IRect> = ::bevy_math::IRect::union_point( - &_self, - other.into_inner(), - ) - .into(); - output + let output: ::bevy_math::IRect = ::bevy_math::IRect::union_point( + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -2407,8 +2296,10 @@ pub(crate) fn register_i_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::IRect>| { let output: i32 = { { - let output: i32 = ::bevy_math::IRect::width(&_self).into(); - output + let output: i32 = ::bevy_math::IRect::width( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2433,11 +2324,10 @@ pub(crate) fn register_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::Rect>| { let output: Val<::bevy_math::IRect> = { { - let output: Val<::bevy_math::IRect> = ::bevy_math::Rect::as_irect( - &_self, - ) - .into(); - output + let output: ::bevy_math::IRect = ::bevy_math::Rect::as_irect( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2450,11 +2340,10 @@ pub(crate) fn register_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::Rect>| { let output: Val<::bevy_math::URect> = { { - let output: Val<::bevy_math::URect> = ::bevy_math::Rect::as_urect( - &_self, - ) - .into(); - output + let output: ::bevy_math::URect = ::bevy_math::Rect::as_urect( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2467,11 +2356,10 @@ pub(crate) fn register_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::Rect>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::Rect::center( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::Rect::center( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2484,11 +2372,10 @@ pub(crate) fn register_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::Rect>| { let output: Val<::bevy_math::Rect> = { { - let output: Val<::bevy_math::Rect> = <::bevy_math::Rect as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::Rect = <::bevy_math::Rect as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2502,11 +2389,10 @@ pub(crate) fn register_rect_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_math::Rect::contains( - &_self, - point.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(point), + ); + safe_transmute(output) } }; output @@ -2521,9 +2407,8 @@ pub(crate) fn register_rect_functions(world: &mut World) { { let output: bool = <::bevy_math::Rect as ::core::cmp::PartialEq< ::bevy_math::Rect, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2536,12 +2421,11 @@ pub(crate) fn register_rect_functions(world: &mut World) { |origin: Val<::bevy_math::Vec2>, half_size: Val<::bevy_math::Vec2>| { let output: Val<::bevy_math::Rect> = { { - let output: Val<::bevy_math::Rect> = ::bevy_math::Rect::from_center_half_size( - origin.into_inner(), - half_size.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Rect = ::bevy_math::Rect::from_center_half_size( + safe_transmute(origin), + safe_transmute(half_size), + ); + safe_transmute(output) } }; output @@ -2554,12 +2438,11 @@ pub(crate) fn register_rect_functions(world: &mut World) { |origin: Val<::bevy_math::Vec2>, size: Val<::bevy_math::Vec2>| { let output: Val<::bevy_math::Rect> = { { - let output: Val<::bevy_math::Rect> = ::bevy_math::Rect::from_center_size( - origin.into_inner(), - size.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Rect = ::bevy_math::Rect::from_center_size( + safe_transmute(origin), + safe_transmute(size), + ); + safe_transmute(output) } }; output @@ -2572,12 +2455,11 @@ pub(crate) fn register_rect_functions(world: &mut World) { |p0: Val<::bevy_math::Vec2>, p1: Val<::bevy_math::Vec2>| { let output: Val<::bevy_math::Rect> = { { - let output: Val<::bevy_math::Rect> = ::bevy_math::Rect::from_corners( - p0.into_inner(), - p1.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Rect = ::bevy_math::Rect::from_corners( + safe_transmute(p0), + safe_transmute(p1), + ); + safe_transmute(output) } }; output @@ -2590,11 +2472,10 @@ pub(crate) fn register_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::Rect>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::Rect::half_size( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::Rect::half_size( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2607,8 +2488,10 @@ pub(crate) fn register_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::Rect>| { let output: f32 = { { - let output: f32 = ::bevy_math::Rect::height(&_self).into(); - output + let output: f32 = ::bevy_math::Rect::height( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2621,12 +2504,11 @@ pub(crate) fn register_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::Rect>, expansion: f32| { let output: Val<::bevy_math::Rect> = { { - let output: Val<::bevy_math::Rect> = ::bevy_math::Rect::inflate( - &_self, - expansion, - ) - .into(); - output + let output: ::bevy_math::Rect = ::bevy_math::Rect::inflate( + safe_transmute(_self), + safe_transmute(expansion), + ); + safe_transmute(output) } }; output @@ -2639,12 +2521,11 @@ pub(crate) fn register_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::Rect>, other: Val<::bevy_math::Rect>| { let output: Val<::bevy_math::Rect> = { { - let output: Val<::bevy_math::Rect> = ::bevy_math::Rect::intersect( - &_self, - other.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Rect = ::bevy_math::Rect::intersect( + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -2657,8 +2538,10 @@ pub(crate) fn register_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::Rect>| { let output: bool = { { - let output: bool = ::bevy_math::Rect::is_empty(&_self).into(); - output + let output: bool = ::bevy_math::Rect::is_empty( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2671,14 +2554,13 @@ pub(crate) fn register_rect_functions(world: &mut World) { |x0: f32, y0: f32, x1: f32, y1: f32| { let output: Val<::bevy_math::Rect> = { { - let output: Val<::bevy_math::Rect> = ::bevy_math::Rect::new( - x0, - y0, - x1, - y1, - ) - .into(); - output + let output: ::bevy_math::Rect = ::bevy_math::Rect::new( + safe_transmute(x0), + safe_transmute(y0), + safe_transmute(x1), + safe_transmute(y1), + ); + safe_transmute(output) } }; output @@ -2691,12 +2573,11 @@ pub(crate) fn register_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::Rect>, other: Val<::bevy_math::Rect>| { let output: Val<::bevy_math::Rect> = { { - let output: Val<::bevy_math::Rect> = ::bevy_math::Rect::normalize( - &_self, - other.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Rect = ::bevy_math::Rect::normalize( + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -2709,11 +2590,10 @@ pub(crate) fn register_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::Rect>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::Rect::size( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::Rect::size( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2726,12 +2606,11 @@ pub(crate) fn register_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::Rect>, other: Val<::bevy_math::Rect>| { let output: Val<::bevy_math::Rect> = { { - let output: Val<::bevy_math::Rect> = ::bevy_math::Rect::union( - &_self, - other.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Rect = ::bevy_math::Rect::union( + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -2744,12 +2623,11 @@ pub(crate) fn register_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::Rect>, other: Val<::bevy_math::Vec2>| { let output: Val<::bevy_math::Rect> = { { - let output: Val<::bevy_math::Rect> = ::bevy_math::Rect::union_point( - &_self, - other.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Rect = ::bevy_math::Rect::union_point( + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -2762,8 +2640,10 @@ pub(crate) fn register_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::Rect>| { let output: f32 = { { - let output: f32 = ::bevy_math::Rect::width(&_self).into(); - output + let output: f32 = ::bevy_math::Rect::width( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2788,11 +2668,10 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::URect>| { let output: Val<::bevy_math::IRect> = { { - let output: Val<::bevy_math::IRect> = ::bevy_math::URect::as_irect( - &_self, - ) - .into(); - output + let output: ::bevy_math::IRect = ::bevy_math::URect::as_irect( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2805,11 +2684,10 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::URect>| { let output: Val<::bevy_math::Rect> = { { - let output: Val<::bevy_math::Rect> = ::bevy_math::URect::as_rect( - &_self, - ) - .into(); - output + let output: ::bevy_math::Rect = ::bevy_math::URect::as_rect( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2823,10 +2701,9 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_math::URect as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2839,11 +2716,10 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::URect>| { let output: Val<::bevy_math::UVec2> = { { - let output: Val<::bevy_math::UVec2> = ::bevy_math::URect::center( - &_self, - ) - .into(); - output + let output: ::bevy_math::UVec2 = ::bevy_math::URect::center( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2856,11 +2732,10 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::URect>| { let output: Val<::bevy_math::URect> = { { - let output: Val<::bevy_math::URect> = <::bevy_math::URect as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::URect = <::bevy_math::URect as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2874,11 +2749,10 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_math::URect::contains( - &_self, - point.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(point), + ); + safe_transmute(output) } }; output @@ -2893,9 +2767,8 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { { let output: bool = <::bevy_math::URect as ::core::cmp::PartialEq< ::bevy_math::URect, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2908,12 +2781,11 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { |origin: Val<::bevy_math::UVec2>, half_size: Val<::bevy_math::UVec2>| { let output: Val<::bevy_math::URect> = { { - let output: Val<::bevy_math::URect> = ::bevy_math::URect::from_center_half_size( - origin.into_inner(), - half_size.into_inner(), - ) - .into(); - output + let output: ::bevy_math::URect = ::bevy_math::URect::from_center_half_size( + safe_transmute(origin), + safe_transmute(half_size), + ); + safe_transmute(output) } }; output @@ -2926,12 +2798,11 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { |origin: Val<::bevy_math::UVec2>, size: Val<::bevy_math::UVec2>| { let output: Val<::bevy_math::URect> = { { - let output: Val<::bevy_math::URect> = ::bevy_math::URect::from_center_size( - origin.into_inner(), - size.into_inner(), - ) - .into(); - output + let output: ::bevy_math::URect = ::bevy_math::URect::from_center_size( + safe_transmute(origin), + safe_transmute(size), + ); + safe_transmute(output) } }; output @@ -2944,12 +2815,11 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { |p0: Val<::bevy_math::UVec2>, p1: Val<::bevy_math::UVec2>| { let output: Val<::bevy_math::URect> = { { - let output: Val<::bevy_math::URect> = ::bevy_math::URect::from_corners( - p0.into_inner(), - p1.into_inner(), - ) - .into(); - output + let output: ::bevy_math::URect = ::bevy_math::URect::from_corners( + safe_transmute(p0), + safe_transmute(p1), + ); + safe_transmute(output) } }; output @@ -2962,11 +2832,10 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::URect>| { let output: Val<::bevy_math::UVec2> = { { - let output: Val<::bevy_math::UVec2> = ::bevy_math::URect::half_size( - &_self, - ) - .into(); - output + let output: ::bevy_math::UVec2 = ::bevy_math::URect::half_size( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2979,8 +2848,10 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::URect>| { let output: u32 = { { - let output: u32 = ::bevy_math::URect::height(&_self).into(); - output + let output: u32 = ::bevy_math::URect::height( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2993,12 +2864,11 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::URect>, expansion: i32| { let output: Val<::bevy_math::URect> = { { - let output: Val<::bevy_math::URect> = ::bevy_math::URect::inflate( - &_self, - expansion, - ) - .into(); - output + let output: ::bevy_math::URect = ::bevy_math::URect::inflate( + safe_transmute(_self), + safe_transmute(expansion), + ); + safe_transmute(output) } }; output @@ -3011,12 +2881,11 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::URect>, other: Val<::bevy_math::URect>| { let output: Val<::bevy_math::URect> = { { - let output: Val<::bevy_math::URect> = ::bevy_math::URect::intersect( - &_self, - other.into_inner(), - ) - .into(); - output + let output: ::bevy_math::URect = ::bevy_math::URect::intersect( + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -3029,8 +2898,10 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::URect>| { let output: bool = { { - let output: bool = ::bevy_math::URect::is_empty(&_self).into(); - output + let output: bool = ::bevy_math::URect::is_empty( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3043,14 +2914,13 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { |x0: u32, y0: u32, x1: u32, y1: u32| { let output: Val<::bevy_math::URect> = { { - let output: Val<::bevy_math::URect> = ::bevy_math::URect::new( - x0, - y0, - x1, - y1, - ) - .into(); - output + let output: ::bevy_math::URect = ::bevy_math::URect::new( + safe_transmute(x0), + safe_transmute(y0), + safe_transmute(x1), + safe_transmute(y1), + ); + safe_transmute(output) } }; output @@ -3063,11 +2933,10 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::URect>| { let output: Val<::bevy_math::UVec2> = { { - let output: Val<::bevy_math::UVec2> = ::bevy_math::URect::size( - &_self, - ) - .into(); - output + let output: ::bevy_math::UVec2 = ::bevy_math::URect::size( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3080,12 +2949,11 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::URect>, other: Val<::bevy_math::URect>| { let output: Val<::bevy_math::URect> = { { - let output: Val<::bevy_math::URect> = ::bevy_math::URect::union( - &_self, - other.into_inner(), - ) - .into(); - output + let output: ::bevy_math::URect = ::bevy_math::URect::union( + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -3098,12 +2966,11 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::URect>, other: Val<::bevy_math::UVec2>| { let output: Val<::bevy_math::URect> = { { - let output: Val<::bevy_math::URect> = ::bevy_math::URect::union_point( - &_self, - other.into_inner(), - ) - .into(); - output + let output: ::bevy_math::URect = ::bevy_math::URect::union_point( + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -3116,8 +2983,10 @@ pub(crate) fn register_u_rect_functions(world: &mut World) { |_self: Ref<::bevy_math::URect>| { let output: u32 = { { - let output: u32 = ::bevy_math::URect::width(&_self).into(); - output + let output: u32 = ::bevy_math::URect::width( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3154,11 +3023,10 @@ pub(crate) fn register_aabb_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::bounding::Aabb2d>| { let output: Val<::bevy_math::bounding::BoundingCircle> = { { - let output: Val<::bevy_math::bounding::BoundingCircle> = ::bevy_math::bounding::Aabb2d::bounding_circle( - &_self, - ) - .into(); - output + let output: ::bevy_math::bounding::BoundingCircle = ::bevy_math::bounding::Aabb2d::bounding_circle( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3171,11 +3039,10 @@ pub(crate) fn register_aabb_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::bounding::Aabb2d>| { let output: Val<::bevy_math::bounding::Aabb2d> = { { - let output: Val<::bevy_math::bounding::Aabb2d> = <::bevy_math::bounding::Aabb2d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::bounding::Aabb2d = <::bevy_math::bounding::Aabb2d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3188,12 +3055,11 @@ pub(crate) fn register_aabb_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::bounding::Aabb2d>, point: Val<::bevy_math::Vec2>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::bounding::Aabb2d::closest_point( - &_self, - point.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::bounding::Aabb2d::closest_point( + safe_transmute(_self), + safe_transmute(point), + ); + safe_transmute(output) } }; output @@ -3211,9 +3077,8 @@ pub(crate) fn register_aabb_2_d_functions(world: &mut World) { { let output: bool = <::bevy_math::bounding::Aabb2d as ::core::cmp::PartialEq< ::bevy_math::bounding::Aabb2d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -3226,12 +3091,11 @@ pub(crate) fn register_aabb_2_d_functions(world: &mut World) { |center: Val<::bevy_math::Vec2>, half_size: Val<::bevy_math::Vec2>| { let output: Val<::bevy_math::bounding::Aabb2d> = { { - let output: Val<::bevy_math::bounding::Aabb2d> = ::bevy_math::bounding::Aabb2d::new( - center.into_inner(), - half_size.into_inner(), - ) - .into(); - output + let output: ::bevy_math::bounding::Aabb2d = ::bevy_math::bounding::Aabb2d::new( + safe_transmute(center), + safe_transmute(half_size), + ); + safe_transmute(output) } }; output @@ -3256,11 +3120,10 @@ pub(crate) fn register_bounding_circle_functions(world: &mut World) { |_self: Ref<::bevy_math::bounding::BoundingCircle>| { let output: Val<::bevy_math::bounding::Aabb2d> = { { - let output: Val<::bevy_math::bounding::Aabb2d> = ::bevy_math::bounding::BoundingCircle::aabb_2d( - &_self, - ) - .into(); - output + let output: ::bevy_math::bounding::Aabb2d = ::bevy_math::bounding::BoundingCircle::aabb_2d( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3273,11 +3136,10 @@ pub(crate) fn register_bounding_circle_functions(world: &mut World) { |_self: Ref<::bevy_math::bounding::BoundingCircle>| { let output: Val<::bevy_math::bounding::BoundingCircle> = { { - let output: Val<::bevy_math::bounding::BoundingCircle> = <::bevy_math::bounding::BoundingCircle as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::bounding::BoundingCircle = <::bevy_math::bounding::BoundingCircle as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3293,12 +3155,11 @@ pub(crate) fn register_bounding_circle_functions(world: &mut World) { { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::bounding::BoundingCircle::closest_point( - &_self, - point.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::bounding::BoundingCircle::closest_point( + safe_transmute(_self), + safe_transmute(point), + ); + safe_transmute(output) } }; output @@ -3316,9 +3177,8 @@ pub(crate) fn register_bounding_circle_functions(world: &mut World) { { let output: bool = <::bevy_math::bounding::BoundingCircle as ::core::cmp::PartialEq< ::bevy_math::bounding::BoundingCircle, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -3331,12 +3191,11 @@ pub(crate) fn register_bounding_circle_functions(world: &mut World) { |center: Val<::bevy_math::Vec2>, radius: f32| { let output: Val<::bevy_math::bounding::BoundingCircle> = { { - let output: Val<::bevy_math::bounding::BoundingCircle> = ::bevy_math::bounding::BoundingCircle::new( - center.into_inner(), - radius, - ) - .into(); - output + let output: ::bevy_math::bounding::BoundingCircle = ::bevy_math::bounding::BoundingCircle::new( + safe_transmute(center), + safe_transmute(radius), + ); + safe_transmute(output) } }; output @@ -3350,10 +3209,9 @@ pub(crate) fn register_bounding_circle_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::bounding::BoundingCircle::radius( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3378,11 +3236,10 @@ pub(crate) fn register_circle_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Circle>| { let output: Val<::bevy_math::primitives::Circle> = { { - let output: Val<::bevy_math::primitives::Circle> = <::bevy_math::primitives::Circle as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Circle = <::bevy_math::primitives::Circle as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3395,12 +3252,11 @@ pub(crate) fn register_circle_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Circle>, point: Val<::bevy_math::Vec2>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Circle::closest_point( - &_self, - point.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::primitives::Circle::closest_point( + safe_transmute(_self), + safe_transmute(point), + ); + safe_transmute(output) } }; output @@ -3414,10 +3270,9 @@ pub(crate) fn register_circle_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Circle::diameter( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3435,9 +3290,8 @@ pub(crate) fn register_circle_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Circle as ::core::cmp::PartialEq< ::bevy_math::primitives::Circle, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -3450,11 +3304,10 @@ pub(crate) fn register_circle_functions(world: &mut World) { |radius: f32| { let output: Val<::bevy_math::primitives::Circle> = { { - let output: Val<::bevy_math::primitives::Circle> = ::bevy_math::primitives::Circle::new( - radius, - ) - .into(); - output + let output: ::bevy_math::primitives::Circle = ::bevy_math::primitives::Circle::new( + safe_transmute(radius), + ); + safe_transmute(output) } }; output @@ -3479,11 +3332,10 @@ pub(crate) fn register_annulus_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Annulus>| { let output: Val<::bevy_math::primitives::Annulus> = { { - let output: Val<::bevy_math::primitives::Annulus> = <::bevy_math::primitives::Annulus as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Annulus = <::bevy_math::primitives::Annulus as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3499,12 +3351,11 @@ pub(crate) fn register_annulus_functions(world: &mut World) { { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Annulus::closest_point( - &_self, - point.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::primitives::Annulus::closest_point( + safe_transmute(_self), + safe_transmute(point), + ); + safe_transmute(output) } }; output @@ -3518,10 +3369,9 @@ pub(crate) fn register_annulus_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Annulus::diameter( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3539,9 +3389,8 @@ pub(crate) fn register_annulus_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Annulus as ::core::cmp::PartialEq< ::bevy_math::primitives::Annulus, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -3554,12 +3403,11 @@ pub(crate) fn register_annulus_functions(world: &mut World) { |inner_radius: f32, outer_radius: f32| { let output: Val<::bevy_math::primitives::Annulus> = { { - let output: Val<::bevy_math::primitives::Annulus> = ::bevy_math::primitives::Annulus::new( - inner_radius, - outer_radius, - ) - .into(); - output + let output: ::bevy_math::primitives::Annulus = ::bevy_math::primitives::Annulus::new( + safe_transmute(inner_radius), + safe_transmute(outer_radius), + ); + safe_transmute(output) } }; output @@ -3573,10 +3421,9 @@ pub(crate) fn register_annulus_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Annulus::thickness( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3601,9 +3448,10 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Arc2d>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::Arc2d::angle(&_self) - .into(); - output + let output: f32 = ::bevy_math::primitives::Arc2d::angle( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3616,9 +3464,10 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Arc2d>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::Arc2d::apothem(&_self) - .into(); - output + let output: f32 = ::bevy_math::primitives::Arc2d::apothem( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3632,10 +3481,9 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Arc2d::chord_length( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3648,11 +3496,10 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Arc2d>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Arc2d::chord_midpoint( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::primitives::Arc2d::chord_midpoint( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3665,11 +3512,10 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Arc2d>| { let output: Val<::bevy_math::primitives::Arc2d> = { { - let output: Val<::bevy_math::primitives::Arc2d> = <::bevy_math::primitives::Arc2d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Arc2d = <::bevy_math::primitives::Arc2d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3687,9 +3533,8 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Arc2d as ::core::cmp::PartialEq< ::bevy_math::primitives::Arc2d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -3702,12 +3547,11 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { |radius: f32, angle: f32| { let output: Val<::bevy_math::primitives::Arc2d> = { { - let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::from_degrees( - radius, - angle, - ) - .into(); - output + let output: ::bevy_math::primitives::Arc2d = ::bevy_math::primitives::Arc2d::from_degrees( + safe_transmute(radius), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -3720,12 +3564,11 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { |radius: f32, angle: f32| { let output: Val<::bevy_math::primitives::Arc2d> = { { - let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::from_radians( - radius, - angle, - ) - .into(); - output + let output: ::bevy_math::primitives::Arc2d = ::bevy_math::primitives::Arc2d::from_radians( + safe_transmute(radius), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -3738,12 +3581,11 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { |radius: f32, fraction: f32| { let output: Val<::bevy_math::primitives::Arc2d> = { { - let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::from_turns( - radius, - fraction, - ) - .into(); - output + let output: ::bevy_math::primitives::Arc2d = ::bevy_math::primitives::Arc2d::from_turns( + safe_transmute(radius), + safe_transmute(fraction), + ); + safe_transmute(output) } }; output @@ -3757,10 +3599,9 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Arc2d::half_chord_length( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3774,10 +3615,9 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_math::primitives::Arc2d::is_major( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3791,10 +3631,9 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_math::primitives::Arc2d::is_minor( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3807,11 +3646,10 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Arc2d>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Arc2d::left_endpoint( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::primitives::Arc2d::left_endpoint( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3824,9 +3662,10 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Arc2d>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::Arc2d::length(&_self) - .into(); - output + let output: f32 = ::bevy_math::primitives::Arc2d::length( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3839,11 +3678,10 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Arc2d>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Arc2d::midpoint( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::primitives::Arc2d::midpoint( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3856,12 +3694,11 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { |radius: f32, half_angle: f32| { let output: Val<::bevy_math::primitives::Arc2d> = { { - let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::new( - radius, - half_angle, - ) - .into(); - output + let output: ::bevy_math::primitives::Arc2d = ::bevy_math::primitives::Arc2d::new( + safe_transmute(radius), + safe_transmute(half_angle), + ); + safe_transmute(output) } }; output @@ -3874,11 +3711,10 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Arc2d>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Arc2d::right_endpoint( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::primitives::Arc2d::right_endpoint( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3891,9 +3727,10 @@ pub(crate) fn register_arc_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Arc2d>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::Arc2d::sagitta(&_self) - .into(); - output + let output: f32 = ::bevy_math::primitives::Arc2d::sagitta( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3918,11 +3755,10 @@ pub(crate) fn register_capsule_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Capsule2d>| { let output: Val<::bevy_math::primitives::Capsule2d> = { { - let output: Val<::bevy_math::primitives::Capsule2d> = <::bevy_math::primitives::Capsule2d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Capsule2d = <::bevy_math::primitives::Capsule2d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3940,9 +3776,8 @@ pub(crate) fn register_capsule_2_d_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Capsule2d as ::core::cmp::PartialEq< ::bevy_math::primitives::Capsule2d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -3955,12 +3790,11 @@ pub(crate) fn register_capsule_2_d_functions(world: &mut World) { |radius: f32, length: f32| { let output: Val<::bevy_math::primitives::Capsule2d> = { { - let output: Val<::bevy_math::primitives::Capsule2d> = ::bevy_math::primitives::Capsule2d::new( - radius, - length, - ) - .into(); - output + let output: ::bevy_math::primitives::Capsule2d = ::bevy_math::primitives::Capsule2d::new( + safe_transmute(radius), + safe_transmute(length), + ); + safe_transmute(output) } }; output @@ -3973,11 +3807,10 @@ pub(crate) fn register_capsule_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Capsule2d>| { let output: Val<::bevy_math::primitives::Rectangle> = { { - let output: Val<::bevy_math::primitives::Rectangle> = ::bevy_math::primitives::Capsule2d::to_inner_rectangle( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Rectangle = ::bevy_math::primitives::Capsule2d::to_inner_rectangle( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4003,10 +3836,9 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::CircularSector::angle( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4020,10 +3852,9 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::CircularSector::apothem( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4037,10 +3868,9 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::CircularSector::arc_length( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4054,10 +3884,9 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::CircularSector::chord_length( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4070,11 +3899,10 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::CircularSector>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::CircularSector::chord_midpoint( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::primitives::CircularSector::chord_midpoint( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4087,11 +3915,10 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::CircularSector>| { let output: Val<::bevy_math::primitives::CircularSector> = { { - let output: Val<::bevy_math::primitives::CircularSector> = <::bevy_math::primitives::CircularSector as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::CircularSector = <::bevy_math::primitives::CircularSector as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4109,9 +3936,8 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::CircularSector as ::core::cmp::PartialEq< ::bevy_math::primitives::CircularSector, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -4124,12 +3950,11 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { |radius: f32, angle: f32| { let output: Val<::bevy_math::primitives::CircularSector> = { { - let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::from_degrees( - radius, - angle, - ) - .into(); - output + let output: ::bevy_math::primitives::CircularSector = ::bevy_math::primitives::CircularSector::from_degrees( + safe_transmute(radius), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -4142,12 +3967,11 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { |radius: f32, angle: f32| { let output: Val<::bevy_math::primitives::CircularSector> = { { - let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::from_radians( - radius, - angle, - ) - .into(); - output + let output: ::bevy_math::primitives::CircularSector = ::bevy_math::primitives::CircularSector::from_radians( + safe_transmute(radius), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -4160,12 +3984,11 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { |radius: f32, fraction: f32| { let output: Val<::bevy_math::primitives::CircularSector> = { { - let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::from_turns( - radius, - fraction, - ) - .into(); - output + let output: ::bevy_math::primitives::CircularSector = ::bevy_math::primitives::CircularSector::from_turns( + safe_transmute(radius), + safe_transmute(fraction), + ); + safe_transmute(output) } }; output @@ -4179,10 +4002,9 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::CircularSector::half_angle( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4196,10 +4018,9 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::CircularSector::half_chord_length( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4212,12 +4033,11 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { |radius: f32, angle: f32| { let output: Val<::bevy_math::primitives::CircularSector> = { { - let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::new( - radius, - angle, - ) - .into(); - output + let output: ::bevy_math::primitives::CircularSector = ::bevy_math::primitives::CircularSector::new( + safe_transmute(radius), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -4231,10 +4051,9 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::CircularSector::radius( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4248,10 +4067,9 @@ pub(crate) fn register_circular_sector_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::CircularSector::sagitta( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4277,10 +4095,9 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::CircularSegment::angle( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4294,10 +4111,9 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::CircularSegment::apothem( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4311,10 +4127,9 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::CircularSegment::arc_length( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4328,10 +4143,9 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::CircularSegment::chord_length( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4344,11 +4158,10 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::CircularSegment>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::CircularSegment::chord_midpoint( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::primitives::CircularSegment::chord_midpoint( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4361,11 +4174,10 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::CircularSegment>| { let output: Val<::bevy_math::primitives::CircularSegment> = { { - let output: Val<::bevy_math::primitives::CircularSegment> = <::bevy_math::primitives::CircularSegment as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::CircularSegment = <::bevy_math::primitives::CircularSegment as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4383,9 +4195,8 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::CircularSegment as ::core::cmp::PartialEq< ::bevy_math::primitives::CircularSegment, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -4398,12 +4209,11 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { |radius: f32, angle: f32| { let output: Val<::bevy_math::primitives::CircularSegment> = { { - let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::from_degrees( - radius, - angle, - ) - .into(); - output + let output: ::bevy_math::primitives::CircularSegment = ::bevy_math::primitives::CircularSegment::from_degrees( + safe_transmute(radius), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -4416,12 +4226,11 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { |radius: f32, angle: f32| { let output: Val<::bevy_math::primitives::CircularSegment> = { { - let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::from_radians( - radius, - angle, - ) - .into(); - output + let output: ::bevy_math::primitives::CircularSegment = ::bevy_math::primitives::CircularSegment::from_radians( + safe_transmute(radius), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -4434,12 +4243,11 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { |radius: f32, fraction: f32| { let output: Val<::bevy_math::primitives::CircularSegment> = { { - let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::from_turns( - radius, - fraction, - ) - .into(); - output + let output: ::bevy_math::primitives::CircularSegment = ::bevy_math::primitives::CircularSegment::from_turns( + safe_transmute(radius), + safe_transmute(fraction), + ); + safe_transmute(output) } }; output @@ -4453,10 +4261,9 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::CircularSegment::half_angle( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4470,10 +4277,9 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::CircularSegment::half_chord_length( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4486,12 +4292,11 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { |radius: f32, angle: f32| { let output: Val<::bevy_math::primitives::CircularSegment> = { { - let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::new( - radius, - angle, - ) - .into(); - output + let output: ::bevy_math::primitives::CircularSegment = ::bevy_math::primitives::CircularSegment::new( + safe_transmute(radius), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -4505,10 +4310,9 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::CircularSegment::radius( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4522,10 +4326,9 @@ pub(crate) fn register_circular_segment_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::CircularSegment::sagitta( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4550,11 +4353,10 @@ pub(crate) fn register_ellipse_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Ellipse>| { let output: Val<::bevy_math::primitives::Ellipse> = { { - let output: Val<::bevy_math::primitives::Ellipse> = <::bevy_math::primitives::Ellipse as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Ellipse = <::bevy_math::primitives::Ellipse as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4568,10 +4370,9 @@ pub(crate) fn register_ellipse_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Ellipse::eccentricity( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4589,9 +4390,8 @@ pub(crate) fn register_ellipse_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Ellipse as ::core::cmp::PartialEq< ::bevy_math::primitives::Ellipse, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -4605,10 +4405,9 @@ pub(crate) fn register_ellipse_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Ellipse::focal_length( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4621,11 +4420,10 @@ pub(crate) fn register_ellipse_functions(world: &mut World) { |size: Val<::bevy_math::Vec2>| { let output: Val<::bevy_math::primitives::Ellipse> = { { - let output: Val<::bevy_math::primitives::Ellipse> = ::bevy_math::primitives::Ellipse::from_size( - size.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Ellipse = ::bevy_math::primitives::Ellipse::from_size( + safe_transmute(size), + ); + safe_transmute(output) } }; output @@ -4638,12 +4436,11 @@ pub(crate) fn register_ellipse_functions(world: &mut World) { |half_width: f32, half_height: f32| { let output: Val<::bevy_math::primitives::Ellipse> = { { - let output: Val<::bevy_math::primitives::Ellipse> = ::bevy_math::primitives::Ellipse::new( - half_width, - half_height, - ) - .into(); - output + let output: ::bevy_math::primitives::Ellipse = ::bevy_math::primitives::Ellipse::new( + safe_transmute(half_width), + safe_transmute(half_height), + ); + safe_transmute(output) } }; output @@ -4657,10 +4454,9 @@ pub(crate) fn register_ellipse_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Ellipse::semi_major( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4674,10 +4470,9 @@ pub(crate) fn register_ellipse_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Ellipse::semi_minor( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4702,11 +4497,10 @@ pub(crate) fn register_line_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Line2d>| { let output: Val<::bevy_math::primitives::Line2d> = { { - let output: Val<::bevy_math::primitives::Line2d> = <::bevy_math::primitives::Line2d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Line2d = <::bevy_math::primitives::Line2d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4724,9 +4518,8 @@ pub(crate) fn register_line_2_d_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Line2d as ::core::cmp::PartialEq< ::bevy_math::primitives::Line2d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -4751,11 +4544,10 @@ pub(crate) fn register_plane_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Plane2d>| { let output: Val<::bevy_math::primitives::Plane2d> = { { - let output: Val<::bevy_math::primitives::Plane2d> = <::bevy_math::primitives::Plane2d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Plane2d = <::bevy_math::primitives::Plane2d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4773,9 +4565,8 @@ pub(crate) fn register_plane_2_d_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Plane2d as ::core::cmp::PartialEq< ::bevy_math::primitives::Plane2d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -4788,11 +4579,10 @@ pub(crate) fn register_plane_2_d_functions(world: &mut World) { |normal: Val<::bevy_math::Vec2>| { let output: Val<::bevy_math::primitives::Plane2d> = { { - let output: Val<::bevy_math::primitives::Plane2d> = ::bevy_math::primitives::Plane2d::new( - normal.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Plane2d = ::bevy_math::primitives::Plane2d::new( + safe_transmute(normal), + ); + safe_transmute(output) } }; output @@ -4817,11 +4607,10 @@ pub(crate) fn register_rectangle_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Rectangle>| { let output: Val<::bevy_math::primitives::Rectangle> = { { - let output: Val<::bevy_math::primitives::Rectangle> = <::bevy_math::primitives::Rectangle as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Rectangle = <::bevy_math::primitives::Rectangle as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4837,12 +4626,11 @@ pub(crate) fn register_rectangle_functions(world: &mut World) { { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Rectangle::closest_point( - &_self, - point.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::primitives::Rectangle::closest_point( + safe_transmute(_self), + safe_transmute(point), + ); + safe_transmute(output) } }; output @@ -4860,9 +4648,8 @@ pub(crate) fn register_rectangle_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Rectangle as ::core::cmp::PartialEq< ::bevy_math::primitives::Rectangle, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -4875,12 +4662,11 @@ pub(crate) fn register_rectangle_functions(world: &mut World) { |point1: Val<::bevy_math::Vec2>, point2: Val<::bevy_math::Vec2>| { let output: Val<::bevy_math::primitives::Rectangle> = { { - let output: Val<::bevy_math::primitives::Rectangle> = ::bevy_math::primitives::Rectangle::from_corners( - point1.into_inner(), - point2.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Rectangle = ::bevy_math::primitives::Rectangle::from_corners( + safe_transmute(point1), + safe_transmute(point2), + ); + safe_transmute(output) } }; output @@ -4893,11 +4679,10 @@ pub(crate) fn register_rectangle_functions(world: &mut World) { |length: f32| { let output: Val<::bevy_math::primitives::Rectangle> = { { - let output: Val<::bevy_math::primitives::Rectangle> = ::bevy_math::primitives::Rectangle::from_length( - length, - ) - .into(); - output + let output: ::bevy_math::primitives::Rectangle = ::bevy_math::primitives::Rectangle::from_length( + safe_transmute(length), + ); + safe_transmute(output) } }; output @@ -4910,11 +4695,10 @@ pub(crate) fn register_rectangle_functions(world: &mut World) { |size: Val<::bevy_math::Vec2>| { let output: Val<::bevy_math::primitives::Rectangle> = { { - let output: Val<::bevy_math::primitives::Rectangle> = ::bevy_math::primitives::Rectangle::from_size( - size.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Rectangle = ::bevy_math::primitives::Rectangle::from_size( + safe_transmute(size), + ); + safe_transmute(output) } }; output @@ -4927,12 +4711,11 @@ pub(crate) fn register_rectangle_functions(world: &mut World) { |width: f32, height: f32| { let output: Val<::bevy_math::primitives::Rectangle> = { { - let output: Val<::bevy_math::primitives::Rectangle> = ::bevy_math::primitives::Rectangle::new( - width, - height, - ) - .into(); - output + let output: ::bevy_math::primitives::Rectangle = ::bevy_math::primitives::Rectangle::new( + safe_transmute(width), + safe_transmute(height), + ); + safe_transmute(output) } }; output @@ -4945,11 +4728,10 @@ pub(crate) fn register_rectangle_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Rectangle>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Rectangle::size( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::primitives::Rectangle::size( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4975,10 +4757,9 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::RegularPolygon::circumradius( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4991,11 +4772,10 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::RegularPolygon>| { let output: Val<::bevy_math::primitives::RegularPolygon> = { { - let output: Val<::bevy_math::primitives::RegularPolygon> = <::bevy_math::primitives::RegularPolygon as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::RegularPolygon = <::bevy_math::primitives::RegularPolygon as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5013,9 +4793,8 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::RegularPolygon as ::core::cmp::PartialEq< ::bevy_math::primitives::RegularPolygon, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -5029,10 +4808,9 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::RegularPolygon::external_angle_degrees( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5046,10 +4824,9 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::RegularPolygon::external_angle_radians( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5063,10 +4840,9 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::RegularPolygon::inradius( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5080,10 +4856,9 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::RegularPolygon::internal_angle_degrees( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5097,10 +4872,9 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::RegularPolygon::internal_angle_radians( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5113,12 +4887,11 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { |circumradius: f32, sides: u32| { let output: Val<::bevy_math::primitives::RegularPolygon> = { { - let output: Val<::bevy_math::primitives::RegularPolygon> = ::bevy_math::primitives::RegularPolygon::new( - circumradius, - sides, - ) - .into(); - output + let output: ::bevy_math::primitives::RegularPolygon = ::bevy_math::primitives::RegularPolygon::new( + safe_transmute(circumradius), + safe_transmute(sides), + ); + safe_transmute(output) } }; output @@ -5132,10 +4905,9 @@ pub(crate) fn register_regular_polygon_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::RegularPolygon::side_length( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5161,10 +4933,9 @@ pub(crate) fn register_rhombus_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Rhombus::circumradius( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5177,11 +4948,10 @@ pub(crate) fn register_rhombus_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Rhombus>| { let output: Val<::bevy_math::primitives::Rhombus> = { { - let output: Val<::bevy_math::primitives::Rhombus> = <::bevy_math::primitives::Rhombus as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Rhombus = <::bevy_math::primitives::Rhombus as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5197,12 +4967,11 @@ pub(crate) fn register_rhombus_functions(world: &mut World) { { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Rhombus::closest_point( - &_self, - point.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::primitives::Rhombus::closest_point( + safe_transmute(_self), + safe_transmute(point), + ); + safe_transmute(output) } }; output @@ -5220,9 +4989,8 @@ pub(crate) fn register_rhombus_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Rhombus as ::core::cmp::PartialEq< ::bevy_math::primitives::Rhombus, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -5235,11 +5003,10 @@ pub(crate) fn register_rhombus_functions(world: &mut World) { |inradius: f32| { let output: Val<::bevy_math::primitives::Rhombus> = { { - let output: Val<::bevy_math::primitives::Rhombus> = ::bevy_math::primitives::Rhombus::from_inradius( - inradius, - ) - .into(); - output + let output: ::bevy_math::primitives::Rhombus = ::bevy_math::primitives::Rhombus::from_inradius( + safe_transmute(inradius), + ); + safe_transmute(output) } }; output @@ -5252,11 +5019,10 @@ pub(crate) fn register_rhombus_functions(world: &mut World) { |side: f32| { let output: Val<::bevy_math::primitives::Rhombus> = { { - let output: Val<::bevy_math::primitives::Rhombus> = ::bevy_math::primitives::Rhombus::from_side( - side, - ) - .into(); - output + let output: ::bevy_math::primitives::Rhombus = ::bevy_math::primitives::Rhombus::from_side( + safe_transmute(side), + ); + safe_transmute(output) } }; output @@ -5270,10 +5036,9 @@ pub(crate) fn register_rhombus_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Rhombus::inradius( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5286,12 +5051,11 @@ pub(crate) fn register_rhombus_functions(world: &mut World) { |horizontal_diagonal: f32, vertical_diagonal: f32| { let output: Val<::bevy_math::primitives::Rhombus> = { { - let output: Val<::bevy_math::primitives::Rhombus> = ::bevy_math::primitives::Rhombus::new( - horizontal_diagonal, - vertical_diagonal, - ) - .into(); - output + let output: ::bevy_math::primitives::Rhombus = ::bevy_math::primitives::Rhombus::new( + safe_transmute(horizontal_diagonal), + safe_transmute(vertical_diagonal), + ); + safe_transmute(output) } }; output @@ -5304,9 +5068,10 @@ pub(crate) fn register_rhombus_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Rhombus>| { let output: f32 = { { - let output: f32 = ::bevy_math::primitives::Rhombus::side(&_self) - .into(); - output + let output: f32 = ::bevy_math::primitives::Rhombus::side( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5331,11 +5096,10 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Segment2d>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Segment2d::center( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::primitives::Segment2d::center( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5348,11 +5112,10 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Segment2d>| { let output: Val<::bevy_math::primitives::Segment2d> = { { - let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::centered( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Segment2d = ::bevy_math::primitives::Segment2d::centered( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5365,11 +5128,10 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Segment2d>| { let output: Val<::bevy_math::primitives::Segment2d> = { { - let output: Val<::bevy_math::primitives::Segment2d> = <::bevy_math::primitives::Segment2d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Segment2d = <::bevy_math::primitives::Segment2d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5385,12 +5147,11 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Segment2d::closest_point( - &_self, - point.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::primitives::Segment2d::closest_point( + safe_transmute(_self), + safe_transmute(point), + ); + safe_transmute(output) } }; output @@ -5403,11 +5164,10 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Segment2d>| { let output: Val<::bevy_math::Dir2> = { { - let output: Val<::bevy_math::Dir2> = ::bevy_math::primitives::Segment2d::direction( - &_self, - ) - .into(); - output + let output: ::bevy_math::Dir2 = ::bevy_math::primitives::Segment2d::direction( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5425,9 +5185,8 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Segment2d as ::core::cmp::PartialEq< ::bevy_math::primitives::Segment2d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -5440,12 +5199,11 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { |direction: Val<::bevy_math::Dir2>, length: f32| { let output: Val<::bevy_math::primitives::Segment2d> = { { - let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::from_direction_and_length( - direction.into_inner(), - length, - ) - .into(); - output + let output: ::bevy_math::primitives::Segment2d = ::bevy_math::primitives::Segment2d::from_direction_and_length( + safe_transmute(direction), + safe_transmute(length), + ); + safe_transmute(output) } }; output @@ -5458,12 +5216,11 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { |ray: Val<::bevy_math::Ray2d>, length: f32| { let output: Val<::bevy_math::primitives::Segment2d> = { { - let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::from_ray_and_length( - ray.into_inner(), - length, - ) - .into(); - output + let output: ::bevy_math::primitives::Segment2d = ::bevy_math::primitives::Segment2d::from_ray_and_length( + safe_transmute(ray), + safe_transmute(length), + ); + safe_transmute(output) } }; output @@ -5476,11 +5233,10 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { |scaled_direction: Val<::bevy_math::Vec2>| { let output: Val<::bevy_math::primitives::Segment2d> = { { - let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::from_scaled_direction( - scaled_direction.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Segment2d = ::bevy_math::primitives::Segment2d::from_scaled_direction( + safe_transmute(scaled_direction), + ); + safe_transmute(output) } }; output @@ -5493,11 +5249,10 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Segment2d>| { let output: Val<::bevy_math::Dir2> = { { - let output: Val<::bevy_math::Dir2> = ::bevy_math::primitives::Segment2d::left_normal( - &_self, - ) - .into(); - output + let output: ::bevy_math::Dir2 = ::bevy_math::primitives::Segment2d::left_normal( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5511,10 +5266,9 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Segment2d::length( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5528,10 +5282,9 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Segment2d::length_squared( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5544,12 +5297,11 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { |point1: Val<::bevy_math::Vec2>, point2: Val<::bevy_math::Vec2>| { let output: Val<::bevy_math::primitives::Segment2d> = { { - let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::new( - point1.into_inner(), - point2.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Segment2d = ::bevy_math::primitives::Segment2d::new( + safe_transmute(point1), + safe_transmute(point2), + ); + safe_transmute(output) } }; output @@ -5562,11 +5314,10 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Segment2d>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Segment2d::point1( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::primitives::Segment2d::point1( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5579,11 +5330,10 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Segment2d>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Segment2d::point2( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::primitives::Segment2d::point2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5596,12 +5346,11 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Segment2d>, length: f32| { let output: Val<::bevy_math::primitives::Segment2d> = { { - let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::resized( - &_self, - length, - ) - .into(); - output + let output: ::bevy_math::primitives::Segment2d = ::bevy_math::primitives::Segment2d::resized( + safe_transmute(_self), + safe_transmute(length), + ); + safe_transmute(output) } }; output @@ -5615,10 +5364,9 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_math::primitives::Segment2d::reverse( - &mut _self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5631,11 +5379,10 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { |_self: Val<::bevy_math::primitives::Segment2d>| { let output: Val<::bevy_math::primitives::Segment2d> = { { - let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::reversed( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Segment2d = ::bevy_math::primitives::Segment2d::reversed( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5648,11 +5395,10 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Segment2d>| { let output: Val<::bevy_math::Dir2> = { { - let output: Val<::bevy_math::Dir2> = ::bevy_math::primitives::Segment2d::right_normal( - &_self, - ) - .into(); - output + let output: ::bevy_math::Dir2 = ::bevy_math::primitives::Segment2d::right_normal( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5668,12 +5414,11 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { { let output: Val<::bevy_math::primitives::Segment2d> = { { - let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::rotated( - &_self, - rotation.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Segment2d = ::bevy_math::primitives::Segment2d::rotated( + safe_transmute(_self), + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -5690,13 +5435,12 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { { let output: Val<::bevy_math::primitives::Segment2d> = { { - let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::rotated_around( - &_self, - rotation.into_inner(), - point.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Segment2d = ::bevy_math::primitives::Segment2d::rotated_around( + safe_transmute(_self), + safe_transmute(rotation), + safe_transmute(point), + ); + safe_transmute(output) } }; output @@ -5712,12 +5456,11 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { { let output: Val<::bevy_math::primitives::Segment2d> = { { - let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::rotated_around_center( - &_self, - rotation.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Segment2d = ::bevy_math::primitives::Segment2d::rotated_around_center( + safe_transmute(_self), + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -5730,11 +5473,10 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Segment2d>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Segment2d::scaled_direction( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::primitives::Segment2d::scaled_direction( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5747,11 +5489,10 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Segment2d>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Segment2d::scaled_left_normal( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::primitives::Segment2d::scaled_left_normal( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5764,11 +5505,10 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Segment2d>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::primitives::Segment2d::scaled_right_normal( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::primitives::Segment2d::scaled_right_normal( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5784,12 +5524,11 @@ pub(crate) fn register_segment_2_d_functions(world: &mut World) { { let output: Val<::bevy_math::primitives::Segment2d> = { { - let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::translated( - &_self, - translation.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Segment2d = ::bevy_math::primitives::Segment2d::translated( + safe_transmute(_self), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -5814,11 +5553,10 @@ pub(crate) fn register_triangle_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Triangle2d>| { let output: Val<::bevy_math::primitives::Triangle2d> = { { - let output: Val<::bevy_math::primitives::Triangle2d> = <::bevy_math::primitives::Triangle2d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Triangle2d = <::bevy_math::primitives::Triangle2d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5836,9 +5574,8 @@ pub(crate) fn register_triangle_2_d_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Triangle2d as ::core::cmp::PartialEq< ::bevy_math::primitives::Triangle2d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -5852,10 +5589,9 @@ pub(crate) fn register_triangle_2_d_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_math::primitives::Triangle2d::is_acute( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5869,10 +5605,9 @@ pub(crate) fn register_triangle_2_d_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_math::primitives::Triangle2d::is_degenerate( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5886,10 +5621,9 @@ pub(crate) fn register_triangle_2_d_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_math::primitives::Triangle2d::is_obtuse( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5906,13 +5640,12 @@ pub(crate) fn register_triangle_2_d_functions(world: &mut World) { { let output: Val<::bevy_math::primitives::Triangle2d> = { { - let output: Val<::bevy_math::primitives::Triangle2d> = ::bevy_math::primitives::Triangle2d::new( - a.into_inner(), - b.into_inner(), - c.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Triangle2d = ::bevy_math::primitives::Triangle2d::new( + safe_transmute(a), + safe_transmute(b), + safe_transmute(c), + ); + safe_transmute(output) } }; output @@ -5926,10 +5659,9 @@ pub(crate) fn register_triangle_2_d_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_math::primitives::Triangle2d::reverse( - &mut _self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5942,11 +5674,10 @@ pub(crate) fn register_triangle_2_d_functions(world: &mut World) { |_self: Val<::bevy_math::primitives::Triangle2d>| { let output: Val<::bevy_math::primitives::Triangle2d> = { { - let output: Val<::bevy_math::primitives::Triangle2d> = ::bevy_math::primitives::Triangle2d::reversed( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Triangle2d = ::bevy_math::primitives::Triangle2d::reversed( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5971,11 +5702,10 @@ pub(crate) fn register_convex_polygon_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::ConvexPolygon>| { let output: Val<::bevy_math::primitives::ConvexPolygon> = { { - let output: Val<::bevy_math::primitives::ConvexPolygon> = <::bevy_math::primitives::ConvexPolygon as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::ConvexPolygon = <::bevy_math::primitives::ConvexPolygon as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5993,9 +5723,8 @@ pub(crate) fn register_convex_polygon_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::ConvexPolygon as ::core::cmp::PartialEq< ::bevy_math::primitives::ConvexPolygon, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -6020,11 +5749,10 @@ pub(crate) fn register_polygon_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Polygon>| { let output: Val<::bevy_math::primitives::Polygon> = { { - let output: Val<::bevy_math::primitives::Polygon> = <::bevy_math::primitives::Polygon as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Polygon = <::bevy_math::primitives::Polygon as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6042,9 +5770,8 @@ pub(crate) fn register_polygon_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Polygon as ::core::cmp::PartialEq< ::bevy_math::primitives::Polygon, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -6058,10 +5785,9 @@ pub(crate) fn register_polygon_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_math::primitives::Polygon::is_simple( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6086,11 +5812,10 @@ pub(crate) fn register_polyline_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Polyline2d>| { let output: Val<::bevy_math::primitives::Polyline2d> = { { - let output: Val<::bevy_math::primitives::Polyline2d> = <::bevy_math::primitives::Polyline2d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Polyline2d = <::bevy_math::primitives::Polyline2d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6108,9 +5833,8 @@ pub(crate) fn register_polyline_2_d_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Polyline2d as ::core::cmp::PartialEq< ::bevy_math::primitives::Polyline2d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -6127,13 +5851,12 @@ pub(crate) fn register_polyline_2_d_functions(world: &mut World) { { let output: Val<::bevy_math::primitives::Polyline2d> = { { - let output: Val<::bevy_math::primitives::Polyline2d> = ::bevy_math::primitives::Polyline2d::with_subdivisions( - start.into_inner(), - end.into_inner(), - subdivisions, - ) - .into(); - output + let output: ::bevy_math::primitives::Polyline2d = ::bevy_math::primitives::Polyline2d::with_subdivisions( + safe_transmute(start), + safe_transmute(end), + safe_transmute(subdivisions), + ); + safe_transmute(output) } }; output @@ -6158,11 +5881,10 @@ pub(crate) fn register_aabb_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::bounding::Aabb3d>| { let output: Val<::bevy_math::bounding::BoundingSphere> = { { - let output: Val<::bevy_math::bounding::BoundingSphere> = ::bevy_math::bounding::Aabb3d::bounding_sphere( - &_self, - ) - .into(); - output + let output: ::bevy_math::bounding::BoundingSphere = ::bevy_math::bounding::Aabb3d::bounding_sphere( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6175,11 +5897,10 @@ pub(crate) fn register_aabb_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::bounding::Aabb3d>| { let output: Val<::bevy_math::bounding::Aabb3d> = { { - let output: Val<::bevy_math::bounding::Aabb3d> = <::bevy_math::bounding::Aabb3d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::bounding::Aabb3d = <::bevy_math::bounding::Aabb3d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6197,9 +5918,8 @@ pub(crate) fn register_aabb_3_d_functions(world: &mut World) { { let output: bool = <::bevy_math::bounding::Aabb3d as ::core::cmp::PartialEq< ::bevy_math::bounding::Aabb3d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -6224,11 +5944,10 @@ pub(crate) fn register_bounding_sphere_functions(world: &mut World) { |_self: Ref<::bevy_math::bounding::BoundingSphere>| { let output: Val<::bevy_math::bounding::Aabb3d> = { { - let output: Val<::bevy_math::bounding::Aabb3d> = ::bevy_math::bounding::BoundingSphere::aabb_3d( - &_self, - ) - .into(); - output + let output: ::bevy_math::bounding::Aabb3d = ::bevy_math::bounding::BoundingSphere::aabb_3d( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6241,11 +5960,10 @@ pub(crate) fn register_bounding_sphere_functions(world: &mut World) { |_self: Ref<::bevy_math::bounding::BoundingSphere>| { let output: Val<::bevy_math::bounding::BoundingSphere> = { { - let output: Val<::bevy_math::bounding::BoundingSphere> = <::bevy_math::bounding::BoundingSphere as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::bounding::BoundingSphere = <::bevy_math::bounding::BoundingSphere as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6263,9 +5981,8 @@ pub(crate) fn register_bounding_sphere_functions(world: &mut World) { { let output: bool = <::bevy_math::bounding::BoundingSphere as ::core::cmp::PartialEq< ::bevy_math::bounding::BoundingSphere, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -6279,10 +5996,9 @@ pub(crate) fn register_bounding_sphere_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::bounding::BoundingSphere::radius( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6307,11 +6023,10 @@ pub(crate) fn register_sphere_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Sphere>| { let output: Val<::bevy_math::primitives::Sphere> = { { - let output: Val<::bevy_math::primitives::Sphere> = <::bevy_math::primitives::Sphere as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Sphere = <::bevy_math::primitives::Sphere as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6324,12 +6039,11 @@ pub(crate) fn register_sphere_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Sphere>, point: Val<::bevy_math::Vec3>| { let output: Val<::bevy_math::Vec3> = { { - let output: Val<::bevy_math::Vec3> = ::bevy_math::primitives::Sphere::closest_point( - &_self, - point.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Vec3 = ::bevy_math::primitives::Sphere::closest_point( + safe_transmute(_self), + safe_transmute(point), + ); + safe_transmute(output) } }; output @@ -6343,10 +6057,9 @@ pub(crate) fn register_sphere_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Sphere::diameter( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6364,9 +6077,8 @@ pub(crate) fn register_sphere_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Sphere as ::core::cmp::PartialEq< ::bevy_math::primitives::Sphere, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -6379,11 +6091,10 @@ pub(crate) fn register_sphere_functions(world: &mut World) { |radius: f32| { let output: Val<::bevy_math::primitives::Sphere> = { { - let output: Val<::bevy_math::primitives::Sphere> = ::bevy_math::primitives::Sphere::new( - radius, - ) - .into(); - output + let output: ::bevy_math::primitives::Sphere = ::bevy_math::primitives::Sphere::new( + safe_transmute(radius), + ); + safe_transmute(output) } }; output @@ -6408,11 +6119,10 @@ pub(crate) fn register_cuboid_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Cuboid>| { let output: Val<::bevy_math::primitives::Cuboid> = { { - let output: Val<::bevy_math::primitives::Cuboid> = <::bevy_math::primitives::Cuboid as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Cuboid = <::bevy_math::primitives::Cuboid as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6425,12 +6135,11 @@ pub(crate) fn register_cuboid_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Cuboid>, point: Val<::bevy_math::Vec3>| { let output: Val<::bevy_math::Vec3> = { { - let output: Val<::bevy_math::Vec3> = ::bevy_math::primitives::Cuboid::closest_point( - &_self, - point.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Vec3 = ::bevy_math::primitives::Cuboid::closest_point( + safe_transmute(_self), + safe_transmute(point), + ); + safe_transmute(output) } }; output @@ -6448,9 +6157,8 @@ pub(crate) fn register_cuboid_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Cuboid as ::core::cmp::PartialEq< ::bevy_math::primitives::Cuboid, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -6463,12 +6171,11 @@ pub(crate) fn register_cuboid_functions(world: &mut World) { |point1: Val<::bevy_math::Vec3>, point2: Val<::bevy_math::Vec3>| { let output: Val<::bevy_math::primitives::Cuboid> = { { - let output: Val<::bevy_math::primitives::Cuboid> = ::bevy_math::primitives::Cuboid::from_corners( - point1.into_inner(), - point2.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Cuboid = ::bevy_math::primitives::Cuboid::from_corners( + safe_transmute(point1), + safe_transmute(point2), + ); + safe_transmute(output) } }; output @@ -6481,11 +6188,10 @@ pub(crate) fn register_cuboid_functions(world: &mut World) { |length: f32| { let output: Val<::bevy_math::primitives::Cuboid> = { { - let output: Val<::bevy_math::primitives::Cuboid> = ::bevy_math::primitives::Cuboid::from_length( - length, - ) - .into(); - output + let output: ::bevy_math::primitives::Cuboid = ::bevy_math::primitives::Cuboid::from_length( + safe_transmute(length), + ); + safe_transmute(output) } }; output @@ -6498,11 +6204,10 @@ pub(crate) fn register_cuboid_functions(world: &mut World) { |size: Val<::bevy_math::Vec3>| { let output: Val<::bevy_math::primitives::Cuboid> = { { - let output: Val<::bevy_math::primitives::Cuboid> = ::bevy_math::primitives::Cuboid::from_size( - size.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Cuboid = ::bevy_math::primitives::Cuboid::from_size( + safe_transmute(size), + ); + safe_transmute(output) } }; output @@ -6515,13 +6220,12 @@ pub(crate) fn register_cuboid_functions(world: &mut World) { |x_length: f32, y_length: f32, z_length: f32| { let output: Val<::bevy_math::primitives::Cuboid> = { { - let output: Val<::bevy_math::primitives::Cuboid> = ::bevy_math::primitives::Cuboid::new( - x_length, - y_length, - z_length, - ) - .into(); - output + let output: ::bevy_math::primitives::Cuboid = ::bevy_math::primitives::Cuboid::new( + safe_transmute(x_length), + safe_transmute(y_length), + safe_transmute(z_length), + ); + safe_transmute(output) } }; output @@ -6534,11 +6238,10 @@ pub(crate) fn register_cuboid_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Cuboid>| { let output: Val<::bevy_math::Vec3> = { { - let output: Val<::bevy_math::Vec3> = ::bevy_math::primitives::Cuboid::size( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec3 = ::bevy_math::primitives::Cuboid::size( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6563,11 +6266,10 @@ pub(crate) fn register_cylinder_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Cylinder>| { let output: Val<::bevy_math::primitives::Circle> = { { - let output: Val<::bevy_math::primitives::Circle> = ::bevy_math::primitives::Cylinder::base( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Circle = ::bevy_math::primitives::Cylinder::base( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6581,10 +6283,9 @@ pub(crate) fn register_cylinder_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Cylinder::base_area( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6597,11 +6298,10 @@ pub(crate) fn register_cylinder_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Cylinder>| { let output: Val<::bevy_math::primitives::Cylinder> = { { - let output: Val<::bevy_math::primitives::Cylinder> = <::bevy_math::primitives::Cylinder as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Cylinder = <::bevy_math::primitives::Cylinder as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6619,9 +6319,8 @@ pub(crate) fn register_cylinder_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Cylinder as ::core::cmp::PartialEq< ::bevy_math::primitives::Cylinder, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -6635,10 +6334,9 @@ pub(crate) fn register_cylinder_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Cylinder::lateral_area( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6651,12 +6349,11 @@ pub(crate) fn register_cylinder_functions(world: &mut World) { |radius: f32, height: f32| { let output: Val<::bevy_math::primitives::Cylinder> = { { - let output: Val<::bevy_math::primitives::Cylinder> = ::bevy_math::primitives::Cylinder::new( - radius, - height, - ) - .into(); - output + let output: ::bevy_math::primitives::Cylinder = ::bevy_math::primitives::Cylinder::new( + safe_transmute(radius), + safe_transmute(height), + ); + safe_transmute(output) } }; output @@ -6681,11 +6378,10 @@ pub(crate) fn register_capsule_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Capsule3d>| { let output: Val<::bevy_math::primitives::Capsule3d> = { { - let output: Val<::bevy_math::primitives::Capsule3d> = <::bevy_math::primitives::Capsule3d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Capsule3d = <::bevy_math::primitives::Capsule3d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6703,9 +6399,8 @@ pub(crate) fn register_capsule_3_d_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Capsule3d as ::core::cmp::PartialEq< ::bevy_math::primitives::Capsule3d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -6718,12 +6413,11 @@ pub(crate) fn register_capsule_3_d_functions(world: &mut World) { |radius: f32, length: f32| { let output: Val<::bevy_math::primitives::Capsule3d> = { { - let output: Val<::bevy_math::primitives::Capsule3d> = ::bevy_math::primitives::Capsule3d::new( - radius, - length, - ) - .into(); - output + let output: ::bevy_math::primitives::Capsule3d = ::bevy_math::primitives::Capsule3d::new( + safe_transmute(radius), + safe_transmute(length), + ); + safe_transmute(output) } }; output @@ -6736,11 +6430,10 @@ pub(crate) fn register_capsule_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Capsule3d>| { let output: Val<::bevy_math::primitives::Cylinder> = { { - let output: Val<::bevy_math::primitives::Cylinder> = ::bevy_math::primitives::Capsule3d::to_cylinder( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Cylinder = ::bevy_math::primitives::Capsule3d::to_cylinder( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6765,11 +6458,10 @@ pub(crate) fn register_cone_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Cone>| { let output: Val<::bevy_math::primitives::Circle> = { { - let output: Val<::bevy_math::primitives::Circle> = ::bevy_math::primitives::Cone::base( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Circle = ::bevy_math::primitives::Cone::base( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6783,10 +6475,9 @@ pub(crate) fn register_cone_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Cone::base_area( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6799,11 +6490,10 @@ pub(crate) fn register_cone_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Cone>| { let output: Val<::bevy_math::primitives::Cone> = { { - let output: Val<::bevy_math::primitives::Cone> = <::bevy_math::primitives::Cone as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Cone = <::bevy_math::primitives::Cone as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6821,9 +6511,8 @@ pub(crate) fn register_cone_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Cone as ::core::cmp::PartialEq< ::bevy_math::primitives::Cone, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -6837,10 +6526,9 @@ pub(crate) fn register_cone_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Cone::lateral_area( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6853,12 +6541,11 @@ pub(crate) fn register_cone_functions(world: &mut World) { |radius: f32, height: f32| { let output: Val<::bevy_math::primitives::Cone> = { { - let output: Val<::bevy_math::primitives::Cone> = ::bevy_math::primitives::Cone::new( - radius, - height, - ) - .into(); - output + let output: ::bevy_math::primitives::Cone = ::bevy_math::primitives::Cone::new( + safe_transmute(radius), + safe_transmute(height), + ); + safe_transmute(output) } }; output @@ -6872,10 +6559,9 @@ pub(crate) fn register_cone_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Cone::slant_height( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6900,11 +6586,10 @@ pub(crate) fn register_conical_frustum_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::ConicalFrustum>| { let output: Val<::bevy_math::primitives::ConicalFrustum> = { { - let output: Val<::bevy_math::primitives::ConicalFrustum> = <::bevy_math::primitives::ConicalFrustum as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::ConicalFrustum = <::bevy_math::primitives::ConicalFrustum as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6922,9 +6607,8 @@ pub(crate) fn register_conical_frustum_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::ConicalFrustum as ::core::cmp::PartialEq< ::bevy_math::primitives::ConicalFrustum, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -6949,11 +6633,10 @@ pub(crate) fn register_infinite_plane_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::InfinitePlane3d>| { let output: Val<::bevy_math::primitives::InfinitePlane3d> = { { - let output: Val<::bevy_math::primitives::InfinitePlane3d> = <::bevy_math::primitives::InfinitePlane3d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::InfinitePlane3d = <::bevy_math::primitives::InfinitePlane3d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6971,9 +6654,8 @@ pub(crate) fn register_infinite_plane_3_d_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::InfinitePlane3d as ::core::cmp::PartialEq< ::bevy_math::primitives::InfinitePlane3d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -6989,12 +6671,11 @@ pub(crate) fn register_infinite_plane_3_d_functions(world: &mut World) { { let output: Val<::bevy_math::Isometry3d> = { { - let output: Val<::bevy_math::Isometry3d> = ::bevy_math::primitives::InfinitePlane3d::isometry_from_xy( - &_self, - origin.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Isometry3d = ::bevy_math::primitives::InfinitePlane3d::isometry_from_xy( + safe_transmute(_self), + safe_transmute(origin), + ); + safe_transmute(output) } }; output @@ -7010,12 +6691,11 @@ pub(crate) fn register_infinite_plane_3_d_functions(world: &mut World) { { let output: Val<::bevy_math::Isometry3d> = { { - let output: Val<::bevy_math::Isometry3d> = ::bevy_math::primitives::InfinitePlane3d::isometry_into_xy( - &_self, - origin.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Isometry3d = ::bevy_math::primitives::InfinitePlane3d::isometry_into_xy( + safe_transmute(_self), + safe_transmute(origin), + ); + safe_transmute(output) } }; output @@ -7040,11 +6720,10 @@ pub(crate) fn register_line_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Line3d>| { let output: Val<::bevy_math::primitives::Line3d> = { { - let output: Val<::bevy_math::primitives::Line3d> = <::bevy_math::primitives::Line3d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Line3d = <::bevy_math::primitives::Line3d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7062,9 +6741,8 @@ pub(crate) fn register_line_3_d_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Line3d as ::core::cmp::PartialEq< ::bevy_math::primitives::Line3d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -7089,11 +6767,10 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Segment3d>| { let output: Val<::bevy_math::Vec3> = { { - let output: Val<::bevy_math::Vec3> = ::bevy_math::primitives::Segment3d::center( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec3 = ::bevy_math::primitives::Segment3d::center( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7106,11 +6783,10 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Segment3d>| { let output: Val<::bevy_math::primitives::Segment3d> = { { - let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::centered( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Segment3d = ::bevy_math::primitives::Segment3d::centered( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7123,11 +6799,10 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Segment3d>| { let output: Val<::bevy_math::primitives::Segment3d> = { { - let output: Val<::bevy_math::primitives::Segment3d> = <::bevy_math::primitives::Segment3d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Segment3d = <::bevy_math::primitives::Segment3d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7143,12 +6818,11 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { { let output: Val<::bevy_math::Vec3> = { { - let output: Val<::bevy_math::Vec3> = ::bevy_math::primitives::Segment3d::closest_point( - &_self, - point.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Vec3 = ::bevy_math::primitives::Segment3d::closest_point( + safe_transmute(_self), + safe_transmute(point), + ); + safe_transmute(output) } }; output @@ -7161,11 +6835,10 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Segment3d>| { let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::Dir3> = ::bevy_math::primitives::Segment3d::direction( - &_self, - ) - .into(); - output + let output: ::bevy_math::Dir3 = ::bevy_math::primitives::Segment3d::direction( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7183,9 +6856,8 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Segment3d as ::core::cmp::PartialEq< ::bevy_math::primitives::Segment3d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -7198,12 +6870,11 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { |direction: Val<::bevy_math::Dir3>, length: f32| { let output: Val<::bevy_math::primitives::Segment3d> = { { - let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::from_direction_and_length( - direction.into_inner(), - length, - ) - .into(); - output + let output: ::bevy_math::primitives::Segment3d = ::bevy_math::primitives::Segment3d::from_direction_and_length( + safe_transmute(direction), + safe_transmute(length), + ); + safe_transmute(output) } }; output @@ -7216,12 +6887,11 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { |ray: Val<::bevy_math::Ray3d>, length: f32| { let output: Val<::bevy_math::primitives::Segment3d> = { { - let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::from_ray_and_length( - ray.into_inner(), - length, - ) - .into(); - output + let output: ::bevy_math::primitives::Segment3d = ::bevy_math::primitives::Segment3d::from_ray_and_length( + safe_transmute(ray), + safe_transmute(length), + ); + safe_transmute(output) } }; output @@ -7234,11 +6904,10 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { |scaled_direction: Val<::bevy_math::Vec3>| { let output: Val<::bevy_math::primitives::Segment3d> = { { - let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::from_scaled_direction( - scaled_direction.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Segment3d = ::bevy_math::primitives::Segment3d::from_scaled_direction( + safe_transmute(scaled_direction), + ); + safe_transmute(output) } }; output @@ -7252,10 +6921,9 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Segment3d::length( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7269,10 +6937,9 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Segment3d::length_squared( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7285,12 +6952,11 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { |point1: Val<::bevy_math::Vec3>, point2: Val<::bevy_math::Vec3>| { let output: Val<::bevy_math::primitives::Segment3d> = { { - let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::new( - point1.into_inner(), - point2.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Segment3d = ::bevy_math::primitives::Segment3d::new( + safe_transmute(point1), + safe_transmute(point2), + ); + safe_transmute(output) } }; output @@ -7303,11 +6969,10 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Segment3d>| { let output: Val<::bevy_math::Vec3> = { { - let output: Val<::bevy_math::Vec3> = ::bevy_math::primitives::Segment3d::point1( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec3 = ::bevy_math::primitives::Segment3d::point1( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7320,11 +6985,10 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Segment3d>| { let output: Val<::bevy_math::Vec3> = { { - let output: Val<::bevy_math::Vec3> = ::bevy_math::primitives::Segment3d::point2( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec3 = ::bevy_math::primitives::Segment3d::point2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7337,12 +7001,11 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Segment3d>, length: f32| { let output: Val<::bevy_math::primitives::Segment3d> = { { - let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::resized( - &_self, - length, - ) - .into(); - output + let output: ::bevy_math::primitives::Segment3d = ::bevy_math::primitives::Segment3d::resized( + safe_transmute(_self), + safe_transmute(length), + ); + safe_transmute(output) } }; output @@ -7356,10 +7019,9 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_math::primitives::Segment3d::reverse( - &mut _self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7372,11 +7034,10 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { |_self: Val<::bevy_math::primitives::Segment3d>| { let output: Val<::bevy_math::primitives::Segment3d> = { { - let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::reversed( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Segment3d = ::bevy_math::primitives::Segment3d::reversed( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7392,12 +7053,11 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { { let output: Val<::bevy_math::primitives::Segment3d> = { { - let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::rotated( - &_self, - rotation.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Segment3d = ::bevy_math::primitives::Segment3d::rotated( + safe_transmute(_self), + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -7414,13 +7074,12 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { { let output: Val<::bevy_math::primitives::Segment3d> = { { - let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::rotated_around( - &_self, - rotation.into_inner(), - point.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Segment3d = ::bevy_math::primitives::Segment3d::rotated_around( + safe_transmute(_self), + safe_transmute(rotation), + safe_transmute(point), + ); + safe_transmute(output) } }; output @@ -7436,12 +7095,11 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { { let output: Val<::bevy_math::primitives::Segment3d> = { { - let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::rotated_around_center( - &_self, - rotation.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Segment3d = ::bevy_math::primitives::Segment3d::rotated_around_center( + safe_transmute(_self), + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -7454,11 +7112,10 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Segment3d>| { let output: Val<::bevy_math::Vec3> = { { - let output: Val<::bevy_math::Vec3> = ::bevy_math::primitives::Segment3d::scaled_direction( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec3 = ::bevy_math::primitives::Segment3d::scaled_direction( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7474,12 +7131,11 @@ pub(crate) fn register_segment_3_d_functions(world: &mut World) { { let output: Val<::bevy_math::primitives::Segment3d> = { { - let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::translated( - &_self, - translation.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Segment3d = ::bevy_math::primitives::Segment3d::translated( + safe_transmute(_self), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -7504,11 +7160,10 @@ pub(crate) fn register_torus_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Torus>| { let output: Val<::bevy_math::primitives::Torus> = { { - let output: Val<::bevy_math::primitives::Torus> = <::bevy_math::primitives::Torus as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Torus = <::bevy_math::primitives::Torus as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7526,9 +7181,8 @@ pub(crate) fn register_torus_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Torus as ::core::cmp::PartialEq< ::bevy_math::primitives::Torus, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -7542,10 +7196,9 @@ pub(crate) fn register_torus_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Torus::inner_radius( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7558,12 +7211,11 @@ pub(crate) fn register_torus_functions(world: &mut World) { |inner_radius: f32, outer_radius: f32| { let output: Val<::bevy_math::primitives::Torus> = { { - let output: Val<::bevy_math::primitives::Torus> = ::bevy_math::primitives::Torus::new( - inner_radius, - outer_radius, - ) - .into(); - output + let output: ::bevy_math::primitives::Torus = ::bevy_math::primitives::Torus::new( + safe_transmute(inner_radius), + safe_transmute(outer_radius), + ); + safe_transmute(output) } }; output @@ -7577,10 +7229,9 @@ pub(crate) fn register_torus_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Torus::outer_radius( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7605,11 +7256,10 @@ pub(crate) fn register_triangle_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Triangle3d>| { let output: Val<::bevy_math::Vec3> = { { - let output: Val<::bevy_math::Vec3> = ::bevy_math::primitives::Triangle3d::centroid( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec3 = ::bevy_math::primitives::Triangle3d::centroid( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7622,11 +7272,10 @@ pub(crate) fn register_triangle_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Triangle3d>| { let output: Val<::bevy_math::Vec3> = { { - let output: Val<::bevy_math::Vec3> = ::bevy_math::primitives::Triangle3d::circumcenter( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec3 = ::bevy_math::primitives::Triangle3d::circumcenter( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7639,11 +7288,10 @@ pub(crate) fn register_triangle_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Triangle3d>| { let output: Val<::bevy_math::primitives::Triangle3d> = { { - let output: Val<::bevy_math::primitives::Triangle3d> = <::bevy_math::primitives::Triangle3d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Triangle3d = <::bevy_math::primitives::Triangle3d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7661,9 +7309,8 @@ pub(crate) fn register_triangle_3_d_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Triangle3d as ::core::cmp::PartialEq< ::bevy_math::primitives::Triangle3d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -7677,10 +7324,9 @@ pub(crate) fn register_triangle_3_d_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_math::primitives::Triangle3d::is_acute( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7694,10 +7340,9 @@ pub(crate) fn register_triangle_3_d_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_math::primitives::Triangle3d::is_degenerate( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7711,10 +7356,9 @@ pub(crate) fn register_triangle_3_d_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_math::primitives::Triangle3d::is_obtuse( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7731,13 +7375,12 @@ pub(crate) fn register_triangle_3_d_functions(world: &mut World) { { let output: Val<::bevy_math::primitives::Triangle3d> = { { - let output: Val<::bevy_math::primitives::Triangle3d> = ::bevy_math::primitives::Triangle3d::new( - a.into_inner(), - b.into_inner(), - c.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Triangle3d = ::bevy_math::primitives::Triangle3d::new( + safe_transmute(a), + safe_transmute(b), + safe_transmute(c), + ); + safe_transmute(output) } }; output @@ -7751,10 +7394,9 @@ pub(crate) fn register_triangle_3_d_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_math::primitives::Triangle3d::reverse( - &mut _self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7767,11 +7409,10 @@ pub(crate) fn register_triangle_3_d_functions(world: &mut World) { |_self: Val<::bevy_math::primitives::Triangle3d>| { let output: Val<::bevy_math::primitives::Triangle3d> = { { - let output: Val<::bevy_math::primitives::Triangle3d> = ::bevy_math::primitives::Triangle3d::reversed( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Triangle3d = ::bevy_math::primitives::Triangle3d::reversed( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7796,11 +7437,10 @@ pub(crate) fn register_polyline_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Polyline3d>| { let output: Val<::bevy_math::primitives::Polyline3d> = { { - let output: Val<::bevy_math::primitives::Polyline3d> = <::bevy_math::primitives::Polyline3d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Polyline3d = <::bevy_math::primitives::Polyline3d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7818,9 +7458,8 @@ pub(crate) fn register_polyline_3_d_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Polyline3d as ::core::cmp::PartialEq< ::bevy_math::primitives::Polyline3d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -7837,13 +7476,12 @@ pub(crate) fn register_polyline_3_d_functions(world: &mut World) { { let output: Val<::bevy_math::primitives::Polyline3d> = { { - let output: Val<::bevy_math::primitives::Polyline3d> = ::bevy_math::primitives::Polyline3d::with_subdivisions( - start.into_inner(), - end.into_inner(), - subdivisions, - ) - .into(); - output + let output: ::bevy_math::primitives::Polyline3d = ::bevy_math::primitives::Polyline3d::with_subdivisions( + safe_transmute(start), + safe_transmute(end), + safe_transmute(subdivisions), + ); + safe_transmute(output) } }; output @@ -7872,11 +7510,10 @@ pub(crate) fn register_ray_cast_2_d_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::bevy_math::bounding::RayCast2d::aabb_intersection_at( - &_self, - &aabb, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(aabb), + ); + safe_transmute(output) } }; output @@ -7893,11 +7530,10 @@ pub(crate) fn register_ray_cast_2_d_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::bevy_math::bounding::RayCast2d::circle_intersection_at( - &_self, - &circle, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(circle), + ); + safe_transmute(output) } }; output @@ -7910,11 +7546,10 @@ pub(crate) fn register_ray_cast_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::bounding::RayCast2d>| { let output: Val<::bevy_math::bounding::RayCast2d> = { { - let output: Val<::bevy_math::bounding::RayCast2d> = <::bevy_math::bounding::RayCast2d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::bounding::RayCast2d = <::bevy_math::bounding::RayCast2d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7927,11 +7562,10 @@ pub(crate) fn register_ray_cast_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::bounding::RayCast2d>| { let output: Val<::bevy_math::Vec2> = { { - let output: Val<::bevy_math::Vec2> = ::bevy_math::bounding::RayCast2d::direction_recip( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_math::bounding::RayCast2d::direction_recip( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7944,12 +7578,11 @@ pub(crate) fn register_ray_cast_2_d_functions(world: &mut World) { |ray: Val<::bevy_math::Ray2d>, max: f32| { let output: Val<::bevy_math::bounding::RayCast2d> = { { - let output: Val<::bevy_math::bounding::RayCast2d> = ::bevy_math::bounding::RayCast2d::from_ray( - ray.into_inner(), - max, - ) - .into(); - output + let output: ::bevy_math::bounding::RayCast2d = ::bevy_math::bounding::RayCast2d::from_ray( + safe_transmute(ray), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -7966,13 +7599,12 @@ pub(crate) fn register_ray_cast_2_d_functions(world: &mut World) { { let output: Val<::bevy_math::bounding::RayCast2d> = { { - let output: Val<::bevy_math::bounding::RayCast2d> = ::bevy_math::bounding::RayCast2d::new( - origin.into_inner(), - direction.into_inner(), - max, - ) - .into(); - output + let output: ::bevy_math::bounding::RayCast2d = ::bevy_math::bounding::RayCast2d::new( + safe_transmute(origin), + safe_transmute(direction), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -8001,11 +7633,10 @@ pub(crate) fn register_aabb_cast_2_d_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::bevy_math::bounding::AabbCast2d::aabb_collision_at( - &_self, - aabb.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(aabb), + ); + safe_transmute(output) } }; output @@ -8018,11 +7649,10 @@ pub(crate) fn register_aabb_cast_2_d_functions(world: &mut World) { |_self: Ref<::bevy_math::bounding::AabbCast2d>| { let output: Val<::bevy_math::bounding::AabbCast2d> = { { - let output: Val<::bevy_math::bounding::AabbCast2d> = <::bevy_math::bounding::AabbCast2d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::bounding::AabbCast2d = <::bevy_math::bounding::AabbCast2d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8039,13 +7669,12 @@ pub(crate) fn register_aabb_cast_2_d_functions(world: &mut World) { { let output: Val<::bevy_math::bounding::AabbCast2d> = { { - let output: Val<::bevy_math::bounding::AabbCast2d> = ::bevy_math::bounding::AabbCast2d::from_ray( - aabb.into_inner(), - ray.into_inner(), - max, - ) - .into(); - output + let output: ::bevy_math::bounding::AabbCast2d = ::bevy_math::bounding::AabbCast2d::from_ray( + safe_transmute(aabb), + safe_transmute(ray), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -8063,14 +7692,13 @@ pub(crate) fn register_aabb_cast_2_d_functions(world: &mut World) { { let output: Val<::bevy_math::bounding::AabbCast2d> = { { - let output: Val<::bevy_math::bounding::AabbCast2d> = ::bevy_math::bounding::AabbCast2d::new( - aabb.into_inner(), - origin.into_inner(), - direction.into_inner(), - max, - ) - .into(); - output + let output: ::bevy_math::bounding::AabbCast2d = ::bevy_math::bounding::AabbCast2d::new( + safe_transmute(aabb), + safe_transmute(origin), + safe_transmute(direction), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -8099,11 +7727,10 @@ pub(crate) fn register_bounding_circle_cast_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::bevy_math::bounding::BoundingCircleCast::circle_collision_at( - &_self, - circle.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(circle), + ); + safe_transmute(output) } }; output @@ -8116,11 +7743,10 @@ pub(crate) fn register_bounding_circle_cast_functions(world: &mut World) { |_self: Ref<::bevy_math::bounding::BoundingCircleCast>| { let output: Val<::bevy_math::bounding::BoundingCircleCast> = { { - let output: Val<::bevy_math::bounding::BoundingCircleCast> = <::bevy_math::bounding::BoundingCircleCast as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::bounding::BoundingCircleCast = <::bevy_math::bounding::BoundingCircleCast as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8137,13 +7763,12 @@ pub(crate) fn register_bounding_circle_cast_functions(world: &mut World) { { let output: Val<::bevy_math::bounding::BoundingCircleCast> = { { - let output: Val<::bevy_math::bounding::BoundingCircleCast> = ::bevy_math::bounding::BoundingCircleCast::from_ray( - circle.into_inner(), - ray.into_inner(), - max, - ) - .into(); - output + let output: ::bevy_math::bounding::BoundingCircleCast = ::bevy_math::bounding::BoundingCircleCast::from_ray( + safe_transmute(circle), + safe_transmute(ray), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -8161,14 +7786,13 @@ pub(crate) fn register_bounding_circle_cast_functions(world: &mut World) { { let output: Val<::bevy_math::bounding::BoundingCircleCast> = { { - let output: Val<::bevy_math::bounding::BoundingCircleCast> = ::bevy_math::bounding::BoundingCircleCast::new( - circle.into_inner(), - origin.into_inner(), - direction.into_inner(), - max, - ) - .into(); - output + let output: ::bevy_math::bounding::BoundingCircleCast = ::bevy_math::bounding::BoundingCircleCast::new( + safe_transmute(circle), + safe_transmute(origin), + safe_transmute(direction), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -8197,11 +7821,10 @@ pub(crate) fn register_ray_cast_3_d_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::bevy_math::bounding::RayCast3d::aabb_intersection_at( - &_self, - &aabb, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(aabb), + ); + safe_transmute(output) } }; output @@ -8214,11 +7837,10 @@ pub(crate) fn register_ray_cast_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::bounding::RayCast3d>| { let output: Val<::bevy_math::bounding::RayCast3d> = { { - let output: Val<::bevy_math::bounding::RayCast3d> = <::bevy_math::bounding::RayCast3d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::bounding::RayCast3d = <::bevy_math::bounding::RayCast3d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8231,11 +7853,10 @@ pub(crate) fn register_ray_cast_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::bounding::RayCast3d>| { let output: Val<::bevy_math::Vec3A> = { { - let output: Val<::bevy_math::Vec3A> = ::bevy_math::bounding::RayCast3d::direction_recip( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec3A = ::bevy_math::bounding::RayCast3d::direction_recip( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8248,12 +7869,11 @@ pub(crate) fn register_ray_cast_3_d_functions(world: &mut World) { |ray: Val<::bevy_math::Ray3d>, max: f32| { let output: Val<::bevy_math::bounding::RayCast3d> = { { - let output: Val<::bevy_math::bounding::RayCast3d> = ::bevy_math::bounding::RayCast3d::from_ray( - ray.into_inner(), - max, - ) - .into(); - output + let output: ::bevy_math::bounding::RayCast3d = ::bevy_math::bounding::RayCast3d::from_ray( + safe_transmute(ray), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -8270,11 +7890,10 @@ pub(crate) fn register_ray_cast_3_d_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::bevy_math::bounding::RayCast3d::sphere_intersection_at( - &_self, - &sphere, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(sphere), + ); + safe_transmute(output) } }; output @@ -8303,11 +7922,10 @@ pub(crate) fn register_aabb_cast_3_d_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::bevy_math::bounding::AabbCast3d::aabb_collision_at( - &_self, - aabb.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(aabb), + ); + safe_transmute(output) } }; output @@ -8320,11 +7938,10 @@ pub(crate) fn register_aabb_cast_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::bounding::AabbCast3d>| { let output: Val<::bevy_math::bounding::AabbCast3d> = { { - let output: Val<::bevy_math::bounding::AabbCast3d> = <::bevy_math::bounding::AabbCast3d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::bounding::AabbCast3d = <::bevy_math::bounding::AabbCast3d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8341,13 +7958,12 @@ pub(crate) fn register_aabb_cast_3_d_functions(world: &mut World) { { let output: Val<::bevy_math::bounding::AabbCast3d> = { { - let output: Val<::bevy_math::bounding::AabbCast3d> = ::bevy_math::bounding::AabbCast3d::from_ray( - aabb.into_inner(), - ray.into_inner(), - max, - ) - .into(); - output + let output: ::bevy_math::bounding::AabbCast3d = ::bevy_math::bounding::AabbCast3d::from_ray( + safe_transmute(aabb), + safe_transmute(ray), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -8372,11 +7988,10 @@ pub(crate) fn register_bounding_sphere_cast_functions(world: &mut World) { |_self: Ref<::bevy_math::bounding::BoundingSphereCast>| { let output: Val<::bevy_math::bounding::BoundingSphereCast> = { { - let output: Val<::bevy_math::bounding::BoundingSphereCast> = <::bevy_math::bounding::BoundingSphereCast as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::bounding::BoundingSphereCast = <::bevy_math::bounding::BoundingSphereCast as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8393,13 +8008,12 @@ pub(crate) fn register_bounding_sphere_cast_functions(world: &mut World) { { let output: Val<::bevy_math::bounding::BoundingSphereCast> = { { - let output: Val<::bevy_math::bounding::BoundingSphereCast> = ::bevy_math::bounding::BoundingSphereCast::from_ray( - sphere.into_inner(), - ray.into_inner(), - max, - ) - .into(); - output + let output: ::bevy_math::bounding::BoundingSphereCast = ::bevy_math::bounding::BoundingSphereCast::from_ray( + safe_transmute(sphere), + safe_transmute(ray), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -8416,11 +8030,10 @@ pub(crate) fn register_bounding_sphere_cast_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::bevy_math::bounding::BoundingSphereCast::sphere_collision_at( - &_self, - sphere.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(sphere), + ); + safe_transmute(output) } }; output @@ -8446,11 +8059,10 @@ pub(crate) fn register_interval_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::curve::Interval::clamp( - _self.into_inner(), - value, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -8463,11 +8075,10 @@ pub(crate) fn register_interval_functions(world: &mut World) { |_self: Ref<::bevy_math::curve::Interval>| { let output: Val<::bevy_math::curve::Interval> = { { - let output: Val<::bevy_math::curve::Interval> = <::bevy_math::curve::Interval as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::curve::Interval = <::bevy_math::curve::Interval as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8481,11 +8092,10 @@ pub(crate) fn register_interval_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_math::curve::Interval::contains( - _self.into_inner(), - item, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(item), + ); + safe_transmute(output) } }; output @@ -8502,11 +8112,10 @@ pub(crate) fn register_interval_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_math::curve::Interval::contains_interval( - _self.into_inner(), - other.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -8520,10 +8129,9 @@ pub(crate) fn register_interval_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::curve::Interval::end( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8541,9 +8149,8 @@ pub(crate) fn register_interval_functions(world: &mut World) { { let output: bool = <::bevy_math::curve::Interval as ::core::cmp::PartialEq< ::bevy_math::curve::Interval, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -8557,10 +8164,9 @@ pub(crate) fn register_interval_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_math::curve::Interval::has_finite_end( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8574,10 +8180,9 @@ pub(crate) fn register_interval_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_math::curve::Interval::has_finite_start( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8591,10 +8196,9 @@ pub(crate) fn register_interval_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_math::curve::Interval::is_bounded( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8608,10 +8212,9 @@ pub(crate) fn register_interval_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::curve::Interval::length( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8625,10 +8228,9 @@ pub(crate) fn register_interval_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::curve::Interval::start( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8653,11 +8255,10 @@ pub(crate) fn register_dir_4_functions(world: &mut World) { |_self: Ref<::bevy_math::Dir4>| { let output: Val<::bevy_math::Vec4> = { { - let output: Val<::bevy_math::Vec4> = ::bevy_math::Dir4::as_vec4( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec4 = ::bevy_math::Dir4::as_vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8670,11 +8271,10 @@ pub(crate) fn register_dir_4_functions(world: &mut World) { |_self: Ref<::bevy_math::Dir4>| { let output: Val<::bevy_math::Dir4> = { { - let output: Val<::bevy_math::Dir4> = <::bevy_math::Dir4 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::Dir4 = <::bevy_math::Dir4 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8689,9 +8289,8 @@ pub(crate) fn register_dir_4_functions(world: &mut World) { { let output: bool = <::bevy_math::Dir4 as ::core::cmp::PartialEq< ::bevy_math::Dir4, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -8704,11 +8303,10 @@ pub(crate) fn register_dir_4_functions(world: &mut World) { |_self: Val<::bevy_math::Dir4>| { let output: Val<::bevy_math::Dir4> = { { - let output: Val<::bevy_math::Dir4> = ::bevy_math::Dir4::fast_renormalize( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Dir4 = ::bevy_math::Dir4::fast_renormalize( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8721,14 +8319,13 @@ pub(crate) fn register_dir_4_functions(world: &mut World) { |x: f32, y: f32, z: f32, w: f32| { let output: Val<::bevy_math::Dir4> = { { - let output: Val<::bevy_math::Dir4> = ::bevy_math::Dir4::from_xyzw_unchecked( - x, - y, - z, - w, - ) - .into(); - output + let output: ::bevy_math::Dir4 = ::bevy_math::Dir4::from_xyzw_unchecked( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -8741,11 +8338,10 @@ pub(crate) fn register_dir_4_functions(world: &mut World) { |_self: Val<::bevy_math::Dir4>, rhs: f32| { let output: Val<::bevy_math::Vec4> = { { - let output: Val<::bevy_math::Vec4> = <::bevy_math::Dir4 as ::core::ops::Mul< + let output: ::bevy_math::Vec4 = <::bevy_math::Dir4 as ::core::ops::Mul< f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -8758,11 +8354,10 @@ pub(crate) fn register_dir_4_functions(world: &mut World) { |_self: Val<::bevy_math::Dir4>| { let output: Val<::bevy_math::Dir4> = { { - let output: Val<::bevy_math::Dir4> = <::bevy_math::Dir4 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Dir4 = <::bevy_math::Dir4 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8775,11 +8370,10 @@ pub(crate) fn register_dir_4_functions(world: &mut World) { |value: Val<::bevy_math::Vec4>| { let output: Val<::bevy_math::Dir4> = { { - let output: Val<::bevy_math::Dir4> = ::bevy_math::Dir4::new_unchecked( - value.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Dir4 = ::bevy_math::Dir4::new_unchecked( + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -8804,11 +8398,10 @@ pub(crate) fn register_float_ord_functions(world: &mut World) { |_self: Ref<::bevy_math::FloatOrd>| { let output: Val<::bevy_math::FloatOrd> = { { - let output: Val<::bevy_math::FloatOrd> = <::bevy_math::FloatOrd as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::FloatOrd = <::bevy_math::FloatOrd as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8823,9 +8416,8 @@ pub(crate) fn register_float_ord_functions(world: &mut World) { { let output: bool = <::bevy_math::FloatOrd as ::core::cmp::PartialEq< ::bevy_math::FloatOrd, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -8840,9 +8432,8 @@ pub(crate) fn register_float_ord_functions(world: &mut World) { { let output: bool = <::bevy_math::FloatOrd as ::core::cmp::PartialOrd< ::bevy_math::FloatOrd, - >>::ge(&_self, &other) - .into(); - output + >>::ge(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -8857,9 +8448,8 @@ pub(crate) fn register_float_ord_functions(world: &mut World) { { let output: bool = <::bevy_math::FloatOrd as ::core::cmp::PartialOrd< ::bevy_math::FloatOrd, - >>::gt(&_self, &other) - .into(); - output + >>::gt(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -8874,9 +8464,8 @@ pub(crate) fn register_float_ord_functions(world: &mut World) { { let output: bool = <::bevy_math::FloatOrd as ::core::cmp::PartialOrd< ::bevy_math::FloatOrd, - >>::le(&_self, &other) - .into(); - output + >>::le(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -8891,9 +8480,8 @@ pub(crate) fn register_float_ord_functions(world: &mut World) { { let output: bool = <::bevy_math::FloatOrd as ::core::cmp::PartialOrd< ::bevy_math::FloatOrd, - >>::lt(&_self, &other) - .into(); - output + >>::lt(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -8906,11 +8494,10 @@ pub(crate) fn register_float_ord_functions(world: &mut World) { |_self: Val<::bevy_math::FloatOrd>| { let output: Val<::bevy_math::FloatOrd> = { { - let output: Val<::bevy_math::FloatOrd> = <::bevy_math::FloatOrd as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_math::FloatOrd = <::bevy_math::FloatOrd as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8935,11 +8522,10 @@ pub(crate) fn register_plane_3_d_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Plane3d>| { let output: Val<::bevy_math::primitives::Plane3d> = { { - let output: Val<::bevy_math::primitives::Plane3d> = <::bevy_math::primitives::Plane3d as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Plane3d = <::bevy_math::primitives::Plane3d as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8957,9 +8543,8 @@ pub(crate) fn register_plane_3_d_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Plane3d as ::core::cmp::PartialEq< ::bevy_math::primitives::Plane3d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -8972,12 +8557,11 @@ pub(crate) fn register_plane_3_d_functions(world: &mut World) { |normal: Val<::bevy_math::Vec3>, half_size: Val<::bevy_math::Vec2>| { let output: Val<::bevy_math::primitives::Plane3d> = { { - let output: Val<::bevy_math::primitives::Plane3d> = ::bevy_math::primitives::Plane3d::new( - normal.into_inner(), - half_size.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Plane3d = ::bevy_math::primitives::Plane3d::new( + safe_transmute(normal), + safe_transmute(half_size), + ); + safe_transmute(output) } }; output @@ -9002,11 +8586,10 @@ pub(crate) fn register_tetrahedron_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Tetrahedron>| { let output: Val<::bevy_math::Vec3> = { { - let output: Val<::bevy_math::Vec3> = ::bevy_math::primitives::Tetrahedron::centroid( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec3 = ::bevy_math::primitives::Tetrahedron::centroid( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9019,11 +8602,10 @@ pub(crate) fn register_tetrahedron_functions(world: &mut World) { |_self: Ref<::bevy_math::primitives::Tetrahedron>| { let output: Val<::bevy_math::primitives::Tetrahedron> = { { - let output: Val<::bevy_math::primitives::Tetrahedron> = <::bevy_math::primitives::Tetrahedron as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::primitives::Tetrahedron = <::bevy_math::primitives::Tetrahedron as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9041,9 +8623,8 @@ pub(crate) fn register_tetrahedron_functions(world: &mut World) { { let output: bool = <::bevy_math::primitives::Tetrahedron as ::core::cmp::PartialEq< ::bevy_math::primitives::Tetrahedron, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -9061,14 +8642,13 @@ pub(crate) fn register_tetrahedron_functions(world: &mut World) { { let output: Val<::bevy_math::primitives::Tetrahedron> = { { - let output: Val<::bevy_math::primitives::Tetrahedron> = ::bevy_math::primitives::Tetrahedron::new( - a.into_inner(), - b.into_inner(), - c.into_inner(), - d.into_inner(), - ) - .into(); - output + let output: ::bevy_math::primitives::Tetrahedron = ::bevy_math::primitives::Tetrahedron::new( + safe_transmute(a), + safe_transmute(b), + safe_transmute(c), + safe_transmute(d), + ); + safe_transmute(output) } }; output @@ -9082,10 +8662,9 @@ pub(crate) fn register_tetrahedron_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_math::primitives::Tetrahedron::signed_volume( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9110,11 +8689,10 @@ pub(crate) fn register_ease_function_functions(world: &mut World) { |_self: Ref<::bevy_math::curve::EaseFunction>| { let output: Val<::bevy_math::curve::EaseFunction> = { { - let output: Val<::bevy_math::curve::EaseFunction> = <::bevy_math::curve::EaseFunction as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::curve::EaseFunction = <::bevy_math::curve::EaseFunction as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9132,9 +8710,8 @@ pub(crate) fn register_ease_function_functions(world: &mut World) { { let output: bool = <::bevy_math::curve::EaseFunction as ::core::cmp::PartialEq< ::bevy_math::curve::EaseFunction, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -9160,10 +8737,9 @@ pub(crate) fn register_jump_at_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_math::curve::JumpAt as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9176,11 +8752,10 @@ pub(crate) fn register_jump_at_functions(world: &mut World) { |_self: Ref<::bevy_math::curve::JumpAt>| { let output: Val<::bevy_math::curve::JumpAt> = { { - let output: Val<::bevy_math::curve::JumpAt> = <::bevy_math::curve::JumpAt as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_math::curve::JumpAt = <::bevy_math::curve::JumpAt as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9198,9 +8773,8 @@ pub(crate) fn register_jump_at_functions(world: &mut World) { { let output: bool = <::bevy_math::curve::JumpAt as ::core::cmp::PartialEq< ::bevy_math::curve::JumpAt, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_mesh_bms_bindings/src/lib.rs b/crates/bindings/bevy_mesh_bms_bindings/src/lib.rs index f9c7d38e06..b933438e5c 100644 --- a/crates/bindings/bevy_mesh_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_mesh_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -24,11 +24,10 @@ pub(crate) fn register_morph_weights_functions(world: &mut World) { |_self: Ref<::bevy_mesh::morph::MorphWeights>| { let output: Val<::bevy_mesh::morph::MorphWeights> = { { - let output: Val<::bevy_mesh::morph::MorphWeights> = <::bevy_mesh::morph::MorphWeights as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::morph::MorphWeights = <::bevy_mesh::morph::MorphWeights as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -53,11 +52,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { |_self: Ref<::bevy_mesh::Mesh>| { let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = <::bevy_mesh::Mesh as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::Mesh = <::bevy_mesh::Mesh as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -71,10 +69,9 @@ pub(crate) fn register_mesh_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_mesh::Mesh::compute_area_weighted_normals( - &mut _self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -88,10 +85,9 @@ pub(crate) fn register_mesh_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_mesh::Mesh::compute_flat_normals( - &mut _self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -104,9 +100,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { |mut _self: Mut<::bevy_mesh::Mesh>| { let output: () = { { - let output: () = ::bevy_mesh::Mesh::compute_normals(&mut _self) - .into(); - output + let output: () = ::bevy_mesh::Mesh::compute_normals( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -120,10 +117,9 @@ pub(crate) fn register_mesh_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_mesh::Mesh::compute_smooth_normals( - &mut _self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -136,9 +132,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { |_self: Ref<::bevy_mesh::Mesh>| { let output: usize = { { - let output: usize = ::bevy_mesh::Mesh::count_vertices(&_self) - .into(); - output + let output: usize = ::bevy_mesh::Mesh::count_vertices( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -152,10 +149,9 @@ pub(crate) fn register_mesh_functions(world: &mut World) { let output: ::std::vec::Vec = { { let output: ::std::vec::Vec = ::bevy_mesh::Mesh::create_packed_vertex_buffer_data( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -169,10 +165,9 @@ pub(crate) fn register_mesh_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_mesh::Mesh::duplicate_vertices( - &mut _self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -187,9 +182,8 @@ pub(crate) fn register_mesh_functions(world: &mut World) { { let output: bool = <::bevy_mesh::Mesh as ::std::cmp::PartialEq< ::bevy_mesh::Mesh, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -203,10 +197,9 @@ pub(crate) fn register_mesh_functions(world: &mut World) { let output: usize = { { let output: usize = ::bevy_mesh::Mesh::get_vertex_buffer_size( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -219,9 +212,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { |_self: Ref<::bevy_mesh::Mesh>| { let output: u64 = { { - let output: u64 = ::bevy_mesh::Mesh::get_vertex_size(&_self) - .into(); - output + let output: u64 = ::bevy_mesh::Mesh::get_vertex_size( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -234,9 +228,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { |_self: Ref<::bevy_mesh::Mesh>| { let output: bool = { { - let output: bool = ::bevy_mesh::Mesh::has_morph_targets(&_self) - .into(); - output + let output: bool = ::bevy_mesh::Mesh::has_morph_targets( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -250,11 +245,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_mesh::Mesh::insert_indices( - &mut _self, - indices.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(indices), + ); + safe_transmute(output) } }; output @@ -268,10 +262,9 @@ pub(crate) fn register_mesh_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_mesh::Mesh::normalize_joint_weights( - &mut _self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -281,15 +274,14 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "rotate_by", - |mut _self: Mut<::bevy_mesh::Mesh>, rotation: Val<::glam::Quat>| { + |mut _self: Mut<::bevy_mesh::Mesh>, rotation: Val<::bevy_math::Quat>| { let output: () = { { let output: () = ::bevy_mesh::Mesh::rotate_by( - &mut _self, - rotation.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -299,15 +291,14 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "rotated_by", - |_self: Val<::bevy_mesh::Mesh>, rotation: Val<::glam::Quat>| { + |_self: Val<::bevy_mesh::Mesh>, rotation: Val<::bevy_math::Quat>| { let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::rotated_by( - _self.into_inner(), - rotation.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::Mesh = ::bevy_mesh::Mesh::rotated_by( + safe_transmute(_self), + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -317,15 +308,14 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "scale_by", - |mut _self: Mut<::bevy_mesh::Mesh>, scale: Val<::glam::Vec3>| { + |mut _self: Mut<::bevy_mesh::Mesh>, scale: Val<::bevy_math::Vec3>| { let output: () = { { let output: () = ::bevy_mesh::Mesh::scale_by( - &mut _self, - scale.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(scale), + ); + safe_transmute(output) } }; output @@ -335,15 +325,14 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "scaled_by", - |_self: Val<::bevy_mesh::Mesh>, scale: Val<::glam::Vec3>| { + |_self: Val<::bevy_mesh::Mesh>, scale: Val<::bevy_math::Vec3>| { let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::scaled_by( - _self.into_inner(), - scale.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::Mesh = ::bevy_mesh::Mesh::scaled_by( + safe_transmute(_self), + safe_transmute(scale), + ); + safe_transmute(output) } }; output @@ -360,11 +349,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_mesh::Mesh::set_morph_target_names( - &mut _self, - names, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(names), + ); + safe_transmute(output) } }; output @@ -381,11 +369,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_mesh::Mesh::transform_by( - &mut _self, - transform.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(transform), + ); + safe_transmute(output) } }; output @@ -401,12 +388,11 @@ pub(crate) fn register_mesh_functions(world: &mut World) { { let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::transformed_by( - _self.into_inner(), - transform.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::Mesh = ::bevy_mesh::Mesh::transformed_by( + safe_transmute(_self), + safe_transmute(transform), + ); + safe_transmute(output) } }; output @@ -416,15 +402,14 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "translate_by", - |mut _self: Mut<::bevy_mesh::Mesh>, translation: Val<::glam::Vec3>| { + |mut _self: Mut<::bevy_mesh::Mesh>, translation: Val<::bevy_math::Vec3>| { let output: () = { { let output: () = ::bevy_mesh::Mesh::translate_by( - &mut _self, - translation.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -434,15 +419,14 @@ pub(crate) fn register_mesh_functions(world: &mut World) { ) .register_documented( "translated_by", - |_self: Val<::bevy_mesh::Mesh>, translation: Val<::glam::Vec3>| { + |_self: Val<::bevy_mesh::Mesh>, translation: Val<::bevy_math::Vec3>| { let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::translated_by( - _self.into_inner(), - translation.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::Mesh = ::bevy_mesh::Mesh::translated_by( + safe_transmute(_self), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -455,11 +439,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { |_self: Val<::bevy_mesh::Mesh>| { let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::with_computed_area_weighted_normals( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::Mesh = ::bevy_mesh::Mesh::with_computed_area_weighted_normals( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -472,11 +455,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { |_self: Val<::bevy_mesh::Mesh>| { let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::with_computed_flat_normals( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::Mesh = ::bevy_mesh::Mesh::with_computed_flat_normals( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -489,11 +471,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { |_self: Val<::bevy_mesh::Mesh>| { let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::with_computed_normals( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::Mesh = ::bevy_mesh::Mesh::with_computed_normals( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -506,11 +487,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { |_self: Val<::bevy_mesh::Mesh>| { let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::with_computed_smooth_normals( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::Mesh = ::bevy_mesh::Mesh::with_computed_smooth_normals( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -523,11 +503,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { |_self: Val<::bevy_mesh::Mesh>| { let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::with_duplicated_vertices( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::Mesh = ::bevy_mesh::Mesh::with_duplicated_vertices( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -540,12 +519,11 @@ pub(crate) fn register_mesh_functions(world: &mut World) { |_self: Val<::bevy_mesh::Mesh>, indices: Val<::bevy_mesh::Indices>| { let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::with_inserted_indices( - _self.into_inner(), - indices.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::Mesh = ::bevy_mesh::Mesh::with_inserted_indices( + safe_transmute(_self), + safe_transmute(indices), + ); + safe_transmute(output) } }; output @@ -561,12 +539,11 @@ pub(crate) fn register_mesh_functions(world: &mut World) { { let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::with_morph_target_names( - _self.into_inner(), - names, - ) - .into(); - output + let output: ::bevy_mesh::Mesh = ::bevy_mesh::Mesh::with_morph_target_names( + safe_transmute(_self), + safe_transmute(names), + ); + safe_transmute(output) } }; output @@ -579,11 +556,10 @@ pub(crate) fn register_mesh_functions(world: &mut World) { |_self: Val<::bevy_mesh::Mesh>| { let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::Mesh::with_removed_indices( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::Mesh = ::bevy_mesh::Mesh::with_removed_indices( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -609,10 +585,9 @@ pub(crate) fn register_mesh_2_d_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_mesh::Mesh2d as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -625,11 +600,10 @@ pub(crate) fn register_mesh_2_d_functions(world: &mut World) { |_self: Ref<::bevy_mesh::Mesh2d>| { let output: Val<::bevy_mesh::Mesh2d> = { { - let output: Val<::bevy_mesh::Mesh2d> = <::bevy_mesh::Mesh2d as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::Mesh2d = <::bevy_mesh::Mesh2d as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -644,9 +618,8 @@ pub(crate) fn register_mesh_2_d_functions(world: &mut World) { { let output: bool = <::bevy_mesh::Mesh2d as ::std::cmp::PartialEq< ::bevy_mesh::Mesh2d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -672,10 +645,9 @@ pub(crate) fn register_mesh_3_d_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_mesh::Mesh3d as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -688,11 +660,10 @@ pub(crate) fn register_mesh_3_d_functions(world: &mut World) { |_self: Ref<::bevy_mesh::Mesh3d>| { let output: Val<::bevy_mesh::Mesh3d> = { { - let output: Val<::bevy_mesh::Mesh3d> = <::bevy_mesh::Mesh3d as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::Mesh3d = <::bevy_mesh::Mesh3d as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -707,9 +678,8 @@ pub(crate) fn register_mesh_3_d_functions(world: &mut World) { { let output: bool = <::bevy_mesh::Mesh3d as ::std::cmp::PartialEq< ::bevy_mesh::Mesh3d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -735,10 +705,9 @@ pub(crate) fn register_mesh_tag_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_mesh::MeshTag as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -751,11 +720,10 @@ pub(crate) fn register_mesh_tag_functions(world: &mut World) { |_self: Ref<::bevy_mesh::MeshTag>| { let output: Val<::bevy_mesh::MeshTag> = { { - let output: Val<::bevy_mesh::MeshTag> = <::bevy_mesh::MeshTag as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::MeshTag = <::bevy_mesh::MeshTag as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -770,9 +738,8 @@ pub(crate) fn register_mesh_tag_functions(world: &mut World) { { let output: bool = <::bevy_mesh::MeshTag as ::std::cmp::PartialEq< ::bevy_mesh::MeshTag, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -797,11 +764,10 @@ pub(crate) fn register_indices_functions(world: &mut World) { |_self: Ref<::bevy_mesh::Indices>| { let output: Val<::bevy_mesh::Indices> = { { - let output: Val<::bevy_mesh::Indices> = <::bevy_mesh::Indices as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::Indices = <::bevy_mesh::Indices as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -816,9 +782,8 @@ pub(crate) fn register_indices_functions(world: &mut World) { { let output: bool = <::bevy_mesh::Indices as ::std::cmp::PartialEq< ::bevy_mesh::Indices, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -831,8 +796,10 @@ pub(crate) fn register_indices_functions(world: &mut World) { |_self: Ref<::bevy_mesh::Indices>| { let output: bool = { { - let output: bool = ::bevy_mesh::Indices::is_empty(&_self).into(); - output + let output: bool = ::bevy_mesh::Indices::is_empty( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -845,8 +812,10 @@ pub(crate) fn register_indices_functions(world: &mut World) { |_self: Ref<::bevy_mesh::Indices>| { let output: usize = { { - let output: usize = ::bevy_mesh::Indices::len(&_self).into(); - output + let output: usize = ::bevy_mesh::Indices::len( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -859,9 +828,11 @@ pub(crate) fn register_indices_functions(world: &mut World) { |mut _self: Mut<::bevy_mesh::Indices>, index: u32| { let output: () = { { - let output: () = ::bevy_mesh::Indices::push(&mut _self, index) - .into(); - output + let output: () = ::bevy_mesh::Indices::push( + safe_transmute(_self), + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -887,10 +858,9 @@ pub(crate) fn register_mesh_morph_weights_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_mesh::morph::MeshMorphWeights::clear_weights( - &mut _self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -903,11 +873,10 @@ pub(crate) fn register_mesh_morph_weights_functions(world: &mut World) { |_self: Ref<::bevy_mesh::morph::MeshMorphWeights>| { let output: Val<::bevy_mesh::morph::MeshMorphWeights> = { { - let output: Val<::bevy_mesh::morph::MeshMorphWeights> = <::bevy_mesh::morph::MeshMorphWeights as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::morph::MeshMorphWeights = <::bevy_mesh::morph::MeshMorphWeights as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -932,11 +901,10 @@ pub(crate) fn register_circle_mesh_builder_functions(world: &mut World) { |_self: Ref<::bevy_mesh::CircleMeshBuilder>| { let output: Val<::bevy_mesh::CircleMeshBuilder> = { { - let output: Val<::bevy_mesh::CircleMeshBuilder> = <::bevy_mesh::CircleMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::CircleMeshBuilder = <::bevy_mesh::CircleMeshBuilder as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -949,12 +917,11 @@ pub(crate) fn register_circle_mesh_builder_functions(world: &mut World) { |radius: f32, resolution: u32| { let output: Val<::bevy_mesh::CircleMeshBuilder> = { { - let output: Val<::bevy_mesh::CircleMeshBuilder> = ::bevy_mesh::CircleMeshBuilder::new( - radius, - resolution, - ) - .into(); - output + let output: ::bevy_mesh::CircleMeshBuilder = ::bevy_mesh::CircleMeshBuilder::new( + safe_transmute(radius), + safe_transmute(resolution), + ); + safe_transmute(output) } }; output @@ -967,12 +934,11 @@ pub(crate) fn register_circle_mesh_builder_functions(world: &mut World) { |_self: Val<::bevy_mesh::CircleMeshBuilder>, resolution: u32| { let output: Val<::bevy_mesh::CircleMeshBuilder> = { { - let output: Val<::bevy_mesh::CircleMeshBuilder> = ::bevy_mesh::CircleMeshBuilder::resolution( - _self.into_inner(), - resolution, - ) - .into(); - output + let output: ::bevy_mesh::CircleMeshBuilder = ::bevy_mesh::CircleMeshBuilder::resolution( + safe_transmute(_self), + safe_transmute(resolution), + ); + safe_transmute(output) } }; output @@ -997,11 +963,10 @@ pub(crate) fn register_circular_mesh_uv_mode_functions(world: &mut World) { |_self: Ref<::bevy_mesh::CircularMeshUvMode>| { let output: Val<::bevy_mesh::CircularMeshUvMode> = { { - let output: Val<::bevy_mesh::CircularMeshUvMode> = <::bevy_mesh::CircularMeshUvMode as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::CircularMeshUvMode = <::bevy_mesh::CircularMeshUvMode as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1019,9 +984,8 @@ pub(crate) fn register_circular_mesh_uv_mode_functions(world: &mut World) { { let output: bool = <::bevy_mesh::CircularMeshUvMode as ::std::cmp::PartialEq< ::bevy_mesh::CircularMeshUvMode, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1046,11 +1010,10 @@ pub(crate) fn register_circular_sector_mesh_builder_functions(world: &mut World) |_self: Ref<::bevy_mesh::CircularSectorMeshBuilder>| { let output: Val<::bevy_mesh::CircularSectorMeshBuilder> = { { - let output: Val<::bevy_mesh::CircularSectorMeshBuilder> = <::bevy_mesh::CircularSectorMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::CircularSectorMeshBuilder = <::bevy_mesh::CircularSectorMeshBuilder as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1063,11 +1026,10 @@ pub(crate) fn register_circular_sector_mesh_builder_functions(world: &mut World) |sector: Val<::bevy_math::primitives::CircularSector>| { let output: Val<::bevy_mesh::CircularSectorMeshBuilder> = { { - let output: Val<::bevy_mesh::CircularSectorMeshBuilder> = ::bevy_mesh::CircularSectorMeshBuilder::new( - sector.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::CircularSectorMeshBuilder = ::bevy_mesh::CircularSectorMeshBuilder::new( + safe_transmute(sector), + ); + safe_transmute(output) } }; output @@ -1080,12 +1042,11 @@ pub(crate) fn register_circular_sector_mesh_builder_functions(world: &mut World) |_self: Val<::bevy_mesh::CircularSectorMeshBuilder>, resolution: u32| { let output: Val<::bevy_mesh::CircularSectorMeshBuilder> = { { - let output: Val<::bevy_mesh::CircularSectorMeshBuilder> = ::bevy_mesh::CircularSectorMeshBuilder::resolution( - _self.into_inner(), - resolution, - ) - .into(); - output + let output: ::bevy_mesh::CircularSectorMeshBuilder = ::bevy_mesh::CircularSectorMeshBuilder::resolution( + safe_transmute(_self), + safe_transmute(resolution), + ); + safe_transmute(output) } }; output @@ -1101,12 +1062,11 @@ pub(crate) fn register_circular_sector_mesh_builder_functions(world: &mut World) { let output: Val<::bevy_mesh::CircularSectorMeshBuilder> = { { - let output: Val<::bevy_mesh::CircularSectorMeshBuilder> = ::bevy_mesh::CircularSectorMeshBuilder::uv_mode( - _self.into_inner(), - uv_mode.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::CircularSectorMeshBuilder = ::bevy_mesh::CircularSectorMeshBuilder::uv_mode( + safe_transmute(_self), + safe_transmute(uv_mode), + ); + safe_transmute(output) } }; output @@ -1131,11 +1091,10 @@ pub(crate) fn register_circular_segment_mesh_builder_functions(world: &mut World |_self: Ref<::bevy_mesh::CircularSegmentMeshBuilder>| { let output: Val<::bevy_mesh::CircularSegmentMeshBuilder> = { { - let output: Val<::bevy_mesh::CircularSegmentMeshBuilder> = <::bevy_mesh::CircularSegmentMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::CircularSegmentMeshBuilder = <::bevy_mesh::CircularSegmentMeshBuilder as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1148,11 +1107,10 @@ pub(crate) fn register_circular_segment_mesh_builder_functions(world: &mut World |segment: Val<::bevy_math::primitives::CircularSegment>| { let output: Val<::bevy_mesh::CircularSegmentMeshBuilder> = { { - let output: Val<::bevy_mesh::CircularSegmentMeshBuilder> = ::bevy_mesh::CircularSegmentMeshBuilder::new( - segment.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::CircularSegmentMeshBuilder = ::bevy_mesh::CircularSegmentMeshBuilder::new( + safe_transmute(segment), + ); + safe_transmute(output) } }; output @@ -1165,12 +1123,11 @@ pub(crate) fn register_circular_segment_mesh_builder_functions(world: &mut World |_self: Val<::bevy_mesh::CircularSegmentMeshBuilder>, resolution: u32| { let output: Val<::bevy_mesh::CircularSegmentMeshBuilder> = { { - let output: Val<::bevy_mesh::CircularSegmentMeshBuilder> = ::bevy_mesh::CircularSegmentMeshBuilder::resolution( - _self.into_inner(), - resolution, - ) - .into(); - output + let output: ::bevy_mesh::CircularSegmentMeshBuilder = ::bevy_mesh::CircularSegmentMeshBuilder::resolution( + safe_transmute(_self), + safe_transmute(resolution), + ); + safe_transmute(output) } }; output @@ -1186,12 +1143,11 @@ pub(crate) fn register_circular_segment_mesh_builder_functions(world: &mut World { let output: Val<::bevy_mesh::CircularSegmentMeshBuilder> = { { - let output: Val<::bevy_mesh::CircularSegmentMeshBuilder> = ::bevy_mesh::CircularSegmentMeshBuilder::uv_mode( - _self.into_inner(), - uv_mode.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::CircularSegmentMeshBuilder = ::bevy_mesh::CircularSegmentMeshBuilder::uv_mode( + safe_transmute(_self), + safe_transmute(uv_mode), + ); + safe_transmute(output) } }; output @@ -1216,11 +1172,10 @@ pub(crate) fn register_convex_polygon_mesh_builder_functions(world: &mut World) |_self: Ref<::bevy_mesh::ConvexPolygonMeshBuilder>| { let output: Val<::bevy_mesh::ConvexPolygonMeshBuilder> = { { - let output: Val<::bevy_mesh::ConvexPolygonMeshBuilder> = <::bevy_mesh::ConvexPolygonMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::ConvexPolygonMeshBuilder = <::bevy_mesh::ConvexPolygonMeshBuilder as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1245,11 +1200,10 @@ pub(crate) fn register_regular_polygon_mesh_builder_functions(world: &mut World) |_self: Ref<::bevy_mesh::RegularPolygonMeshBuilder>| { let output: Val<::bevy_mesh::RegularPolygonMeshBuilder> = { { - let output: Val<::bevy_mesh::RegularPolygonMeshBuilder> = <::bevy_mesh::RegularPolygonMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::RegularPolygonMeshBuilder = <::bevy_mesh::RegularPolygonMeshBuilder as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1262,12 +1216,11 @@ pub(crate) fn register_regular_polygon_mesh_builder_functions(world: &mut World) |circumradius: f32, sides: u32| { let output: Val<::bevy_mesh::RegularPolygonMeshBuilder> = { { - let output: Val<::bevy_mesh::RegularPolygonMeshBuilder> = ::bevy_mesh::RegularPolygonMeshBuilder::new( - circumradius, - sides, - ) - .into(); - output + let output: ::bevy_mesh::RegularPolygonMeshBuilder = ::bevy_mesh::RegularPolygonMeshBuilder::new( + safe_transmute(circumradius), + safe_transmute(sides), + ); + safe_transmute(output) } }; output @@ -1292,11 +1245,10 @@ pub(crate) fn register_ellipse_mesh_builder_functions(world: &mut World) { |_self: Ref<::bevy_mesh::EllipseMeshBuilder>| { let output: Val<::bevy_mesh::EllipseMeshBuilder> = { { - let output: Val<::bevy_mesh::EllipseMeshBuilder> = <::bevy_mesh::EllipseMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::EllipseMeshBuilder = <::bevy_mesh::EllipseMeshBuilder as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1309,13 +1261,12 @@ pub(crate) fn register_ellipse_mesh_builder_functions(world: &mut World) { |half_width: f32, half_height: f32, resolution: u32| { let output: Val<::bevy_mesh::EllipseMeshBuilder> = { { - let output: Val<::bevy_mesh::EllipseMeshBuilder> = ::bevy_mesh::EllipseMeshBuilder::new( - half_width, - half_height, - resolution, - ) - .into(); - output + let output: ::bevy_mesh::EllipseMeshBuilder = ::bevy_mesh::EllipseMeshBuilder::new( + safe_transmute(half_width), + safe_transmute(half_height), + safe_transmute(resolution), + ); + safe_transmute(output) } }; output @@ -1328,12 +1279,11 @@ pub(crate) fn register_ellipse_mesh_builder_functions(world: &mut World) { |_self: Val<::bevy_mesh::EllipseMeshBuilder>, resolution: u32| { let output: Val<::bevy_mesh::EllipseMeshBuilder> = { { - let output: Val<::bevy_mesh::EllipseMeshBuilder> = ::bevy_mesh::EllipseMeshBuilder::resolution( - _self.into_inner(), - resolution, - ) - .into(); - output + let output: ::bevy_mesh::EllipseMeshBuilder = ::bevy_mesh::EllipseMeshBuilder::resolution( + safe_transmute(_self), + safe_transmute(resolution), + ); + safe_transmute(output) } }; output @@ -1358,11 +1308,10 @@ pub(crate) fn register_polyline_2_d_mesh_builder_functions(world: &mut World) { |_self: Ref<::bevy_mesh::Polyline2dMeshBuilder>| { let output: Val<::bevy_mesh::Polyline2dMeshBuilder> = { { - let output: Val<::bevy_mesh::Polyline2dMeshBuilder> = <::bevy_mesh::Polyline2dMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::Polyline2dMeshBuilder = <::bevy_mesh::Polyline2dMeshBuilder as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1387,11 +1336,10 @@ pub(crate) fn register_annulus_mesh_builder_functions(world: &mut World) { |_self: Ref<::bevy_mesh::AnnulusMeshBuilder>| { let output: Val<::bevy_mesh::AnnulusMeshBuilder> = { { - let output: Val<::bevy_mesh::AnnulusMeshBuilder> = <::bevy_mesh::AnnulusMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::AnnulusMeshBuilder = <::bevy_mesh::AnnulusMeshBuilder as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1404,13 +1352,12 @@ pub(crate) fn register_annulus_mesh_builder_functions(world: &mut World) { |inner_radius: f32, outer_radius: f32, resolution: u32| { let output: Val<::bevy_mesh::AnnulusMeshBuilder> = { { - let output: Val<::bevy_mesh::AnnulusMeshBuilder> = ::bevy_mesh::AnnulusMeshBuilder::new( - inner_radius, - outer_radius, - resolution, - ) - .into(); - output + let output: ::bevy_mesh::AnnulusMeshBuilder = ::bevy_mesh::AnnulusMeshBuilder::new( + safe_transmute(inner_radius), + safe_transmute(outer_radius), + safe_transmute(resolution), + ); + safe_transmute(output) } }; output @@ -1423,12 +1370,11 @@ pub(crate) fn register_annulus_mesh_builder_functions(world: &mut World) { |_self: Val<::bevy_mesh::AnnulusMeshBuilder>, resolution: u32| { let output: Val<::bevy_mesh::AnnulusMeshBuilder> = { { - let output: Val<::bevy_mesh::AnnulusMeshBuilder> = ::bevy_mesh::AnnulusMeshBuilder::resolution( - _self.into_inner(), - resolution, - ) - .into(); - output + let output: ::bevy_mesh::AnnulusMeshBuilder = ::bevy_mesh::AnnulusMeshBuilder::resolution( + safe_transmute(_self), + safe_transmute(resolution), + ); + safe_transmute(output) } }; output @@ -1453,11 +1399,10 @@ pub(crate) fn register_rhombus_mesh_builder_functions(world: &mut World) { |_self: Ref<::bevy_mesh::RhombusMeshBuilder>| { let output: Val<::bevy_mesh::RhombusMeshBuilder> = { { - let output: Val<::bevy_mesh::RhombusMeshBuilder> = <::bevy_mesh::RhombusMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::RhombusMeshBuilder = <::bevy_mesh::RhombusMeshBuilder as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1470,12 +1415,11 @@ pub(crate) fn register_rhombus_mesh_builder_functions(world: &mut World) { |horizontal_diagonal: f32, vertical_diagonal: f32| { let output: Val<::bevy_mesh::RhombusMeshBuilder> = { { - let output: Val<::bevy_mesh::RhombusMeshBuilder> = ::bevy_mesh::RhombusMeshBuilder::new( - horizontal_diagonal, - vertical_diagonal, - ) - .into(); - output + let output: ::bevy_mesh::RhombusMeshBuilder = ::bevy_mesh::RhombusMeshBuilder::new( + safe_transmute(horizontal_diagonal), + safe_transmute(vertical_diagonal), + ); + safe_transmute(output) } }; output @@ -1500,11 +1444,10 @@ pub(crate) fn register_triangle_2_d_mesh_builder_functions(world: &mut World) { |_self: Ref<::bevy_mesh::Triangle2dMeshBuilder>| { let output: Val<::bevy_mesh::Triangle2dMeshBuilder> = { { - let output: Val<::bevy_mesh::Triangle2dMeshBuilder> = <::bevy_mesh::Triangle2dMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::Triangle2dMeshBuilder = <::bevy_mesh::Triangle2dMeshBuilder as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1514,16 +1457,19 @@ pub(crate) fn register_triangle_2_d_mesh_builder_functions(world: &mut World) { ) .register_documented( "new", - |a: Val<::glam::Vec2>, b: Val<::glam::Vec2>, c: Val<::glam::Vec2>| { + | + a: Val<::bevy_math::Vec2>, + b: Val<::bevy_math::Vec2>, + c: Val<::bevy_math::Vec2>| + { let output: Val<::bevy_mesh::Triangle2dMeshBuilder> = { { - let output: Val<::bevy_mesh::Triangle2dMeshBuilder> = ::bevy_mesh::Triangle2dMeshBuilder::new( - a.into_inner(), - b.into_inner(), - c.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::Triangle2dMeshBuilder = ::bevy_mesh::Triangle2dMeshBuilder::new( + safe_transmute(a), + safe_transmute(b), + safe_transmute(c), + ); + safe_transmute(output) } }; output @@ -1548,11 +1494,10 @@ pub(crate) fn register_rectangle_mesh_builder_functions(world: &mut World) { |_self: Ref<::bevy_mesh::RectangleMeshBuilder>| { let output: Val<::bevy_mesh::RectangleMeshBuilder> = { { - let output: Val<::bevy_mesh::RectangleMeshBuilder> = <::bevy_mesh::RectangleMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::RectangleMeshBuilder = <::bevy_mesh::RectangleMeshBuilder as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1565,12 +1510,11 @@ pub(crate) fn register_rectangle_mesh_builder_functions(world: &mut World) { |width: f32, height: f32| { let output: Val<::bevy_mesh::RectangleMeshBuilder> = { { - let output: Val<::bevy_mesh::RectangleMeshBuilder> = ::bevy_mesh::RectangleMeshBuilder::new( - width, - height, - ) - .into(); - output + let output: ::bevy_mesh::RectangleMeshBuilder = ::bevy_mesh::RectangleMeshBuilder::new( + safe_transmute(width), + safe_transmute(height), + ); + safe_transmute(output) } }; output @@ -1595,11 +1539,10 @@ pub(crate) fn register_capsule_2_d_mesh_builder_functions(world: &mut World) { |_self: Ref<::bevy_mesh::Capsule2dMeshBuilder>| { let output: Val<::bevy_mesh::Capsule2dMeshBuilder> = { { - let output: Val<::bevy_mesh::Capsule2dMeshBuilder> = <::bevy_mesh::Capsule2dMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::Capsule2dMeshBuilder = <::bevy_mesh::Capsule2dMeshBuilder as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1612,13 +1555,12 @@ pub(crate) fn register_capsule_2_d_mesh_builder_functions(world: &mut World) { |radius: f32, length: f32, resolution: u32| { let output: Val<::bevy_mesh::Capsule2dMeshBuilder> = { { - let output: Val<::bevy_mesh::Capsule2dMeshBuilder> = ::bevy_mesh::Capsule2dMeshBuilder::new( - radius, - length, - resolution, - ) - .into(); - output + let output: ::bevy_mesh::Capsule2dMeshBuilder = ::bevy_mesh::Capsule2dMeshBuilder::new( + safe_transmute(radius), + safe_transmute(length), + safe_transmute(resolution), + ); + safe_transmute(output) } }; output @@ -1631,12 +1573,11 @@ pub(crate) fn register_capsule_2_d_mesh_builder_functions(world: &mut World) { |_self: Val<::bevy_mesh::Capsule2dMeshBuilder>, resolution: u32| { let output: Val<::bevy_mesh::Capsule2dMeshBuilder> = { { - let output: Val<::bevy_mesh::Capsule2dMeshBuilder> = ::bevy_mesh::Capsule2dMeshBuilder::resolution( - _self.into_inner(), - resolution, - ) - .into(); - output + let output: ::bevy_mesh::Capsule2dMeshBuilder = ::bevy_mesh::Capsule2dMeshBuilder::resolution( + safe_transmute(_self), + safe_transmute(resolution), + ); + safe_transmute(output) } }; output @@ -1661,11 +1602,10 @@ pub(crate) fn register_capsule_uv_profile_functions(world: &mut World) { |_self: Ref<::bevy_mesh::CapsuleUvProfile>| { let output: Val<::bevy_mesh::CapsuleUvProfile> = { { - let output: Val<::bevy_mesh::CapsuleUvProfile> = <::bevy_mesh::CapsuleUvProfile as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::CapsuleUvProfile = <::bevy_mesh::CapsuleUvProfile as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1690,11 +1630,10 @@ pub(crate) fn register_capsule_3_d_mesh_builder_functions(world: &mut World) { |_self: Ref<::bevy_mesh::Capsule3dMeshBuilder>| { let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = { { - let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = <::bevy_mesh::Capsule3dMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::Capsule3dMeshBuilder = <::bevy_mesh::Capsule3dMeshBuilder as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1707,12 +1646,11 @@ pub(crate) fn register_capsule_3_d_mesh_builder_functions(world: &mut World) { |_self: Val<::bevy_mesh::Capsule3dMeshBuilder>, latitudes: u32| { let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = { { - let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = ::bevy_mesh::Capsule3dMeshBuilder::latitudes( - _self.into_inner(), - latitudes, - ) - .into(); - output + let output: ::bevy_mesh::Capsule3dMeshBuilder = ::bevy_mesh::Capsule3dMeshBuilder::latitudes( + safe_transmute(_self), + safe_transmute(latitudes), + ); + safe_transmute(output) } }; output @@ -1725,12 +1663,11 @@ pub(crate) fn register_capsule_3_d_mesh_builder_functions(world: &mut World) { |_self: Val<::bevy_mesh::Capsule3dMeshBuilder>, longitudes: u32| { let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = { { - let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = ::bevy_mesh::Capsule3dMeshBuilder::longitudes( - _self.into_inner(), - longitudes, - ) - .into(); - output + let output: ::bevy_mesh::Capsule3dMeshBuilder = ::bevy_mesh::Capsule3dMeshBuilder::longitudes( + safe_transmute(_self), + safe_transmute(longitudes), + ); + safe_transmute(output) } }; output @@ -1743,14 +1680,13 @@ pub(crate) fn register_capsule_3_d_mesh_builder_functions(world: &mut World) { |radius: f32, height: f32, longitudes: u32, latitudes: u32| { let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = { { - let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = ::bevy_mesh::Capsule3dMeshBuilder::new( - radius, - height, - longitudes, - latitudes, - ) - .into(); - output + let output: ::bevy_mesh::Capsule3dMeshBuilder = ::bevy_mesh::Capsule3dMeshBuilder::new( + safe_transmute(radius), + safe_transmute(height), + safe_transmute(longitudes), + safe_transmute(latitudes), + ); + safe_transmute(output) } }; output @@ -1763,12 +1699,11 @@ pub(crate) fn register_capsule_3_d_mesh_builder_functions(world: &mut World) { |_self: Val<::bevy_mesh::Capsule3dMeshBuilder>, rings: u32| { let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = { { - let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = ::bevy_mesh::Capsule3dMeshBuilder::rings( - _self.into_inner(), - rings, - ) - .into(); - output + let output: ::bevy_mesh::Capsule3dMeshBuilder = ::bevy_mesh::Capsule3dMeshBuilder::rings( + safe_transmute(_self), + safe_transmute(rings), + ); + safe_transmute(output) } }; output @@ -1784,12 +1719,11 @@ pub(crate) fn register_capsule_3_d_mesh_builder_functions(world: &mut World) { { let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = { { - let output: Val<::bevy_mesh::Capsule3dMeshBuilder> = ::bevy_mesh::Capsule3dMeshBuilder::uv_profile( - _self.into_inner(), - uv_profile.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::Capsule3dMeshBuilder = ::bevy_mesh::Capsule3dMeshBuilder::uv_profile( + safe_transmute(_self), + safe_transmute(uv_profile), + ); + safe_transmute(output) } }; output @@ -1814,11 +1748,10 @@ pub(crate) fn register_cone_anchor_functions(world: &mut World) { |_self: Ref<::bevy_mesh::ConeAnchor>| { let output: Val<::bevy_mesh::ConeAnchor> = { { - let output: Val<::bevy_mesh::ConeAnchor> = <::bevy_mesh::ConeAnchor as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::ConeAnchor = <::bevy_mesh::ConeAnchor as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1846,12 +1779,11 @@ pub(crate) fn register_cone_mesh_builder_functions(world: &mut World) { { let output: Val<::bevy_mesh::ConeMeshBuilder> = { { - let output: Val<::bevy_mesh::ConeMeshBuilder> = ::bevy_mesh::ConeMeshBuilder::anchor( - _self.into_inner(), - anchor.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::ConeMeshBuilder = ::bevy_mesh::ConeMeshBuilder::anchor( + safe_transmute(_self), + safe_transmute(anchor), + ); + safe_transmute(output) } }; output @@ -1864,11 +1796,10 @@ pub(crate) fn register_cone_mesh_builder_functions(world: &mut World) { |_self: Ref<::bevy_mesh::ConeMeshBuilder>| { let output: Val<::bevy_mesh::ConeMeshBuilder> = { { - let output: Val<::bevy_mesh::ConeMeshBuilder> = <::bevy_mesh::ConeMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::ConeMeshBuilder = <::bevy_mesh::ConeMeshBuilder as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1881,13 +1812,12 @@ pub(crate) fn register_cone_mesh_builder_functions(world: &mut World) { |radius: f32, height: f32, resolution: u32| { let output: Val<::bevy_mesh::ConeMeshBuilder> = { { - let output: Val<::bevy_mesh::ConeMeshBuilder> = ::bevy_mesh::ConeMeshBuilder::new( - radius, - height, - resolution, - ) - .into(); - output + let output: ::bevy_mesh::ConeMeshBuilder = ::bevy_mesh::ConeMeshBuilder::new( + safe_transmute(radius), + safe_transmute(height), + safe_transmute(resolution), + ); + safe_transmute(output) } }; output @@ -1900,12 +1830,11 @@ pub(crate) fn register_cone_mesh_builder_functions(world: &mut World) { |_self: Val<::bevy_mesh::ConeMeshBuilder>, resolution: u32| { let output: Val<::bevy_mesh::ConeMeshBuilder> = { { - let output: Val<::bevy_mesh::ConeMeshBuilder> = ::bevy_mesh::ConeMeshBuilder::resolution( - _self.into_inner(), - resolution, - ) - .into(); - output + let output: ::bevy_mesh::ConeMeshBuilder = ::bevy_mesh::ConeMeshBuilder::resolution( + safe_transmute(_self), + safe_transmute(resolution), + ); + safe_transmute(output) } }; output @@ -1930,11 +1859,10 @@ pub(crate) fn register_conical_frustum_mesh_builder_functions(world: &mut World) |_self: Ref<::bevy_mesh::ConicalFrustumMeshBuilder>| { let output: Val<::bevy_mesh::ConicalFrustumMeshBuilder> = { { - let output: Val<::bevy_mesh::ConicalFrustumMeshBuilder> = <::bevy_mesh::ConicalFrustumMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::ConicalFrustumMeshBuilder = <::bevy_mesh::ConicalFrustumMeshBuilder as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1947,14 +1875,13 @@ pub(crate) fn register_conical_frustum_mesh_builder_functions(world: &mut World) |radius_top: f32, radius_bottom: f32, height: f32, resolution: u32| { let output: Val<::bevy_mesh::ConicalFrustumMeshBuilder> = { { - let output: Val<::bevy_mesh::ConicalFrustumMeshBuilder> = ::bevy_mesh::ConicalFrustumMeshBuilder::new( - radius_top, - radius_bottom, - height, - resolution, - ) - .into(); - output + let output: ::bevy_mesh::ConicalFrustumMeshBuilder = ::bevy_mesh::ConicalFrustumMeshBuilder::new( + safe_transmute(radius_top), + safe_transmute(radius_bottom), + safe_transmute(height), + safe_transmute(resolution), + ); + safe_transmute(output) } }; output @@ -1967,12 +1894,11 @@ pub(crate) fn register_conical_frustum_mesh_builder_functions(world: &mut World) |_self: Val<::bevy_mesh::ConicalFrustumMeshBuilder>, resolution: u32| { let output: Val<::bevy_mesh::ConicalFrustumMeshBuilder> = { { - let output: Val<::bevy_mesh::ConicalFrustumMeshBuilder> = ::bevy_mesh::ConicalFrustumMeshBuilder::resolution( - _self.into_inner(), - resolution, - ) - .into(); - output + let output: ::bevy_mesh::ConicalFrustumMeshBuilder = ::bevy_mesh::ConicalFrustumMeshBuilder::resolution( + safe_transmute(_self), + safe_transmute(resolution), + ); + safe_transmute(output) } }; output @@ -1985,12 +1911,11 @@ pub(crate) fn register_conical_frustum_mesh_builder_functions(world: &mut World) |_self: Val<::bevy_mesh::ConicalFrustumMeshBuilder>, segments: u32| { let output: Val<::bevy_mesh::ConicalFrustumMeshBuilder> = { { - let output: Val<::bevy_mesh::ConicalFrustumMeshBuilder> = ::bevy_mesh::ConicalFrustumMeshBuilder::segments( - _self.into_inner(), - segments, - ) - .into(); - output + let output: ::bevy_mesh::ConicalFrustumMeshBuilder = ::bevy_mesh::ConicalFrustumMeshBuilder::segments( + safe_transmute(_self), + safe_transmute(segments), + ); + safe_transmute(output) } }; output @@ -2015,11 +1940,10 @@ pub(crate) fn register_cuboid_mesh_builder_functions(world: &mut World) { |_self: Ref<::bevy_mesh::CuboidMeshBuilder>| { let output: Val<::bevy_mesh::CuboidMeshBuilder> = { { - let output: Val<::bevy_mesh::CuboidMeshBuilder> = <::bevy_mesh::CuboidMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::CuboidMeshBuilder = <::bevy_mesh::CuboidMeshBuilder as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2044,11 +1968,10 @@ pub(crate) fn register_cylinder_anchor_functions(world: &mut World) { |_self: Ref<::bevy_mesh::CylinderAnchor>| { let output: Val<::bevy_mesh::CylinderAnchor> = { { - let output: Val<::bevy_mesh::CylinderAnchor> = <::bevy_mesh::CylinderAnchor as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::CylinderAnchor = <::bevy_mesh::CylinderAnchor as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2076,12 +1999,11 @@ pub(crate) fn register_cylinder_mesh_builder_functions(world: &mut World) { { let output: Val<::bevy_mesh::CylinderMeshBuilder> = { { - let output: Val<::bevy_mesh::CylinderMeshBuilder> = ::bevy_mesh::CylinderMeshBuilder::anchor( - _self.into_inner(), - anchor.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::CylinderMeshBuilder = ::bevy_mesh::CylinderMeshBuilder::anchor( + safe_transmute(_self), + safe_transmute(anchor), + ); + safe_transmute(output) } }; output @@ -2094,11 +2016,10 @@ pub(crate) fn register_cylinder_mesh_builder_functions(world: &mut World) { |_self: Ref<::bevy_mesh::CylinderMeshBuilder>| { let output: Val<::bevy_mesh::CylinderMeshBuilder> = { { - let output: Val<::bevy_mesh::CylinderMeshBuilder> = <::bevy_mesh::CylinderMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::CylinderMeshBuilder = <::bevy_mesh::CylinderMeshBuilder as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2111,13 +2032,12 @@ pub(crate) fn register_cylinder_mesh_builder_functions(world: &mut World) { |radius: f32, height: f32, resolution: u32| { let output: Val<::bevy_mesh::CylinderMeshBuilder> = { { - let output: Val<::bevy_mesh::CylinderMeshBuilder> = ::bevy_mesh::CylinderMeshBuilder::new( - radius, - height, - resolution, - ) - .into(); - output + let output: ::bevy_mesh::CylinderMeshBuilder = ::bevy_mesh::CylinderMeshBuilder::new( + safe_transmute(radius), + safe_transmute(height), + safe_transmute(resolution), + ); + safe_transmute(output) } }; output @@ -2130,12 +2050,11 @@ pub(crate) fn register_cylinder_mesh_builder_functions(world: &mut World) { |_self: Val<::bevy_mesh::CylinderMeshBuilder>, resolution: u32| { let output: Val<::bevy_mesh::CylinderMeshBuilder> = { { - let output: Val<::bevy_mesh::CylinderMeshBuilder> = ::bevy_mesh::CylinderMeshBuilder::resolution( - _self.into_inner(), - resolution, - ) - .into(); - output + let output: ::bevy_mesh::CylinderMeshBuilder = ::bevy_mesh::CylinderMeshBuilder::resolution( + safe_transmute(_self), + safe_transmute(resolution), + ); + safe_transmute(output) } }; output @@ -2148,12 +2067,11 @@ pub(crate) fn register_cylinder_mesh_builder_functions(world: &mut World) { |_self: Val<::bevy_mesh::CylinderMeshBuilder>, segments: u32| { let output: Val<::bevy_mesh::CylinderMeshBuilder> = { { - let output: Val<::bevy_mesh::CylinderMeshBuilder> = ::bevy_mesh::CylinderMeshBuilder::segments( - _self.into_inner(), - segments, - ) - .into(); - output + let output: ::bevy_mesh::CylinderMeshBuilder = ::bevy_mesh::CylinderMeshBuilder::segments( + safe_transmute(_self), + safe_transmute(segments), + ); + safe_transmute(output) } }; output @@ -2166,11 +2084,10 @@ pub(crate) fn register_cylinder_mesh_builder_functions(world: &mut World) { |_self: Val<::bevy_mesh::CylinderMeshBuilder>| { let output: Val<::bevy_mesh::CylinderMeshBuilder> = { { - let output: Val<::bevy_mesh::CylinderMeshBuilder> = ::bevy_mesh::CylinderMeshBuilder::without_caps( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::CylinderMeshBuilder = ::bevy_mesh::CylinderMeshBuilder::without_caps( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2195,11 +2112,10 @@ pub(crate) fn register_plane_mesh_builder_functions(world: &mut World) { |_self: Ref<::bevy_mesh::PlaneMeshBuilder>| { let output: Val<::bevy_mesh::PlaneMeshBuilder> = { { - let output: Val<::bevy_mesh::PlaneMeshBuilder> = <::bevy_mesh::PlaneMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::PlaneMeshBuilder = <::bevy_mesh::PlaneMeshBuilder as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2212,11 +2128,10 @@ pub(crate) fn register_plane_mesh_builder_functions(world: &mut World) { |length: f32| { let output: Val<::bevy_mesh::PlaneMeshBuilder> = { { - let output: Val<::bevy_mesh::PlaneMeshBuilder> = ::bevy_mesh::PlaneMeshBuilder::from_length( - length, - ) - .into(); - output + let output: ::bevy_mesh::PlaneMeshBuilder = ::bevy_mesh::PlaneMeshBuilder::from_length( + safe_transmute(length), + ); + safe_transmute(output) } }; output @@ -2226,14 +2141,13 @@ pub(crate) fn register_plane_mesh_builder_functions(world: &mut World) { ) .register_documented( "from_size", - |size: Val<::glam::Vec2>| { + |size: Val<::bevy_math::Vec2>| { let output: Val<::bevy_mesh::PlaneMeshBuilder> = { { - let output: Val<::bevy_mesh::PlaneMeshBuilder> = ::bevy_mesh::PlaneMeshBuilder::from_size( - size.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::PlaneMeshBuilder = ::bevy_mesh::PlaneMeshBuilder::from_size( + safe_transmute(size), + ); + safe_transmute(output) } }; output @@ -2243,15 +2157,14 @@ pub(crate) fn register_plane_mesh_builder_functions(world: &mut World) { ) .register_documented( "new", - |normal: Val<::bevy_math::Dir3>, size: Val<::glam::Vec2>| { + |normal: Val<::bevy_math::Dir3>, size: Val<::bevy_math::Vec2>| { let output: Val<::bevy_mesh::PlaneMeshBuilder> = { { - let output: Val<::bevy_mesh::PlaneMeshBuilder> = ::bevy_mesh::PlaneMeshBuilder::new( - normal.into_inner(), - size.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::PlaneMeshBuilder = ::bevy_mesh::PlaneMeshBuilder::new( + safe_transmute(normal), + safe_transmute(size), + ); + safe_transmute(output) } }; output @@ -2264,12 +2177,11 @@ pub(crate) fn register_plane_mesh_builder_functions(world: &mut World) { |_self: Val<::bevy_mesh::PlaneMeshBuilder>, normal: Val<::bevy_math::Dir3>| { let output: Val<::bevy_mesh::PlaneMeshBuilder> = { { - let output: Val<::bevy_mesh::PlaneMeshBuilder> = ::bevy_mesh::PlaneMeshBuilder::normal( - _self.into_inner(), - normal.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::PlaneMeshBuilder = ::bevy_mesh::PlaneMeshBuilder::normal( + safe_transmute(_self), + safe_transmute(normal), + ); + safe_transmute(output) } }; output @@ -2282,13 +2194,12 @@ pub(crate) fn register_plane_mesh_builder_functions(world: &mut World) { |_self: Val<::bevy_mesh::PlaneMeshBuilder>, width: f32, height: f32| { let output: Val<::bevy_mesh::PlaneMeshBuilder> = { { - let output: Val<::bevy_mesh::PlaneMeshBuilder> = ::bevy_mesh::PlaneMeshBuilder::size( - _self.into_inner(), - width, - height, - ) - .into(); - output + let output: ::bevy_mesh::PlaneMeshBuilder = ::bevy_mesh::PlaneMeshBuilder::size( + safe_transmute(_self), + safe_transmute(width), + safe_transmute(height), + ); + safe_transmute(output) } }; output @@ -2301,12 +2212,11 @@ pub(crate) fn register_plane_mesh_builder_functions(world: &mut World) { |_self: Val<::bevy_mesh::PlaneMeshBuilder>, subdivisions: u32| { let output: Val<::bevy_mesh::PlaneMeshBuilder> = { { - let output: Val<::bevy_mesh::PlaneMeshBuilder> = ::bevy_mesh::PlaneMeshBuilder::subdivisions( - _self.into_inner(), - subdivisions, - ) - .into(); - output + let output: ::bevy_mesh::PlaneMeshBuilder = ::bevy_mesh::PlaneMeshBuilder::subdivisions( + safe_transmute(_self), + safe_transmute(subdivisions), + ); + safe_transmute(output) } }; output @@ -2331,11 +2241,10 @@ pub(crate) fn register_sphere_kind_functions(world: &mut World) { |_self: Ref<::bevy_mesh::SphereKind>| { let output: Val<::bevy_mesh::SphereKind> = { { - let output: Val<::bevy_mesh::SphereKind> = <::bevy_mesh::SphereKind as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::SphereKind = <::bevy_mesh::SphereKind as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2360,11 +2269,10 @@ pub(crate) fn register_sphere_mesh_builder_functions(world: &mut World) { |_self: Ref<::bevy_mesh::SphereMeshBuilder>| { let output: Val<::bevy_mesh::SphereMeshBuilder> = { { - let output: Val<::bevy_mesh::SphereMeshBuilder> = <::bevy_mesh::SphereMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::SphereMeshBuilder = <::bevy_mesh::SphereMeshBuilder as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2380,12 +2288,11 @@ pub(crate) fn register_sphere_mesh_builder_functions(world: &mut World) { { let output: Val<::bevy_mesh::SphereMeshBuilder> = { { - let output: Val<::bevy_mesh::SphereMeshBuilder> = ::bevy_mesh::SphereMeshBuilder::kind( - _self.into_inner(), - kind.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::SphereMeshBuilder = ::bevy_mesh::SphereMeshBuilder::kind( + safe_transmute(_self), + safe_transmute(kind), + ); + safe_transmute(output) } }; output @@ -2398,12 +2305,11 @@ pub(crate) fn register_sphere_mesh_builder_functions(world: &mut World) { |radius: f32, kind: Val<::bevy_mesh::SphereKind>| { let output: Val<::bevy_mesh::SphereMeshBuilder> = { { - let output: Val<::bevy_mesh::SphereMeshBuilder> = ::bevy_mesh::SphereMeshBuilder::new( - radius, - kind.into_inner(), - ) - .into(); - output + let output: ::bevy_mesh::SphereMeshBuilder = ::bevy_mesh::SphereMeshBuilder::new( + safe_transmute(radius), + safe_transmute(kind), + ); + safe_transmute(output) } }; output @@ -2416,13 +2322,12 @@ pub(crate) fn register_sphere_mesh_builder_functions(world: &mut World) { |_self: Ref<::bevy_mesh::SphereMeshBuilder>, sectors: u32, stacks: u32| { let output: Val<::bevy_mesh::Mesh> = { { - let output: Val<::bevy_mesh::Mesh> = ::bevy_mesh::SphereMeshBuilder::uv( - &_self, - sectors, - stacks, - ) - .into(); - output + let output: ::bevy_mesh::Mesh = ::bevy_mesh::SphereMeshBuilder::uv( + safe_transmute(_self), + safe_transmute(sectors), + safe_transmute(stacks), + ); + safe_transmute(output) } }; output @@ -2447,11 +2352,10 @@ pub(crate) fn register_tetrahedron_mesh_builder_functions(world: &mut World) { |_self: Ref<::bevy_mesh::TetrahedronMeshBuilder>| { let output: Val<::bevy_mesh::TetrahedronMeshBuilder> = { { - let output: Val<::bevy_mesh::TetrahedronMeshBuilder> = <::bevy_mesh::TetrahedronMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::TetrahedronMeshBuilder = <::bevy_mesh::TetrahedronMeshBuilder as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2476,11 +2380,10 @@ pub(crate) fn register_torus_mesh_builder_functions(world: &mut World) { |_self: Ref<::bevy_mesh::TorusMeshBuilder>| { let output: Val<::bevy_mesh::TorusMeshBuilder> = { { - let output: Val<::bevy_mesh::TorusMeshBuilder> = <::bevy_mesh::TorusMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::TorusMeshBuilder = <::bevy_mesh::TorusMeshBuilder as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2493,12 +2396,11 @@ pub(crate) fn register_torus_mesh_builder_functions(world: &mut World) { |_self: Val<::bevy_mesh::TorusMeshBuilder>, resolution: usize| { let output: Val<::bevy_mesh::TorusMeshBuilder> = { { - let output: Val<::bevy_mesh::TorusMeshBuilder> = ::bevy_mesh::TorusMeshBuilder::major_resolution( - _self.into_inner(), - resolution, - ) - .into(); - output + let output: ::bevy_mesh::TorusMeshBuilder = ::bevy_mesh::TorusMeshBuilder::major_resolution( + safe_transmute(_self), + safe_transmute(resolution), + ); + safe_transmute(output) } }; output @@ -2511,12 +2413,11 @@ pub(crate) fn register_torus_mesh_builder_functions(world: &mut World) { |_self: Val<::bevy_mesh::TorusMeshBuilder>, resolution: usize| { let output: Val<::bevy_mesh::TorusMeshBuilder> = { { - let output: Val<::bevy_mesh::TorusMeshBuilder> = ::bevy_mesh::TorusMeshBuilder::minor_resolution( - _self.into_inner(), - resolution, - ) - .into(); - output + let output: ::bevy_mesh::TorusMeshBuilder = ::bevy_mesh::TorusMeshBuilder::minor_resolution( + safe_transmute(_self), + safe_transmute(resolution), + ); + safe_transmute(output) } }; output @@ -2529,12 +2430,11 @@ pub(crate) fn register_torus_mesh_builder_functions(world: &mut World) { |inner_radius: f32, outer_radius: f32| { let output: Val<::bevy_mesh::TorusMeshBuilder> = { { - let output: Val<::bevy_mesh::TorusMeshBuilder> = ::bevy_mesh::TorusMeshBuilder::new( - inner_radius, - outer_radius, - ) - .into(); - output + let output: ::bevy_mesh::TorusMeshBuilder = ::bevy_mesh::TorusMeshBuilder::new( + safe_transmute(inner_radius), + safe_transmute(outer_radius), + ); + safe_transmute(output) } }; output @@ -2559,11 +2459,10 @@ pub(crate) fn register_triangle_3_d_mesh_builder_functions(world: &mut World) { |_self: Ref<::bevy_mesh::Triangle3dMeshBuilder>| { let output: Val<::bevy_mesh::Triangle3dMeshBuilder> = { { - let output: Val<::bevy_mesh::Triangle3dMeshBuilder> = <::bevy_mesh::Triangle3dMeshBuilder as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::Triangle3dMeshBuilder = <::bevy_mesh::Triangle3dMeshBuilder as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2588,11 +2487,10 @@ pub(crate) fn register_skinned_mesh_functions(world: &mut World) { |_self: Ref<::bevy_mesh::skinning::SkinnedMesh>| { let output: Val<::bevy_mesh::skinning::SkinnedMesh> = { { - let output: Val<::bevy_mesh::skinning::SkinnedMesh> = <::bevy_mesh::skinning::SkinnedMesh as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_mesh::skinning::SkinnedMesh = <::bevy_mesh::skinning::SkinnedMesh as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_pbr_bms_bindings/src/lib.rs b/crates/bindings/bevy_pbr_bms_bindings/src/lib.rs index fd19d4469a..5ad2de8d76 100644 --- a/crates/bindings/bevy_pbr_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_pbr_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -24,11 +24,10 @@ pub(crate) fn register_distance_fog_functions(world: &mut World) { |_self: Ref<::bevy_pbr::DistanceFog>| { let output: Val<::bevy_pbr::DistanceFog> = { { - let output: Val<::bevy_pbr::DistanceFog> = <::bevy_pbr::DistanceFog as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::DistanceFog = <::bevy_pbr::DistanceFog as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -53,11 +52,10 @@ pub(crate) fn register_fog_falloff_functions(world: &mut World) { |_self: Ref<::bevy_pbr::FogFalloff>| { let output: Val<::bevy_pbr::FogFalloff> = { { - let output: Val<::bevy_pbr::FogFalloff> = <::bevy_pbr::FogFalloff as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::FogFalloff = <::bevy_pbr::FogFalloff as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -70,11 +68,10 @@ pub(crate) fn register_fog_falloff_functions(world: &mut World) { |visibility: f32| { let output: Val<::bevy_pbr::FogFalloff> = { { - let output: Val<::bevy_pbr::FogFalloff> = ::bevy_pbr::FogFalloff::from_visibility( - visibility, - ) - .into(); - output + let output: ::bevy_pbr::FogFalloff = ::bevy_pbr::FogFalloff::from_visibility( + safe_transmute(visibility), + ); + safe_transmute(output) } }; output @@ -87,12 +84,11 @@ pub(crate) fn register_fog_falloff_functions(world: &mut World) { |visibility: f32, extinction_inscattering_color: Val<::bevy_color::Color>| { let output: Val<::bevy_pbr::FogFalloff> = { { - let output: Val<::bevy_pbr::FogFalloff> = ::bevy_pbr::FogFalloff::from_visibility_color( - visibility, - extinction_inscattering_color.into_inner(), - ) - .into(); - output + let output: ::bevy_pbr::FogFalloff = ::bevy_pbr::FogFalloff::from_visibility_color( + safe_transmute(visibility), + safe_transmute(extinction_inscattering_color), + ); + safe_transmute(output) } }; output @@ -109,13 +105,12 @@ pub(crate) fn register_fog_falloff_functions(world: &mut World) { { let output: Val<::bevy_pbr::FogFalloff> = { { - let output: Val<::bevy_pbr::FogFalloff> = ::bevy_pbr::FogFalloff::from_visibility_colors( - visibility, - extinction_color.into_inner(), - inscattering_color.into_inner(), - ) - .into(); - output + let output: ::bevy_pbr::FogFalloff = ::bevy_pbr::FogFalloff::from_visibility_colors( + safe_transmute(visibility), + safe_transmute(extinction_color), + safe_transmute(inscattering_color), + ); + safe_transmute(output) } }; output @@ -128,12 +123,11 @@ pub(crate) fn register_fog_falloff_functions(world: &mut World) { |visibility: f32, contrast_threshold: f32| { let output: Val<::bevy_pbr::FogFalloff> = { { - let output: Val<::bevy_pbr::FogFalloff> = ::bevy_pbr::FogFalloff::from_visibility_contrast( - visibility, - contrast_threshold, - ) - .into(); - output + let output: ::bevy_pbr::FogFalloff = ::bevy_pbr::FogFalloff::from_visibility_contrast( + safe_transmute(visibility), + safe_transmute(contrast_threshold), + ); + safe_transmute(output) } }; output @@ -150,13 +144,12 @@ pub(crate) fn register_fog_falloff_functions(world: &mut World) { { let output: Val<::bevy_pbr::FogFalloff> = { { - let output: Val<::bevy_pbr::FogFalloff> = ::bevy_pbr::FogFalloff::from_visibility_contrast_color( - visibility, - contrast_threshold, - extinction_inscattering_color.into_inner(), - ) - .into(); - output + let output: ::bevy_pbr::FogFalloff = ::bevy_pbr::FogFalloff::from_visibility_contrast_color( + safe_transmute(visibility), + safe_transmute(contrast_threshold), + safe_transmute(extinction_inscattering_color), + ); + safe_transmute(output) } }; output @@ -174,14 +167,13 @@ pub(crate) fn register_fog_falloff_functions(world: &mut World) { { let output: Val<::bevy_pbr::FogFalloff> = { { - let output: Val<::bevy_pbr::FogFalloff> = ::bevy_pbr::FogFalloff::from_visibility_contrast_colors( - visibility, - contrast_threshold, - extinction_color.into_inner(), - inscattering_color.into_inner(), - ) - .into(); - output + let output: ::bevy_pbr::FogFalloff = ::bevy_pbr::FogFalloff::from_visibility_contrast_colors( + safe_transmute(visibility), + safe_transmute(contrast_threshold), + safe_transmute(extinction_color), + safe_transmute(inscattering_color), + ); + safe_transmute(output) } }; output @@ -199,12 +191,11 @@ pub(crate) fn register_fog_falloff_functions(world: &mut World) { |visibility: f32, contrast_threshold: f32| { let output: Val<::bevy_pbr::FogFalloff> = { { - let output: Val<::bevy_pbr::FogFalloff> = ::bevy_pbr::FogFalloff::from_visibility_contrast_squared( - visibility, - contrast_threshold, - ) - .into(); - output + let output: ::bevy_pbr::FogFalloff = ::bevy_pbr::FogFalloff::from_visibility_contrast_squared( + safe_transmute(visibility), + safe_transmute(contrast_threshold), + ); + safe_transmute(output) } }; output @@ -217,11 +208,10 @@ pub(crate) fn register_fog_falloff_functions(world: &mut World) { |visibility: f32| { let output: Val<::bevy_pbr::FogFalloff> = { { - let output: Val<::bevy_pbr::FogFalloff> = ::bevy_pbr::FogFalloff::from_visibility_squared( - visibility, - ) - .into(); - output + let output: ::bevy_pbr::FogFalloff = ::bevy_pbr::FogFalloff::from_visibility_squared( + safe_transmute(visibility), + ); + safe_transmute(output) } }; output @@ -234,9 +224,11 @@ pub(crate) fn register_fog_falloff_functions(world: &mut World) { |v: f32, c_t: f32| { let output: f32 = { { - let output: f32 = ::bevy_pbr::FogFalloff::koschmieder(v, c_t) - .into(); - output + let output: f32 = ::bevy_pbr::FogFalloff::koschmieder( + safe_transmute(v), + safe_transmute(c_t), + ); + safe_transmute(output) } }; output @@ -262,10 +254,9 @@ pub(crate) fn register_parallax_mapping_method_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_pbr::ParallaxMappingMethod as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -278,11 +269,10 @@ pub(crate) fn register_parallax_mapping_method_functions(world: &mut World) { |_self: Ref<::bevy_pbr::ParallaxMappingMethod>| { let output: Val<::bevy_pbr::ParallaxMappingMethod> = { { - let output: Val<::bevy_pbr::ParallaxMappingMethod> = <::bevy_pbr::ParallaxMappingMethod as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::ParallaxMappingMethod = <::bevy_pbr::ParallaxMappingMethod as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -300,9 +290,8 @@ pub(crate) fn register_parallax_mapping_method_functions(world: &mut World) { { let output: bool = <::bevy_pbr::ParallaxMappingMethod as ::std::cmp::PartialEq< ::bevy_pbr::ParallaxMappingMethod, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -327,11 +316,10 @@ pub(crate) fn register_standard_material_functions(world: &mut World) { |_self: Ref<::bevy_pbr::StandardMaterial>| { let output: Val<::bevy_pbr::StandardMaterial> = { { - let output: Val<::bevy_pbr::StandardMaterial> = <::bevy_pbr::StandardMaterial as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::StandardMaterial = <::bevy_pbr::StandardMaterial as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -349,12 +337,11 @@ pub(crate) fn register_standard_material_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_pbr::StandardMaterial::flip( - &mut _self, - horizontal, - vertical, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(horizontal), + safe_transmute(vertical), + ); + safe_transmute(output) } }; output @@ -367,13 +354,12 @@ pub(crate) fn register_standard_material_functions(world: &mut World) { |_self: Val<::bevy_pbr::StandardMaterial>, horizontal: bool, vertical: bool| { let output: Val<::bevy_pbr::StandardMaterial> = { { - let output: Val<::bevy_pbr::StandardMaterial> = ::bevy_pbr::StandardMaterial::flipped( - _self.into_inner(), - horizontal, - vertical, - ) - .into(); - output + let output: ::bevy_pbr::StandardMaterial = ::bevy_pbr::StandardMaterial::flipped( + safe_transmute(_self), + safe_transmute(horizontal), + safe_transmute(vertical), + ); + safe_transmute(output) } }; output @@ -398,11 +384,10 @@ pub(crate) fn register_screen_space_ambient_occlusion_functions(world: &mut Worl |_self: Ref<::bevy_pbr::ScreenSpaceAmbientOcclusion>| { let output: Val<::bevy_pbr::ScreenSpaceAmbientOcclusion> = { { - let output: Val<::bevy_pbr::ScreenSpaceAmbientOcclusion> = <::bevy_pbr::ScreenSpaceAmbientOcclusion as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::ScreenSpaceAmbientOcclusion = <::bevy_pbr::ScreenSpaceAmbientOcclusion as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -420,9 +405,8 @@ pub(crate) fn register_screen_space_ambient_occlusion_functions(world: &mut Worl { let output: bool = <::bevy_pbr::ScreenSpaceAmbientOcclusion as ::std::cmp::PartialEq< ::bevy_pbr::ScreenSpaceAmbientOcclusion, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -447,11 +431,10 @@ pub(crate) fn register_screen_space_reflections_functions(world: &mut World) { |_self: Ref<::bevy_pbr::ScreenSpaceReflections>| { let output: Val<::bevy_pbr::ScreenSpaceReflections> = { { - let output: Val<::bevy_pbr::ScreenSpaceReflections> = <::bevy_pbr::ScreenSpaceReflections as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::ScreenSpaceReflections = <::bevy_pbr::ScreenSpaceReflections as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -476,11 +459,10 @@ pub(crate) fn register_default_opaque_renderer_method_functions(world: &mut Worl |_self: Ref<::bevy_pbr::DefaultOpaqueRendererMethod>| { let output: Val<::bevy_pbr::DefaultOpaqueRendererMethod> = { { - let output: Val<::bevy_pbr::DefaultOpaqueRendererMethod> = <::bevy_pbr::DefaultOpaqueRendererMethod as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::DefaultOpaqueRendererMethod = <::bevy_pbr::DefaultOpaqueRendererMethod as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -493,9 +475,8 @@ pub(crate) fn register_default_opaque_renderer_method_functions(world: &mut Worl || { let output: Val<::bevy_pbr::DefaultOpaqueRendererMethod> = { { - let output: Val<::bevy_pbr::DefaultOpaqueRendererMethod> = ::bevy_pbr::DefaultOpaqueRendererMethod::deferred() - .into(); - output + let output: ::bevy_pbr::DefaultOpaqueRendererMethod = ::bevy_pbr::DefaultOpaqueRendererMethod::deferred(); + safe_transmute(output) } }; output @@ -508,9 +489,8 @@ pub(crate) fn register_default_opaque_renderer_method_functions(world: &mut Worl || { let output: Val<::bevy_pbr::DefaultOpaqueRendererMethod> = { { - let output: Val<::bevy_pbr::DefaultOpaqueRendererMethod> = ::bevy_pbr::DefaultOpaqueRendererMethod::forward() - .into(); - output + let output: ::bevy_pbr::DefaultOpaqueRendererMethod = ::bevy_pbr::DefaultOpaqueRendererMethod::forward(); + safe_transmute(output) } }; output @@ -524,10 +504,9 @@ pub(crate) fn register_default_opaque_renderer_method_functions(world: &mut Worl let output: () = { { let output: () = ::bevy_pbr::DefaultOpaqueRendererMethod::set_to_deferred( - &mut _self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -541,10 +520,9 @@ pub(crate) fn register_default_opaque_renderer_method_functions(world: &mut Worl let output: () = { { let output: () = ::bevy_pbr::DefaultOpaqueRendererMethod::set_to_forward( - &mut _self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -569,11 +547,10 @@ pub(crate) fn register_wireframe_material_functions(world: &mut World) { |_self: Ref<::bevy_pbr::wireframe::WireframeMaterial>| { let output: Val<::bevy_pbr::wireframe::WireframeMaterial> = { { - let output: Val<::bevy_pbr::wireframe::WireframeMaterial> = <::bevy_pbr::wireframe::WireframeMaterial as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::wireframe::WireframeMaterial = <::bevy_pbr::wireframe::WireframeMaterial as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -598,11 +575,10 @@ pub(crate) fn register_wireframe_config_functions(world: &mut World) { |_self: Ref<::bevy_pbr::wireframe::WireframeConfig>| { let output: Val<::bevy_pbr::wireframe::WireframeConfig> = { { - let output: Val<::bevy_pbr::wireframe::WireframeConfig> = <::bevy_pbr::wireframe::WireframeConfig as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::wireframe::WireframeConfig = <::bevy_pbr::wireframe::WireframeConfig as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -628,10 +604,9 @@ pub(crate) fn register_wireframe_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_pbr::wireframe::Wireframe as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -644,11 +619,10 @@ pub(crate) fn register_wireframe_functions(world: &mut World) { |_self: Ref<::bevy_pbr::wireframe::Wireframe>| { let output: Val<::bevy_pbr::wireframe::Wireframe> = { { - let output: Val<::bevy_pbr::wireframe::Wireframe> = <::bevy_pbr::wireframe::Wireframe as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::wireframe::Wireframe = <::bevy_pbr::wireframe::Wireframe as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -666,9 +640,8 @@ pub(crate) fn register_wireframe_functions(world: &mut World) { { let output: bool = <::bevy_pbr::wireframe::Wireframe as ::std::cmp::PartialEq< ::bevy_pbr::wireframe::Wireframe, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -693,11 +666,10 @@ pub(crate) fn register_wireframe_color_functions(world: &mut World) { |_self: Ref<::bevy_pbr::wireframe::WireframeColor>| { let output: Val<::bevy_pbr::wireframe::WireframeColor> = { { - let output: Val<::bevy_pbr::wireframe::WireframeColor> = <::bevy_pbr::wireframe::WireframeColor as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::wireframe::WireframeColor = <::bevy_pbr::wireframe::WireframeColor as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -723,10 +695,9 @@ pub(crate) fn register_no_wireframe_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_pbr::wireframe::NoWireframe as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -739,11 +710,10 @@ pub(crate) fn register_no_wireframe_functions(world: &mut World) { |_self: Ref<::bevy_pbr::wireframe::NoWireframe>| { let output: Val<::bevy_pbr::wireframe::NoWireframe> = { { - let output: Val<::bevy_pbr::wireframe::NoWireframe> = <::bevy_pbr::wireframe::NoWireframe as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::wireframe::NoWireframe = <::bevy_pbr::wireframe::NoWireframe as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -761,9 +731,8 @@ pub(crate) fn register_no_wireframe_functions(world: &mut World) { { let output: bool = <::bevy_pbr::wireframe::NoWireframe as ::std::cmp::PartialEq< ::bevy_pbr::wireframe::NoWireframe, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -789,10 +758,9 @@ pub(crate) fn register_mesh_3_d_wireframe_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_pbr::wireframe::Mesh3dWireframe as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -805,11 +773,10 @@ pub(crate) fn register_mesh_3_d_wireframe_functions(world: &mut World) { |_self: Ref<::bevy_pbr::wireframe::Mesh3dWireframe>| { let output: Val<::bevy_pbr::wireframe::Mesh3dWireframe> = { { - let output: Val<::bevy_pbr::wireframe::Mesh3dWireframe> = <::bevy_pbr::wireframe::Mesh3dWireframe as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::wireframe::Mesh3dWireframe = <::bevy_pbr::wireframe::Mesh3dWireframe as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -827,9 +794,8 @@ pub(crate) fn register_mesh_3_d_wireframe_functions(world: &mut World) { { let output: bool = <::bevy_pbr::wireframe::Mesh3dWireframe as ::std::cmp::PartialEq< ::bevy_pbr::wireframe::Mesh3dWireframe, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -854,11 +820,10 @@ pub(crate) fn register_atmosphere_functions(world: &mut World) { |_self: Ref<::bevy_pbr::Atmosphere>| { let output: Val<::bevy_pbr::Atmosphere> = { { - let output: Val<::bevy_pbr::Atmosphere> = <::bevy_pbr::Atmosphere as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::Atmosphere = <::bevy_pbr::Atmosphere as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -871,12 +836,11 @@ pub(crate) fn register_atmosphere_functions(world: &mut World) { |_self: Val<::bevy_pbr::Atmosphere>, mult: f32| { let output: Val<::bevy_pbr::Atmosphere> = { { - let output: Val<::bevy_pbr::Atmosphere> = ::bevy_pbr::Atmosphere::with_density_multiplier( - _self.into_inner(), - mult, - ) - .into(); - output + let output: ::bevy_pbr::Atmosphere = ::bevy_pbr::Atmosphere::with_density_multiplier( + safe_transmute(_self), + safe_transmute(mult), + ); + safe_transmute(output) } }; output @@ -901,11 +865,10 @@ pub(crate) fn register_gpu_atmosphere_settings_functions(world: &mut World) { |_self: Ref<::bevy_pbr::GpuAtmosphereSettings>| { let output: Val<::bevy_pbr::GpuAtmosphereSettings> = { { - let output: Val<::bevy_pbr::GpuAtmosphereSettings> = <::bevy_pbr::GpuAtmosphereSettings as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::GpuAtmosphereSettings = <::bevy_pbr::GpuAtmosphereSettings as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -930,11 +893,10 @@ pub(crate) fn register_atmosphere_settings_functions(world: &mut World) { |_self: Ref<::bevy_pbr::AtmosphereSettings>| { let output: Val<::bevy_pbr::AtmosphereSettings> = { { - let output: Val<::bevy_pbr::AtmosphereSettings> = <::bevy_pbr::AtmosphereSettings as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::AtmosphereSettings = <::bevy_pbr::AtmosphereSettings as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -959,11 +921,10 @@ pub(crate) fn register_atmosphere_mode_functions(world: &mut World) { |_self: Ref<::bevy_pbr::AtmosphereMode>| { let output: Val<::bevy_pbr::AtmosphereMode> = { { - let output: Val<::bevy_pbr::AtmosphereMode> = <::bevy_pbr::AtmosphereMode as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::AtmosphereMode = <::bevy_pbr::AtmosphereMode as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -988,11 +949,10 @@ pub(crate) fn register_render_visible_mesh_entities_functions(world: &mut World) |_self: Ref<::bevy_pbr::RenderVisibleMeshEntities>| { let output: Val<::bevy_pbr::RenderVisibleMeshEntities> = { { - let output: Val<::bevy_pbr::RenderVisibleMeshEntities> = <::bevy_pbr::RenderVisibleMeshEntities as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::RenderVisibleMeshEntities = <::bevy_pbr::RenderVisibleMeshEntities as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1017,11 +977,10 @@ pub(crate) fn register_render_cubemap_visible_entities_functions(world: &mut Wor |_self: Ref<::bevy_pbr::RenderCubemapVisibleEntities>| { let output: Val<::bevy_pbr::RenderCubemapVisibleEntities> = { { - let output: Val<::bevy_pbr::RenderCubemapVisibleEntities> = <::bevy_pbr::RenderCubemapVisibleEntities as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::RenderCubemapVisibleEntities = <::bevy_pbr::RenderCubemapVisibleEntities as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1046,11 +1005,10 @@ pub(crate) fn register_render_cascades_visible_entities_functions(world: &mut Wo |_self: Ref<::bevy_pbr::RenderCascadesVisibleEntities>| { let output: Val<::bevy_pbr::RenderCascadesVisibleEntities> = { { - let output: Val<::bevy_pbr::RenderCascadesVisibleEntities> = <::bevy_pbr::RenderCascadesVisibleEntities as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::RenderCascadesVisibleEntities = <::bevy_pbr::RenderCascadesVisibleEntities as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1087,11 +1045,10 @@ pub(crate) fn register_opaque_renderer_method_functions(world: &mut World) { |_self: Ref<::bevy_pbr::OpaqueRendererMethod>| { let output: Val<::bevy_pbr::OpaqueRendererMethod> = { { - let output: Val<::bevy_pbr::OpaqueRendererMethod> = <::bevy_pbr::OpaqueRendererMethod as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::OpaqueRendererMethod = <::bevy_pbr::OpaqueRendererMethod as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1109,9 +1066,8 @@ pub(crate) fn register_opaque_renderer_method_functions(world: &mut World) { { let output: bool = <::bevy_pbr::OpaqueRendererMethod as ::std::cmp::PartialEq< ::bevy_pbr::OpaqueRendererMethod, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1136,11 +1092,10 @@ pub(crate) fn register_lightmap_functions(world: &mut World) { |_self: Ref<::bevy_pbr::Lightmap>| { let output: Val<::bevy_pbr::Lightmap> = { { - let output: Val<::bevy_pbr::Lightmap> = <::bevy_pbr::Lightmap as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::Lightmap = <::bevy_pbr::Lightmap as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1165,11 +1120,10 @@ pub(crate) fn register_material_binding_id_functions(world: &mut World) { |_self: Ref<::bevy_pbr::MaterialBindingId>| { let output: Val<::bevy_pbr::MaterialBindingId> = { { - let output: Val<::bevy_pbr::MaterialBindingId> = <::bevy_pbr::MaterialBindingId as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::MaterialBindingId = <::bevy_pbr::MaterialBindingId as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1194,11 +1148,10 @@ pub(crate) fn register_material_bind_group_slot_functions(world: &mut World) { |_self: Ref<::bevy_pbr::MaterialBindGroupSlot>| { let output: Val<::bevy_pbr::MaterialBindGroupSlot> = { { - let output: Val<::bevy_pbr::MaterialBindGroupSlot> = <::bevy_pbr::MaterialBindGroupSlot as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::MaterialBindGroupSlot = <::bevy_pbr::MaterialBindGroupSlot as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1216,9 +1169,8 @@ pub(crate) fn register_material_bind_group_slot_functions(world: &mut World) { { let output: bool = <::bevy_pbr::MaterialBindGroupSlot as ::std::cmp::PartialEq< ::bevy_pbr::MaterialBindGroupSlot, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1244,10 +1196,9 @@ pub(crate) fn register_material_bind_group_index_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_pbr::MaterialBindGroupIndex as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1260,11 +1211,10 @@ pub(crate) fn register_material_bind_group_index_functions(world: &mut World) { |_self: Ref<::bevy_pbr::MaterialBindGroupIndex>| { let output: Val<::bevy_pbr::MaterialBindGroupIndex> = { { - let output: Val<::bevy_pbr::MaterialBindGroupIndex> = <::bevy_pbr::MaterialBindGroupIndex as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::MaterialBindGroupIndex = <::bevy_pbr::MaterialBindGroupIndex as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1282,9 +1232,8 @@ pub(crate) fn register_material_bind_group_index_functions(world: &mut World) { { let output: bool = <::bevy_pbr::MaterialBindGroupIndex as ::std::cmp::PartialEq< ::bevy_pbr::MaterialBindGroupIndex, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1310,10 +1259,9 @@ pub(crate) fn register_uv_channel_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_pbr::UvChannel as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1326,11 +1274,10 @@ pub(crate) fn register_uv_channel_functions(world: &mut World) { |_self: Ref<::bevy_pbr::UvChannel>| { let output: Val<::bevy_pbr::UvChannel> = { { - let output: Val<::bevy_pbr::UvChannel> = <::bevy_pbr::UvChannel as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::UvChannel = <::bevy_pbr::UvChannel as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1345,9 +1292,8 @@ pub(crate) fn register_uv_channel_functions(world: &mut World) { { let output: bool = <::bevy_pbr::UvChannel as ::std::cmp::PartialEq< ::bevy_pbr::UvChannel, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1375,10 +1321,9 @@ pub(crate) fn register_screen_space_ambient_occlusion_quality_level_functions( let output: () = { { let output: () = <::bevy_pbr::ScreenSpaceAmbientOcclusionQualityLevel as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1391,13 +1336,10 @@ pub(crate) fn register_screen_space_ambient_occlusion_quality_level_functions( |_self: Ref<::bevy_pbr::ScreenSpaceAmbientOcclusionQualityLevel>| { let output: Val<::bevy_pbr::ScreenSpaceAmbientOcclusionQualityLevel> = { { - let output: Val< - ::bevy_pbr::ScreenSpaceAmbientOcclusionQualityLevel, - > = <::bevy_pbr::ScreenSpaceAmbientOcclusionQualityLevel as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_pbr::ScreenSpaceAmbientOcclusionQualityLevel = <::bevy_pbr::ScreenSpaceAmbientOcclusionQualityLevel as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1415,9 +1357,8 @@ pub(crate) fn register_screen_space_ambient_occlusion_quality_level_functions( { let output: bool = <::bevy_pbr::ScreenSpaceAmbientOcclusionQualityLevel as ::std::cmp::PartialEq< ::bevy_pbr::ScreenSpaceAmbientOcclusionQualityLevel, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_picking_bms_bindings/src/lib.rs b/crates/bindings/bevy_picking_bms_bindings/src/lib.rs index 8cbcbc17b1..e072870e9a 100644 --- a/crates/bindings/bevy_picking_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_picking_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -24,11 +24,10 @@ pub(crate) fn register_release_functions(world: &mut World) { |_self: Ref<::bevy_picking::events::Release>| { let output: Val<::bevy_picking::events::Release> = { { - let output: Val<::bevy_picking::events::Release> = <::bevy_picking::events::Release as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::events::Release = <::bevy_picking::events::Release as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -46,9 +45,8 @@ pub(crate) fn register_release_functions(world: &mut World) { { let output: bool = <::bevy_picking::events::Release as ::std::cmp::PartialEq< ::bevy_picking::events::Release, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -73,11 +71,10 @@ pub(crate) fn register_ray_cast_backfaces_functions(world: &mut World) { |_self: Ref<::bevy_picking::prelude::RayCastBackfaces>| { let output: Val<::bevy_picking::prelude::RayCastBackfaces> = { { - let output: Val<::bevy_picking::prelude::RayCastBackfaces> = <::bevy_picking::prelude::RayCastBackfaces as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::prelude::RayCastBackfaces = <::bevy_picking::prelude::RayCastBackfaces as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -102,11 +99,10 @@ pub(crate) fn register_ray_cast_visibility_functions(world: &mut World) { |_self: Ref<::bevy_picking::prelude::RayCastVisibility>| { let output: Val<::bevy_picking::prelude::RayCastVisibility> = { { - let output: Val<::bevy_picking::prelude::RayCastVisibility> = <::bevy_picking::prelude::RayCastVisibility as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::prelude::RayCastVisibility = <::bevy_picking::prelude::RayCastVisibility as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -131,13 +127,10 @@ pub(crate) fn register_mesh_picking_camera_functions(world: &mut World) { |_self: Ref<::bevy_picking::mesh_picking::MeshPickingCamera>| { let output: Val<::bevy_picking::mesh_picking::MeshPickingCamera> = { { - let output: Val< - ::bevy_picking::mesh_picking::MeshPickingCamera, - > = <::bevy_picking::mesh_picking::MeshPickingCamera as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::mesh_picking::MeshPickingCamera = <::bevy_picking::mesh_picking::MeshPickingCamera as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -175,10 +168,9 @@ pub(crate) fn register_pointer_button_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_picking::pointer::PointerButton as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -191,11 +183,10 @@ pub(crate) fn register_pointer_button_functions(world: &mut World) { |_self: Ref<::bevy_picking::pointer::PointerButton>| { let output: Val<::bevy_picking::pointer::PointerButton> = { { - let output: Val<::bevy_picking::pointer::PointerButton> = <::bevy_picking::pointer::PointerButton as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::pointer::PointerButton = <::bevy_picking::pointer::PointerButton as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -213,9 +204,8 @@ pub(crate) fn register_pointer_button_functions(world: &mut World) { { let output: bool = <::bevy_picking::pointer::PointerButton as ::std::cmp::PartialEq< ::bevy_picking::pointer::PointerButton, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -241,10 +231,9 @@ pub(crate) fn register_pickable_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_picking::Pickable as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -257,11 +246,10 @@ pub(crate) fn register_pickable_functions(world: &mut World) { |_self: Ref<::bevy_picking::Pickable>| { let output: Val<::bevy_picking::Pickable> = { { - let output: Val<::bevy_picking::Pickable> = <::bevy_picking::Pickable as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::Pickable = <::bevy_picking::Pickable as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -276,9 +264,8 @@ pub(crate) fn register_pickable_functions(world: &mut World) { { let output: bool = <::bevy_picking::Pickable as ::std::cmp::PartialEq< ::bevy_picking::Pickable, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -303,11 +290,10 @@ pub(crate) fn register_picking_settings_functions(world: &mut World) { |_self: Ref<::bevy_picking::PickingSettings>| { let output: Val<::bevy_picking::PickingSettings> = { { - let output: Val<::bevy_picking::PickingSettings> = <::bevy_picking::PickingSettings as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::PickingSettings = <::bevy_picking::PickingSettings as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -336,11 +322,10 @@ pub(crate) fn register_pointer_input_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_picking::pointer::PointerInput::button_just_pressed( - &_self, - target_button.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(target_button), + ); + safe_transmute(output) } }; output @@ -357,11 +342,10 @@ pub(crate) fn register_pointer_input_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_picking::pointer::PointerInput::button_just_released( - &_self, - target_button.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(target_button), + ); + safe_transmute(output) } }; output @@ -374,11 +358,10 @@ pub(crate) fn register_pointer_input_functions(world: &mut World) { |_self: Ref<::bevy_picking::pointer::PointerInput>| { let output: Val<::bevy_picking::pointer::PointerInput> = { { - let output: Val<::bevy_picking::pointer::PointerInput> = <::bevy_picking::pointer::PointerInput as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::pointer::PointerInput = <::bevy_picking::pointer::PointerInput as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -395,13 +378,12 @@ pub(crate) fn register_pointer_input_functions(world: &mut World) { { let output: Val<::bevy_picking::pointer::PointerInput> = { { - let output: Val<::bevy_picking::pointer::PointerInput> = ::bevy_picking::pointer::PointerInput::new( - pointer_id.into_inner(), - location.into_inner(), - action.into_inner(), - ) - .into(); - output + let output: ::bevy_picking::pointer::PointerInput = ::bevy_picking::pointer::PointerInput::new( + safe_transmute(pointer_id), + safe_transmute(location), + safe_transmute(action), + ); + safe_transmute(output) } }; output @@ -426,11 +408,10 @@ pub(crate) fn register_pointer_hits_functions(world: &mut World) { |_self: Ref<::bevy_picking::backend::PointerHits>| { let output: Val<::bevy_picking::backend::PointerHits> = { { - let output: Val<::bevy_picking::backend::PointerHits> = <::bevy_picking::backend::PointerHits as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::backend::PointerHits = <::bevy_picking::backend::PointerHits as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -455,11 +436,10 @@ pub(crate) fn register_cancel_functions(world: &mut World) { |_self: Ref<::bevy_picking::events::Cancel>| { let output: Val<::bevy_picking::events::Cancel> = { { - let output: Val<::bevy_picking::events::Cancel> = <::bevy_picking::events::Cancel as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::events::Cancel = <::bevy_picking::events::Cancel as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -477,9 +457,8 @@ pub(crate) fn register_cancel_functions(world: &mut World) { { let output: bool = <::bevy_picking::events::Cancel as ::std::cmp::PartialEq< ::bevy_picking::events::Cancel, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -504,11 +483,10 @@ pub(crate) fn register_click_functions(world: &mut World) { |_self: Ref<::bevy_picking::events::Click>| { let output: Val<::bevy_picking::events::Click> = { { - let output: Val<::bevy_picking::events::Click> = <::bevy_picking::events::Click as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::events::Click = <::bevy_picking::events::Click as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -526,9 +504,8 @@ pub(crate) fn register_click_functions(world: &mut World) { { let output: bool = <::bevy_picking::events::Click as ::std::cmp::PartialEq< ::bevy_picking::events::Click, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -553,11 +530,10 @@ pub(crate) fn register_press_functions(world: &mut World) { |_self: Ref<::bevy_picking::events::Press>| { let output: Val<::bevy_picking::events::Press> = { { - let output: Val<::bevy_picking::events::Press> = <::bevy_picking::events::Press as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::events::Press = <::bevy_picking::events::Press as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -575,9 +551,8 @@ pub(crate) fn register_press_functions(world: &mut World) { { let output: bool = <::bevy_picking::events::Press as ::std::cmp::PartialEq< ::bevy_picking::events::Press, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -602,11 +577,10 @@ pub(crate) fn register_drag_drop_functions(world: &mut World) { |_self: Ref<::bevy_picking::events::DragDrop>| { let output: Val<::bevy_picking::events::DragDrop> = { { - let output: Val<::bevy_picking::events::DragDrop> = <::bevy_picking::events::DragDrop as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::events::DragDrop = <::bevy_picking::events::DragDrop as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -624,9 +598,8 @@ pub(crate) fn register_drag_drop_functions(world: &mut World) { { let output: bool = <::bevy_picking::events::DragDrop as ::std::cmp::PartialEq< ::bevy_picking::events::DragDrop, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -651,11 +624,10 @@ pub(crate) fn register_drag_end_functions(world: &mut World) { |_self: Ref<::bevy_picking::events::DragEnd>| { let output: Val<::bevy_picking::events::DragEnd> = { { - let output: Val<::bevy_picking::events::DragEnd> = <::bevy_picking::events::DragEnd as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::events::DragEnd = <::bevy_picking::events::DragEnd as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -673,9 +645,8 @@ pub(crate) fn register_drag_end_functions(world: &mut World) { { let output: bool = <::bevy_picking::events::DragEnd as ::std::cmp::PartialEq< ::bevy_picking::events::DragEnd, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -700,11 +671,10 @@ pub(crate) fn register_drag_enter_functions(world: &mut World) { |_self: Ref<::bevy_picking::events::DragEnter>| { let output: Val<::bevy_picking::events::DragEnter> = { { - let output: Val<::bevy_picking::events::DragEnter> = <::bevy_picking::events::DragEnter as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::events::DragEnter = <::bevy_picking::events::DragEnter as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -722,9 +692,8 @@ pub(crate) fn register_drag_enter_functions(world: &mut World) { { let output: bool = <::bevy_picking::events::DragEnter as ::std::cmp::PartialEq< ::bevy_picking::events::DragEnter, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -749,11 +718,10 @@ pub(crate) fn register_drag_functions(world: &mut World) { |_self: Ref<::bevy_picking::events::Drag>| { let output: Val<::bevy_picking::events::Drag> = { { - let output: Val<::bevy_picking::events::Drag> = <::bevy_picking::events::Drag as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::events::Drag = <::bevy_picking::events::Drag as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -771,9 +739,8 @@ pub(crate) fn register_drag_functions(world: &mut World) { { let output: bool = <::bevy_picking::events::Drag as ::std::cmp::PartialEq< ::bevy_picking::events::Drag, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -798,11 +765,10 @@ pub(crate) fn register_drag_leave_functions(world: &mut World) { |_self: Ref<::bevy_picking::events::DragLeave>| { let output: Val<::bevy_picking::events::DragLeave> = { { - let output: Val<::bevy_picking::events::DragLeave> = <::bevy_picking::events::DragLeave as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::events::DragLeave = <::bevy_picking::events::DragLeave as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -820,9 +786,8 @@ pub(crate) fn register_drag_leave_functions(world: &mut World) { { let output: bool = <::bevy_picking::events::DragLeave as ::std::cmp::PartialEq< ::bevy_picking::events::DragLeave, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -847,11 +812,10 @@ pub(crate) fn register_drag_over_functions(world: &mut World) { |_self: Ref<::bevy_picking::events::DragOver>| { let output: Val<::bevy_picking::events::DragOver> = { { - let output: Val<::bevy_picking::events::DragOver> = <::bevy_picking::events::DragOver as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::events::DragOver = <::bevy_picking::events::DragOver as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -869,9 +833,8 @@ pub(crate) fn register_drag_over_functions(world: &mut World) { { let output: bool = <::bevy_picking::events::DragOver as ::std::cmp::PartialEq< ::bevy_picking::events::DragOver, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -896,11 +859,10 @@ pub(crate) fn register_drag_start_functions(world: &mut World) { |_self: Ref<::bevy_picking::events::DragStart>| { let output: Val<::bevy_picking::events::DragStart> = { { - let output: Val<::bevy_picking::events::DragStart> = <::bevy_picking::events::DragStart as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::events::DragStart = <::bevy_picking::events::DragStart as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -918,9 +880,8 @@ pub(crate) fn register_drag_start_functions(world: &mut World) { { let output: bool = <::bevy_picking::events::DragStart as ::std::cmp::PartialEq< ::bevy_picking::events::DragStart, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -945,11 +906,10 @@ pub(crate) fn register_move_functions(world: &mut World) { |_self: Ref<::bevy_picking::events::Move>| { let output: Val<::bevy_picking::events::Move> = { { - let output: Val<::bevy_picking::events::Move> = <::bevy_picking::events::Move as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::events::Move = <::bevy_picking::events::Move as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -967,9 +927,8 @@ pub(crate) fn register_move_functions(world: &mut World) { { let output: bool = <::bevy_picking::events::Move as ::std::cmp::PartialEq< ::bevy_picking::events::Move, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -994,11 +953,10 @@ pub(crate) fn register_out_functions(world: &mut World) { |_self: Ref<::bevy_picking::events::Out>| { let output: Val<::bevy_picking::events::Out> = { { - let output: Val<::bevy_picking::events::Out> = <::bevy_picking::events::Out as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::events::Out = <::bevy_picking::events::Out as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1016,9 +974,8 @@ pub(crate) fn register_out_functions(world: &mut World) { { let output: bool = <::bevy_picking::events::Out as ::std::cmp::PartialEq< ::bevy_picking::events::Out, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1043,11 +1000,10 @@ pub(crate) fn register_over_functions(world: &mut World) { |_self: Ref<::bevy_picking::events::Over>| { let output: Val<::bevy_picking::events::Over> = { { - let output: Val<::bevy_picking::events::Over> = <::bevy_picking::events::Over as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::events::Over = <::bevy_picking::events::Over as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1065,9 +1021,8 @@ pub(crate) fn register_over_functions(world: &mut World) { { let output: bool = <::bevy_picking::events::Over as ::std::cmp::PartialEq< ::bevy_picking::events::Over, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1092,11 +1047,10 @@ pub(crate) fn register_scroll_functions(world: &mut World) { |_self: Ref<::bevy_picking::events::Scroll>| { let output: Val<::bevy_picking::events::Scroll> = { { - let output: Val<::bevy_picking::events::Scroll> = <::bevy_picking::events::Scroll as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::events::Scroll = <::bevy_picking::events::Scroll as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1114,9 +1068,8 @@ pub(crate) fn register_scroll_functions(world: &mut World) { { let output: bool = <::bevy_picking::events::Scroll as ::std::cmp::PartialEq< ::bevy_picking::events::Scroll, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1141,11 +1094,10 @@ pub(crate) fn register_hit_data_functions(world: &mut World) { |_self: Ref<::bevy_picking::backend::HitData>| { let output: Val<::bevy_picking::backend::HitData> = { { - let output: Val<::bevy_picking::backend::HitData> = <::bevy_picking::backend::HitData as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::backend::HitData = <::bevy_picking::backend::HitData as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1163,9 +1115,8 @@ pub(crate) fn register_hit_data_functions(world: &mut World) { { let output: bool = <::bevy_picking::backend::HitData as ::std::cmp::PartialEq< ::bevy_picking::backend::HitData, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1191,10 +1142,9 @@ pub(crate) fn register_pointer_id_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_picking::pointer::PointerId as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1207,11 +1157,10 @@ pub(crate) fn register_pointer_id_functions(world: &mut World) { |_self: Ref<::bevy_picking::pointer::PointerId>| { let output: Val<::bevy_picking::pointer::PointerId> = { { - let output: Val<::bevy_picking::pointer::PointerId> = <::bevy_picking::pointer::PointerId as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::pointer::PointerId = <::bevy_picking::pointer::PointerId as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1229,9 +1178,8 @@ pub(crate) fn register_pointer_id_functions(world: &mut World) { { let output: bool = <::bevy_picking::pointer::PointerId as ::std::cmp::PartialEq< ::bevy_picking::pointer::PointerId, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1245,10 +1193,9 @@ pub(crate) fn register_pointer_id_functions(world: &mut World) { let output: ::std::option::Option = { { let output: ::std::option::Option = ::bevy_picking::pointer::PointerId::get_touch_id( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1262,10 +1209,9 @@ pub(crate) fn register_pointer_id_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_picking::pointer::PointerId::is_custom( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1279,10 +1225,9 @@ pub(crate) fn register_pointer_id_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_picking::pointer::PointerId::is_mouse( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1296,10 +1241,9 @@ pub(crate) fn register_pointer_id_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_picking::pointer::PointerId::is_touch( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1324,11 +1268,10 @@ pub(crate) fn register_pointer_location_functions(world: &mut World) { |_self: Ref<::bevy_picking::pointer::PointerLocation>| { let output: Val<::bevy_picking::pointer::PointerLocation> = { { - let output: Val<::bevy_picking::pointer::PointerLocation> = <::bevy_picking::pointer::PointerLocation as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::pointer::PointerLocation = <::bevy_picking::pointer::PointerLocation as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1346,9 +1289,8 @@ pub(crate) fn register_pointer_location_functions(world: &mut World) { { let output: bool = <::bevy_picking::pointer::PointerLocation as ::std::cmp::PartialEq< ::bevy_picking::pointer::PointerLocation, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1361,11 +1303,10 @@ pub(crate) fn register_pointer_location_functions(world: &mut World) { |location: Val<::bevy_picking::pointer::Location>| { let output: Val<::bevy_picking::pointer::PointerLocation> = { { - let output: Val<::bevy_picking::pointer::PointerLocation> = ::bevy_picking::pointer::PointerLocation::new( - location.into_inner(), - ) - .into(); - output + let output: ::bevy_picking::pointer::PointerLocation = ::bevy_picking::pointer::PointerLocation::new( + safe_transmute(location), + ); + safe_transmute(output) } }; output @@ -1391,10 +1332,9 @@ pub(crate) fn register_ray_id_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_picking::backend::ray::RayId as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1407,11 +1347,10 @@ pub(crate) fn register_ray_id_functions(world: &mut World) { |_self: Ref<::bevy_picking::backend::ray::RayId>| { let output: Val<::bevy_picking::backend::ray::RayId> = { { - let output: Val<::bevy_picking::backend::ray::RayId> = <::bevy_picking::backend::ray::RayId as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::backend::ray::RayId = <::bevy_picking::backend::ray::RayId as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1429,9 +1368,8 @@ pub(crate) fn register_ray_id_functions(world: &mut World) { { let output: bool = <::bevy_picking::backend::ray::RayId as ::std::cmp::PartialEq< ::bevy_picking::backend::ray::RayId, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1447,12 +1385,11 @@ pub(crate) fn register_ray_id_functions(world: &mut World) { { let output: Val<::bevy_picking::backend::ray::RayId> = { { - let output: Val<::bevy_picking::backend::ray::RayId> = ::bevy_picking::backend::ray::RayId::new( - camera.into_inner(), - pointer.into_inner(), - ) - .into(); - output + let output: ::bevy_picking::backend::ray::RayId = ::bevy_picking::backend::ray::RayId::new( + safe_transmute(camera), + safe_transmute(pointer), + ); + safe_transmute(output) } }; output @@ -1477,11 +1414,10 @@ pub(crate) fn register_location_functions(world: &mut World) { |_self: Ref<::bevy_picking::pointer::Location>| { let output: Val<::bevy_picking::pointer::Location> = { { - let output: Val<::bevy_picking::pointer::Location> = <::bevy_picking::pointer::Location as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::pointer::Location = <::bevy_picking::pointer::Location as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1499,9 +1435,8 @@ pub(crate) fn register_location_functions(world: &mut World) { { let output: bool = <::bevy_picking::pointer::Location as ::std::cmp::PartialEq< ::bevy_picking::pointer::Location, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1526,11 +1461,10 @@ pub(crate) fn register_pointer_action_functions(world: &mut World) { |_self: Ref<::bevy_picking::pointer::PointerAction>| { let output: Val<::bevy_picking::pointer::PointerAction> = { { - let output: Val<::bevy_picking::pointer::PointerAction> = <::bevy_picking::pointer::PointerAction as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::pointer::PointerAction = <::bevy_picking::pointer::PointerAction as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1555,11 +1489,10 @@ pub(crate) fn register_drag_entry_functions(world: &mut World) { |_self: Ref<::bevy_picking::events::DragEntry>| { let output: Val<::bevy_picking::events::DragEntry> = { { - let output: Val<::bevy_picking::events::DragEntry> = <::bevy_picking::events::DragEntry as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::events::DragEntry = <::bevy_picking::events::DragEntry as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1577,9 +1510,8 @@ pub(crate) fn register_drag_entry_functions(world: &mut World) { { let output: bool = <::bevy_picking::events::DragEntry as ::std::cmp::PartialEq< ::bevy_picking::events::DragEntry, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1604,11 +1536,10 @@ pub(crate) fn register_pointer_interaction_functions(world: &mut World) { |_self: Ref<::bevy_picking::pointer::PointerInteraction>| { let output: Val<::bevy_picking::pointer::PointerInteraction> = { { - let output: Val<::bevy_picking::pointer::PointerInteraction> = <::bevy_picking::pointer::PointerInteraction as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::pointer::PointerInteraction = <::bevy_picking::pointer::PointerInteraction as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1634,10 +1565,9 @@ pub(crate) fn register_pointer_press_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_picking::pointer::PointerPress as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1650,11 +1580,10 @@ pub(crate) fn register_pointer_press_functions(world: &mut World) { |_self: Ref<::bevy_picking::pointer::PointerPress>| { let output: Val<::bevy_picking::pointer::PointerPress> = { { - let output: Val<::bevy_picking::pointer::PointerPress> = <::bevy_picking::pointer::PointerPress as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::pointer::PointerPress = <::bevy_picking::pointer::PointerPress as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1672,9 +1601,8 @@ pub(crate) fn register_pointer_press_functions(world: &mut World) { { let output: bool = <::bevy_picking::pointer::PointerPress as ::std::cmp::PartialEq< ::bevy_picking::pointer::PointerPress, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1688,10 +1616,9 @@ pub(crate) fn register_pointer_press_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_picking::pointer::PointerPress::is_any_pressed( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1705,10 +1632,9 @@ pub(crate) fn register_pointer_press_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_picking::pointer::PointerPress::is_middle_pressed( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1722,10 +1648,9 @@ pub(crate) fn register_pointer_press_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_picking::pointer::PointerPress::is_primary_pressed( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1739,10 +1664,9 @@ pub(crate) fn register_pointer_press_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_picking::pointer::PointerPress::is_secondary_pressed( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1768,10 +1692,9 @@ pub(crate) fn register_picking_interaction_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_picking::hover::PickingInteraction as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1784,11 +1707,10 @@ pub(crate) fn register_picking_interaction_functions(world: &mut World) { |_self: Ref<::bevy_picking::hover::PickingInteraction>| { let output: Val<::bevy_picking::hover::PickingInteraction> = { { - let output: Val<::bevy_picking::hover::PickingInteraction> = <::bevy_picking::hover::PickingInteraction as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::hover::PickingInteraction = <::bevy_picking::hover::PickingInteraction as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1806,9 +1728,8 @@ pub(crate) fn register_picking_interaction_functions(world: &mut World) { { let output: bool = <::bevy_picking::hover::PickingInteraction as ::std::cmp::PartialEq< ::bevy_picking::hover::PickingInteraction, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1834,10 +1755,9 @@ pub(crate) fn register_hovered_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_picking::hover::Hovered as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1850,11 +1770,10 @@ pub(crate) fn register_hovered_functions(world: &mut World) { |_self: Ref<::bevy_picking::hover::Hovered>| { let output: Val<::bevy_picking::hover::Hovered> = { { - let output: Val<::bevy_picking::hover::Hovered> = <::bevy_picking::hover::Hovered as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::hover::Hovered = <::bevy_picking::hover::Hovered as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1872,9 +1791,8 @@ pub(crate) fn register_hovered_functions(world: &mut World) { { let output: bool = <::bevy_picking::hover::Hovered as ::std::cmp::PartialEq< ::bevy_picking::hover::Hovered, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1887,9 +1805,10 @@ pub(crate) fn register_hovered_functions(world: &mut World) { |_self: Ref<::bevy_picking::hover::Hovered>| { let output: bool = { { - let output: bool = ::bevy_picking::hover::Hovered::get(&_self) - .into(); - output + let output: bool = ::bevy_picking::hover::Hovered::get( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1915,10 +1834,9 @@ pub(crate) fn register_directly_hovered_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_picking::hover::DirectlyHovered as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1931,11 +1849,10 @@ pub(crate) fn register_directly_hovered_functions(world: &mut World) { |_self: Ref<::bevy_picking::hover::DirectlyHovered>| { let output: Val<::bevy_picking::hover::DirectlyHovered> = { { - let output: Val<::bevy_picking::hover::DirectlyHovered> = <::bevy_picking::hover::DirectlyHovered as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::hover::DirectlyHovered = <::bevy_picking::hover::DirectlyHovered as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1953,9 +1870,8 @@ pub(crate) fn register_directly_hovered_functions(world: &mut World) { { let output: bool = <::bevy_picking::hover::DirectlyHovered as ::std::cmp::PartialEq< ::bevy_picking::hover::DirectlyHovered, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1969,10 +1885,9 @@ pub(crate) fn register_directly_hovered_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_picking::hover::DirectlyHovered::get( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1997,11 +1912,10 @@ pub(crate) fn register_pointer_input_settings_functions(world: &mut World) { |_self: Ref<::bevy_picking::input::PointerInputSettings>| { let output: Val<::bevy_picking::input::PointerInputSettings> = { { - let output: Val<::bevy_picking::input::PointerInputSettings> = <::bevy_picking::input::PointerInputSettings as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::input::PointerInputSettings = <::bevy_picking::input::PointerInputSettings as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2026,13 +1940,10 @@ pub(crate) fn register_ray_mesh_hit_functions(world: &mut World) { |_self: Ref<::bevy_picking::mesh_picking::ray_cast::RayMeshHit>| { let output: Val<::bevy_picking::mesh_picking::ray_cast::RayMeshHit> = { { - let output: Val< - ::bevy_picking::mesh_picking::ray_cast::RayMeshHit, - > = <::bevy_picking::mesh_picking::ray_cast::RayMeshHit as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::mesh_picking::ray_cast::RayMeshHit = <::bevy_picking::mesh_picking::ray_cast::RayMeshHit as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2057,13 +1968,10 @@ pub(crate) fn register_backfaces_functions(world: &mut World) { |_self: Ref<::bevy_picking::mesh_picking::ray_cast::Backfaces>| { let output: Val<::bevy_picking::mesh_picking::ray_cast::Backfaces> = { { - let output: Val< - ::bevy_picking::mesh_picking::ray_cast::Backfaces, - > = <::bevy_picking::mesh_picking::ray_cast::Backfaces as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::mesh_picking::ray_cast::Backfaces = <::bevy_picking::mesh_picking::ray_cast::Backfaces as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2090,13 +1998,10 @@ pub(crate) fn register_simplified_mesh_functions(world: &mut World) { ::bevy_picking::mesh_picking::ray_cast::SimplifiedMesh, > = { { - let output: Val< - ::bevy_picking::mesh_picking::ray_cast::SimplifiedMesh, - > = <::bevy_picking::mesh_picking::ray_cast::SimplifiedMesh as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::mesh_picking::ray_cast::SimplifiedMesh = <::bevy_picking::mesh_picking::ray_cast::SimplifiedMesh as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2122,10 +2027,9 @@ pub(crate) fn register_press_direction_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_picking::pointer::PressDirection as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2138,11 +2042,10 @@ pub(crate) fn register_press_direction_functions(world: &mut World) { |_self: Ref<::bevy_picking::pointer::PressDirection>| { let output: Val<::bevy_picking::pointer::PressDirection> = { { - let output: Val<::bevy_picking::pointer::PressDirection> = <::bevy_picking::pointer::PressDirection as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_picking::pointer::PressDirection = <::bevy_picking::pointer::PressDirection as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2160,9 +2063,8 @@ pub(crate) fn register_press_direction_functions(world: &mut World) { { let output: bool = <::bevy_picking::pointer::PressDirection as ::std::cmp::PartialEq< ::bevy_picking::pointer::PressDirection, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_post_process_bms_bindings/src/lib.rs b/crates/bindings/bevy_post_process_bms_bindings/src/lib.rs index 676f86d74b..c235d90f02 100644 --- a/crates/bindings/bevy_post_process_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_post_process_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -30,13 +30,10 @@ pub(crate) fn register_auto_exposure_compensation_curve_functions(world: &mut Wo ::bevy_post_process::auto_exposure::AutoExposureCompensationCurve, > = { { - let output: Val< - ::bevy_post_process::auto_exposure::AutoExposureCompensationCurve, - > = <::bevy_post_process::auto_exposure::AutoExposureCompensationCurve as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_post_process::auto_exposure::AutoExposureCompensationCurve = <::bevy_post_process::auto_exposure::AutoExposureCompensationCurve as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -61,13 +58,10 @@ pub(crate) fn register_auto_exposure_functions(world: &mut World) { |_self: Ref<::bevy_post_process::auto_exposure::AutoExposure>| { let output: Val<::bevy_post_process::auto_exposure::AutoExposure> = { { - let output: Val< - ::bevy_post_process::auto_exposure::AutoExposure, - > = <::bevy_post_process::auto_exposure::AutoExposure as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_post_process::auto_exposure::AutoExposure = <::bevy_post_process::auto_exposure::AutoExposure as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -92,11 +86,10 @@ pub(crate) fn register_bloom_functions(world: &mut World) { |_self: Ref<::bevy_post_process::bloom::Bloom>| { let output: Val<::bevy_post_process::bloom::Bloom> = { { - let output: Val<::bevy_post_process::bloom::Bloom> = <::bevy_post_process::bloom::Bloom as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_post_process::bloom::Bloom = <::bevy_post_process::bloom::Bloom as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -122,10 +115,9 @@ pub(crate) fn register_bloom_composite_mode_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_post_process::bloom::BloomCompositeMode as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -138,13 +130,10 @@ pub(crate) fn register_bloom_composite_mode_functions(world: &mut World) { |_self: Ref<::bevy_post_process::bloom::BloomCompositeMode>| { let output: Val<::bevy_post_process::bloom::BloomCompositeMode> = { { - let output: Val< - ::bevy_post_process::bloom::BloomCompositeMode, - > = <::bevy_post_process::bloom::BloomCompositeMode as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_post_process::bloom::BloomCompositeMode = <::bevy_post_process::bloom::BloomCompositeMode as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -162,9 +151,8 @@ pub(crate) fn register_bloom_composite_mode_functions(world: &mut World) { { let output: bool = <::bevy_post_process::bloom::BloomCompositeMode as ::std::cmp::PartialEq< ::bevy_post_process::bloom::BloomCompositeMode, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -189,11 +177,10 @@ pub(crate) fn register_bloom_prefilter_functions(world: &mut World) { |_self: Ref<::bevy_post_process::bloom::BloomPrefilter>| { let output: Val<::bevy_post_process::bloom::BloomPrefilter> = { { - let output: Val<::bevy_post_process::bloom::BloomPrefilter> = <::bevy_post_process::bloom::BloomPrefilter as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_post_process::bloom::BloomPrefilter = <::bevy_post_process::bloom::BloomPrefilter as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -218,11 +205,10 @@ pub(crate) fn register_depth_of_field_functions(world: &mut World) { |_self: Ref<::bevy_post_process::dof::DepthOfField>| { let output: Val<::bevy_post_process::dof::DepthOfField> = { { - let output: Val<::bevy_post_process::dof::DepthOfField> = <::bevy_post_process::dof::DepthOfField as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_post_process::dof::DepthOfField = <::bevy_post_process::dof::DepthOfField as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -247,11 +233,10 @@ pub(crate) fn register_depth_of_field_mode_functions(world: &mut World) { |_self: Ref<::bevy_post_process::dof::DepthOfFieldMode>| { let output: Val<::bevy_post_process::dof::DepthOfFieldMode> = { { - let output: Val<::bevy_post_process::dof::DepthOfFieldMode> = <::bevy_post_process::dof::DepthOfFieldMode as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_post_process::dof::DepthOfFieldMode = <::bevy_post_process::dof::DepthOfFieldMode as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -269,9 +254,8 @@ pub(crate) fn register_depth_of_field_mode_functions(world: &mut World) { { let output: bool = <::bevy_post_process::dof::DepthOfFieldMode as ::std::cmp::PartialEq< ::bevy_post_process::dof::DepthOfFieldMode, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -298,13 +282,10 @@ pub(crate) fn register_chromatic_aberration_functions(world: &mut World) { ::bevy_post_process::effect_stack::ChromaticAberration, > = { { - let output: Val< - ::bevy_post_process::effect_stack::ChromaticAberration, - > = <::bevy_post_process::effect_stack::ChromaticAberration as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_post_process::effect_stack::ChromaticAberration = <::bevy_post_process::effect_stack::ChromaticAberration as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -329,11 +310,10 @@ pub(crate) fn register_motion_blur_functions(world: &mut World) { |_self: Ref<::bevy_post_process::motion_blur::MotionBlur>| { let output: Val<::bevy_post_process::motion_blur::MotionBlur> = { { - let output: Val<::bevy_post_process::motion_blur::MotionBlur> = <::bevy_post_process::motion_blur::MotionBlur as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_post_process::motion_blur::MotionBlur = <::bevy_post_process::motion_blur::MotionBlur as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs b/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs index 14955f8b95..17e1a3f724 100644 --- a/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs @@ -1,15 +1,18 @@ + #![allow(clippy::all)] #![allow(unused, deprecated, dead_code)] -use bevy_app::{App, Plugin}; -use bevy_ecs::prelude::*; + + use bevy_mod_scripting_bindings::{ ReflectReference, function::{ - from::{Mut, Ref, Val}, - namespace::NamespaceBuilder, + from::{Ref, Mut, Val}, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; +use bevy_ecs::prelude::*; +use bevy_app::{App, Plugin}; use bevy_mod_scripting_derive::script_bindings; pub struct BevyReflectScriptingPlugin; pub(crate) fn register_atomic_bool_functions(world: &mut World) { @@ -22,10 +25,9 @@ pub(crate) fn register_atomic_bool_functions(world: &mut World) { let output: bool = { { let output: bool = ::core::sync::atomic::AtomicBool::into_inner( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -38,11 +40,10 @@ pub(crate) fn register_atomic_bool_functions(world: &mut World) { |v: bool| { let output: Val<::core::sync::atomic::AtomicBool> = { { - let output: Val<::core::sync::atomic::AtomicBool> = ::core::sync::atomic::AtomicBool::new( - v, - ) - .into(); - output + let output: ::core::sync::atomic::AtomicBool = ::core::sync::atomic::AtomicBool::new( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -68,10 +69,9 @@ pub(crate) fn register_atomic_i_8_functions(world: &mut World) { let output: i8 = { { let output: i8 = ::core::sync::atomic::AtomicI8::into_inner( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -84,11 +84,10 @@ pub(crate) fn register_atomic_i_8_functions(world: &mut World) { |v: i8| { let output: Val<::core::sync::atomic::AtomicI8> = { { - let output: Val<::core::sync::atomic::AtomicI8> = ::core::sync::atomic::AtomicI8::new( - v, - ) - .into(); - output + let output: ::core::sync::atomic::AtomicI8 = ::core::sync::atomic::AtomicI8::new( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -114,10 +113,9 @@ pub(crate) fn register_atomic_i_16_functions(world: &mut World) { let output: i16 = { { let output: i16 = ::core::sync::atomic::AtomicI16::into_inner( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -130,11 +128,10 @@ pub(crate) fn register_atomic_i_16_functions(world: &mut World) { |v: i16| { let output: Val<::core::sync::atomic::AtomicI16> = { { - let output: Val<::core::sync::atomic::AtomicI16> = ::core::sync::atomic::AtomicI16::new( - v, - ) - .into(); - output + let output: ::core::sync::atomic::AtomicI16 = ::core::sync::atomic::AtomicI16::new( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -160,10 +157,9 @@ pub(crate) fn register_atomic_i_32_functions(world: &mut World) { let output: i32 = { { let output: i32 = ::core::sync::atomic::AtomicI32::into_inner( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -176,11 +172,10 @@ pub(crate) fn register_atomic_i_32_functions(world: &mut World) { |v: i32| { let output: Val<::core::sync::atomic::AtomicI32> = { { - let output: Val<::core::sync::atomic::AtomicI32> = ::core::sync::atomic::AtomicI32::new( - v, - ) - .into(); - output + let output: ::core::sync::atomic::AtomicI32 = ::core::sync::atomic::AtomicI32::new( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -206,10 +201,9 @@ pub(crate) fn register_atomic_i_64_functions(world: &mut World) { let output: i64 = { { let output: i64 = ::core::sync::atomic::AtomicI64::into_inner( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -222,11 +216,10 @@ pub(crate) fn register_atomic_i_64_functions(world: &mut World) { |v: i64| { let output: Val<::core::sync::atomic::AtomicI64> = { { - let output: Val<::core::sync::atomic::AtomicI64> = ::core::sync::atomic::AtomicI64::new( - v, - ) - .into(); - output + let output: ::core::sync::atomic::AtomicI64 = ::core::sync::atomic::AtomicI64::new( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -252,10 +245,9 @@ pub(crate) fn register_atomic_isize_functions(world: &mut World) { let output: isize = { { let output: isize = ::core::sync::atomic::AtomicIsize::into_inner( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -268,11 +260,10 @@ pub(crate) fn register_atomic_isize_functions(world: &mut World) { |v: isize| { let output: Val<::core::sync::atomic::AtomicIsize> = { { - let output: Val<::core::sync::atomic::AtomicIsize> = ::core::sync::atomic::AtomicIsize::new( - v, - ) - .into(); - output + let output: ::core::sync::atomic::AtomicIsize = ::core::sync::atomic::AtomicIsize::new( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -298,10 +289,9 @@ pub(crate) fn register_atomic_u_8_functions(world: &mut World) { let output: u8 = { { let output: u8 = ::core::sync::atomic::AtomicU8::into_inner( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -314,11 +304,10 @@ pub(crate) fn register_atomic_u_8_functions(world: &mut World) { |v: u8| { let output: Val<::core::sync::atomic::AtomicU8> = { { - let output: Val<::core::sync::atomic::AtomicU8> = ::core::sync::atomic::AtomicU8::new( - v, - ) - .into(); - output + let output: ::core::sync::atomic::AtomicU8 = ::core::sync::atomic::AtomicU8::new( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -344,10 +333,9 @@ pub(crate) fn register_atomic_u_16_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::core::sync::atomic::AtomicU16::into_inner( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -360,11 +348,10 @@ pub(crate) fn register_atomic_u_16_functions(world: &mut World) { |v: u16| { let output: Val<::core::sync::atomic::AtomicU16> = { { - let output: Val<::core::sync::atomic::AtomicU16> = ::core::sync::atomic::AtomicU16::new( - v, - ) - .into(); - output + let output: ::core::sync::atomic::AtomicU16 = ::core::sync::atomic::AtomicU16::new( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -390,10 +377,9 @@ pub(crate) fn register_atomic_u_32_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::core::sync::atomic::AtomicU32::into_inner( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -406,11 +392,10 @@ pub(crate) fn register_atomic_u_32_functions(world: &mut World) { |v: u32| { let output: Val<::core::sync::atomic::AtomicU32> = { { - let output: Val<::core::sync::atomic::AtomicU32> = ::core::sync::atomic::AtomicU32::new( - v, - ) - .into(); - output + let output: ::core::sync::atomic::AtomicU32 = ::core::sync::atomic::AtomicU32::new( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -436,10 +421,9 @@ pub(crate) fn register_atomic_u_64_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::core::sync::atomic::AtomicU64::into_inner( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -452,11 +436,10 @@ pub(crate) fn register_atomic_u_64_functions(world: &mut World) { |v: u64| { let output: Val<::core::sync::atomic::AtomicU64> = { { - let output: Val<::core::sync::atomic::AtomicU64> = ::core::sync::atomic::AtomicU64::new( - v, - ) - .into(); - output + let output: ::core::sync::atomic::AtomicU64 = ::core::sync::atomic::AtomicU64::new( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -482,10 +465,9 @@ pub(crate) fn register_atomic_usize_functions(world: &mut World) { let output: usize = { { let output: usize = ::core::sync::atomic::AtomicUsize::into_inner( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -498,11 +480,10 @@ pub(crate) fn register_atomic_usize_functions(world: &mut World) { |v: usize| { let output: Val<::core::sync::atomic::AtomicUsize> = { { - let output: Val<::core::sync::atomic::AtomicUsize> = ::core::sync::atomic::AtomicUsize::new( - v, - ) - .into(); - output + let output: ::core::sync::atomic::AtomicUsize = ::core::sync::atomic::AtomicUsize::new( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -527,12 +508,11 @@ pub(crate) fn register_duration_functions(world: &mut World) { |_self: Val<::core::time::Duration>, other: Val<::core::time::Duration>| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::abs_diff( - _self.into_inner(), - other.into_inner(), - ) - .into(); - output + let output: ::core::time::Duration = ::core::time::Duration::abs_diff( + safe_transmute(_self), + safe_transmute(other), + ); + safe_transmute(output) } }; output @@ -545,11 +525,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { |_self: Val<::core::time::Duration>, rhs: Val<::core::time::Duration>| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = <::core::time::Duration as ::core::ops::Add< + let output: ::core::time::Duration = <::core::time::Duration as ::core::ops::Add< ::core::time::Duration, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -562,9 +541,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { |_self: Ref<::core::time::Duration>| { let output: u128 = { { - let output: u128 = ::core::time::Duration::as_micros(&_self) - .into(); - output + let output: u128 = ::core::time::Duration::as_micros( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -577,9 +557,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { |_self: Ref<::core::time::Duration>| { let output: u128 = { { - let output: u128 = ::core::time::Duration::as_millis(&_self) - .into(); - output + let output: u128 = ::core::time::Duration::as_millis( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -592,9 +573,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { |_self: Ref<::core::time::Duration>| { let output: u128 = { { - let output: u128 = ::core::time::Duration::as_nanos(&_self) - .into(); - output + let output: u128 = ::core::time::Duration::as_nanos( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -607,8 +589,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { |_self: Ref<::core::time::Duration>| { let output: u64 = { { - let output: u64 = ::core::time::Duration::as_secs(&_self).into(); - output + let output: u64 = ::core::time::Duration::as_secs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -621,9 +605,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { |_self: Ref<::core::time::Duration>| { let output: f32 = { { - let output: f32 = ::core::time::Duration::as_secs_f32(&_self) - .into(); - output + let output: f32 = ::core::time::Duration::as_secs_f32( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -636,9 +621,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { |_self: Ref<::core::time::Duration>| { let output: f64 = { { - let output: f64 = ::core::time::Duration::as_secs_f64(&_self) - .into(); - output + let output: f64 = ::core::time::Duration::as_secs_f64( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -652,10 +638,9 @@ pub(crate) fn register_duration_functions(world: &mut World) { let output: () = { { let output: () = <::core::time::Duration as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -668,11 +653,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { |_self: Ref<::core::time::Duration>| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = <::core::time::Duration as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::core::time::Duration = <::core::time::Duration as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -685,11 +669,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { |_self: Val<::core::time::Duration>, rhs: u32| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = <::core::time::Duration as ::core::ops::Div< + let output: ::core::time::Duration = <::core::time::Duration as ::core::ops::Div< u32, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -703,11 +686,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::core::time::Duration::div_duration_f32( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -721,11 +703,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::core::time::Duration::div_duration_f64( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -738,12 +719,11 @@ pub(crate) fn register_duration_functions(world: &mut World) { |_self: Val<::core::time::Duration>, rhs: f32| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::div_f32( - _self.into_inner(), - rhs, - ) - .into(); - output + let output: ::core::time::Duration = ::core::time::Duration::div_f32( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -756,12 +736,11 @@ pub(crate) fn register_duration_functions(world: &mut World) { |_self: Val<::core::time::Duration>, rhs: f64| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::div_f64( - _self.into_inner(), - rhs, - ) - .into(); - output + let output: ::core::time::Duration = ::core::time::Duration::div_f64( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -776,9 +755,8 @@ pub(crate) fn register_duration_functions(world: &mut World) { { let output: bool = <::core::time::Duration as ::core::cmp::PartialEq< ::core::time::Duration, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -791,11 +769,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { |micros: u64| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::from_micros( - micros, - ) - .into(); - output + let output: ::core::time::Duration = ::core::time::Duration::from_micros( + safe_transmute(micros), + ); + safe_transmute(output) } }; output @@ -808,11 +785,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { |millis: u64| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::from_millis( - millis, - ) - .into(); - output + let output: ::core::time::Duration = ::core::time::Duration::from_millis( + safe_transmute(millis), + ); + safe_transmute(output) } }; output @@ -825,11 +801,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { |nanos: u64| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::from_nanos( - nanos, - ) - .into(); - output + let output: ::core::time::Duration = ::core::time::Duration::from_nanos( + safe_transmute(nanos), + ); + safe_transmute(output) } }; output @@ -842,11 +817,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { |secs: u64| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::from_secs( - secs, - ) - .into(); - output + let output: ::core::time::Duration = ::core::time::Duration::from_secs( + safe_transmute(secs), + ); + safe_transmute(output) } }; output @@ -859,11 +833,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { |secs: f32| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::from_secs_f32( - secs, - ) - .into(); - output + let output: ::core::time::Duration = ::core::time::Duration::from_secs_f32( + safe_transmute(secs), + ); + safe_transmute(output) } }; output @@ -876,11 +849,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { |secs: f64| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::from_secs_f64( - secs, - ) - .into(); - output + let output: ::core::time::Duration = ::core::time::Duration::from_secs_f64( + safe_transmute(secs), + ); + safe_transmute(output) } }; output @@ -893,9 +865,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { |_self: Ref<::core::time::Duration>| { let output: bool = { { - let output: bool = ::core::time::Duration::is_zero(&_self) - .into(); - output + let output: bool = ::core::time::Duration::is_zero( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -908,11 +881,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { |_self: Val<::core::time::Duration>, rhs: u32| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = <::core::time::Duration as ::core::ops::Mul< + let output: ::core::time::Duration = <::core::time::Duration as ::core::ops::Mul< u32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -925,12 +897,11 @@ pub(crate) fn register_duration_functions(world: &mut World) { |_self: Val<::core::time::Duration>, rhs: f32| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::mul_f32( - _self.into_inner(), - rhs, - ) - .into(); - output + let output: ::core::time::Duration = ::core::time::Duration::mul_f32( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -943,12 +914,11 @@ pub(crate) fn register_duration_functions(world: &mut World) { |_self: Val<::core::time::Duration>, rhs: f64| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::mul_f64( - _self.into_inner(), - rhs, - ) - .into(); - output + let output: ::core::time::Duration = ::core::time::Duration::mul_f64( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -961,12 +931,11 @@ pub(crate) fn register_duration_functions(world: &mut World) { |secs: u64, nanos: u32| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::new( - secs, - nanos, - ) - .into(); - output + let output: ::core::time::Duration = ::core::time::Duration::new( + safe_transmute(secs), + safe_transmute(nanos), + ); + safe_transmute(output) } }; output @@ -979,12 +948,11 @@ pub(crate) fn register_duration_functions(world: &mut World) { |_self: Val<::core::time::Duration>, rhs: Val<::core::time::Duration>| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::core::time::Duration = ::core::time::Duration::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -997,12 +965,11 @@ pub(crate) fn register_duration_functions(world: &mut World) { |_self: Val<::core::time::Duration>, rhs: u32| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::saturating_mul( - _self.into_inner(), - rhs, - ) - .into(); - output + let output: ::core::time::Duration = ::core::time::Duration::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -1015,12 +982,11 @@ pub(crate) fn register_duration_functions(world: &mut World) { |_self: Val<::core::time::Duration>, rhs: Val<::core::time::Duration>| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = ::core::time::Duration::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::core::time::Duration = ::core::time::Duration::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -1033,11 +999,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { |_self: Val<::core::time::Duration>, rhs: Val<::core::time::Duration>| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = <::core::time::Duration as ::core::ops::Sub< + let output: ::core::time::Duration = <::core::time::Duration as ::core::ops::Sub< ::core::time::Duration, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -1050,9 +1015,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { |_self: Ref<::core::time::Duration>| { let output: u32 = { { - let output: u32 = ::core::time::Duration::subsec_micros(&_self) - .into(); - output + let output: u32 = ::core::time::Duration::subsec_micros( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1065,9 +1031,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { |_self: Ref<::core::time::Duration>| { let output: u32 = { { - let output: u32 = ::core::time::Duration::subsec_millis(&_self) - .into(); - output + let output: u32 = ::core::time::Duration::subsec_millis( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1080,9 +1047,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { |_self: Ref<::core::time::Duration>| { let output: u32 = { { - let output: u32 = ::core::time::Duration::subsec_nanos(&_self) - .into(); - output + let output: u32 = ::core::time::Duration::subsec_nanos( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1093,8 +1061,10 @@ pub(crate) fn register_duration_functions(world: &mut World) { let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::core::time::Duration, bevy_mod_scripting_bindings::MarkAsGenerated>( - ); + .register_type_data::< + ::core::time::Duration, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_instant_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -1105,11 +1075,10 @@ pub(crate) fn register_instant_functions(world: &mut World) { |_self: Val<::std::time::Instant>, other: Val<::core::time::Duration>| { let output: Val<::std::time::Instant> = { { - let output: Val<::std::time::Instant> = <::std::time::Instant as ::core::ops::Add< + let output: ::std::time::Instant = <::std::time::Instant as ::core::ops::Add< ::core::time::Duration, - >>::add(_self.into_inner(), other.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1123,10 +1092,9 @@ pub(crate) fn register_instant_functions(world: &mut World) { let output: () = { { let output: () = <::std::time::Instant as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1139,11 +1107,10 @@ pub(crate) fn register_instant_functions(world: &mut World) { |_self: Ref<::std::time::Instant>| { let output: Val<::std::time::Instant> = { { - let output: Val<::std::time::Instant> = <::std::time::Instant as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::std::time::Instant = <::std::time::Instant as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1156,12 +1123,11 @@ pub(crate) fn register_instant_functions(world: &mut World) { |_self: Ref<::std::time::Instant>, earlier: Val<::std::time::Instant>| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = ::std::time::Instant::duration_since( - &_self, - earlier.into_inner(), - ) - .into(); - output + let output: ::core::time::Duration = ::std::time::Instant::duration_since( + safe_transmute(_self), + safe_transmute(earlier), + ); + safe_transmute(output) } }; output @@ -1174,11 +1140,10 @@ pub(crate) fn register_instant_functions(world: &mut World) { |_self: Ref<::std::time::Instant>| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = ::std::time::Instant::elapsed( - &_self, - ) - .into(); - output + let output: ::core::time::Duration = ::std::time::Instant::elapsed( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1193,9 +1158,8 @@ pub(crate) fn register_instant_functions(world: &mut World) { { let output: bool = <::std::time::Instant as ::core::cmp::PartialEq< ::std::time::Instant, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1208,9 +1172,8 @@ pub(crate) fn register_instant_functions(world: &mut World) { || { let output: Val<::std::time::Instant> = { { - let output: Val<::std::time::Instant> = ::std::time::Instant::now() - .into(); - output + let output: ::std::time::Instant = ::std::time::Instant::now(); + safe_transmute(output) } }; output @@ -1223,12 +1186,11 @@ pub(crate) fn register_instant_functions(world: &mut World) { |_self: Ref<::std::time::Instant>, earlier: Val<::std::time::Instant>| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = ::std::time::Instant::saturating_duration_since( - &_self, - earlier.into_inner(), - ) - .into(); - output + let output: ::core::time::Duration = ::std::time::Instant::saturating_duration_since( + safe_transmute(_self), + safe_transmute(earlier), + ); + safe_transmute(output) } }; output @@ -1241,11 +1203,10 @@ pub(crate) fn register_instant_functions(world: &mut World) { |_self: Val<::std::time::Instant>, other: Val<::core::time::Duration>| { let output: Val<::std::time::Instant> = { { - let output: Val<::std::time::Instant> = <::std::time::Instant as ::core::ops::Sub< + let output: ::std::time::Instant = <::std::time::Instant as ::core::ops::Sub< ::core::time::Duration, - >>::sub(_self.into_inner(), other.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1258,11 +1219,10 @@ pub(crate) fn register_instant_functions(world: &mut World) { |_self: Val<::std::time::Instant>, other: Val<::std::time::Instant>| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = <::std::time::Instant as ::core::ops::Sub< + let output: ::core::time::Duration = <::std::time::Instant as ::core::ops::Sub< ::std::time::Instant, - >>::sub(_self.into_inner(), other.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1273,7 +1233,10 @@ pub(crate) fn register_instant_functions(world: &mut World) { let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::std::time::Instant, bevy_mod_scripting_bindings::MarkAsGenerated>(); + .register_type_data::< + ::std::time::Instant, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_range_full_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -1285,10 +1248,9 @@ pub(crate) fn register_range_full_functions(world: &mut World) { let output: () = { { let output: () = <::core::ops::RangeFull as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1301,11 +1263,10 @@ pub(crate) fn register_range_full_functions(world: &mut World) { |_self: Ref<::core::ops::RangeFull>| { let output: Val<::core::ops::RangeFull> = { { - let output: Val<::core::ops::RangeFull> = <::core::ops::RangeFull as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::core::ops::RangeFull = <::core::ops::RangeFull as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1320,9 +1281,8 @@ pub(crate) fn register_range_full_functions(world: &mut World) { { let output: bool = <::core::ops::RangeFull as ::core::cmp::PartialEq< ::core::ops::RangeFull, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1333,67 +1293,70 @@ pub(crate) fn register_range_full_functions(world: &mut World) { let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::core::ops::RangeFull, bevy_mod_scripting_bindings::MarkAsGenerated>( - ); + .register_type_data::< + ::core::ops::RangeFull, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_type_id_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<::core::any::TypeId>::new( - world, - ) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::core::any::TypeId>| { - let output: () = { - { - let output: () = - <::core::any::TypeId as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::core::any::TypeId>| { - let output: Val<::core::any::TypeId> = { - { - let output: Val<::core::any::TypeId> = - <::core::any::TypeId as ::core::clone::Clone>::clone(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::core::any::TypeId>, other: Ref<::core::any::TypeId>| { - let output: bool = { - { - let output: bool = <::core::any::TypeId as ::core::cmp::PartialEq< - ::core::any::TypeId, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::core::any::TypeId, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::core::any::TypeId>| { + let output: () = { + { + let output: () = <::core::any::TypeId as ::core::cmp::Eq>::assert_receiver_is_total_eq( + safe_transmute(_self), + ); + safe_transmute(output) + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::core::any::TypeId>| { + let output: Val<::core::any::TypeId> = { + { + let output: ::core::any::TypeId = <::core::any::TypeId as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::core::any::TypeId>, other: Ref<::core::any::TypeId>| { + let output: bool = { + { + let output: bool = <::core::any::TypeId as ::core::cmp::PartialEq< + ::core::any::TypeId, + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::core::any::TypeId, bevy_mod_scripting_bindings::MarkAsGenerated>(); + .register_type_data::< + ::core::any::TypeId, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_quat_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -1405,12 +1368,11 @@ pub(crate) fn register_quat_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::Quat::abs_diff_eq( - _self.into_inner(), - rhs.into_inner(), - max_abs_diff, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_abs_diff), + ); + safe_transmute(output) } }; output @@ -1423,11 +1385,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Ref<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Add< + let output: ::glam::Quat = <::glam::Quat as ::core::ops::Add< &::glam::Quat, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -1440,11 +1401,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Val<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Add< + let output: ::glam::Quat = <::glam::Quat as ::core::ops::Add< ::glam::Quat, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -1458,11 +1418,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Quat::angle_between( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -1475,11 +1434,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::Quat::as_dquat( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DQuat = ::glam::Quat::as_dquat( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1492,11 +1450,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Ref<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::Quat = <::glam::Quat as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1509,11 +1466,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::conjugate( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::conjugate( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1526,11 +1482,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: f32| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Div< + let output: ::glam::Quat = <::glam::Quat as ::core::ops::Div< f32, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -1544,11 +1499,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Quat::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -1563,9 +1517,8 @@ pub(crate) fn register_quat_functions(world: &mut World) { { let output: bool = <::glam::Quat as ::core::cmp::PartialEq< ::glam::Quat, - >>::eq(&_self, &rhs) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -1578,9 +1531,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |a: Ref<::glam::Affine3A>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::from_affine3(&a) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::from_affine3( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -1593,9 +1547,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |a: [f32; 4]| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::from_array(a) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -1608,12 +1563,11 @@ pub(crate) fn register_quat_functions(world: &mut World) { |axis: Val<::glam::Vec3>, angle: f32| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::from_axis_angle( - axis.into_inner(), - angle, - ) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::from_axis_angle( + safe_transmute(axis), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -1626,14 +1580,13 @@ pub(crate) fn register_quat_functions(world: &mut World) { |euler: Val<::glam::EulerRot>, a: f32, b: f32, c: f32| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::from_euler( - euler.into_inner(), - a, - b, - c, - ) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::from_euler( + safe_transmute(euler), + safe_transmute(a), + safe_transmute(b), + safe_transmute(c), + ); + safe_transmute(output) } }; output @@ -1646,9 +1599,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |mat: Ref<::glam::Mat3>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::from_mat3(&mat) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::from_mat3( + safe_transmute(mat), + ); + safe_transmute(output) } }; output @@ -1661,9 +1615,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |mat: Ref<::glam::Mat3A>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::from_mat3a(&mat) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::from_mat3a( + safe_transmute(mat), + ); + safe_transmute(output) } }; output @@ -1676,9 +1631,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |mat: Ref<::glam::Mat4>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::from_mat4(&mat) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::from_mat4( + safe_transmute(mat), + ); + safe_transmute(output) } }; output @@ -1691,12 +1647,11 @@ pub(crate) fn register_quat_functions(world: &mut World) { |from: Val<::glam::Vec3>, to: Val<::glam::Vec3>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::from_rotation_arc( - from.into_inner(), - to.into_inner(), - ) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::from_rotation_arc( + safe_transmute(from), + safe_transmute(to), + ); + safe_transmute(output) } }; output @@ -1709,12 +1664,11 @@ pub(crate) fn register_quat_functions(world: &mut World) { |from: Val<::glam::Vec2>, to: Val<::glam::Vec2>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::from_rotation_arc_2d( - from.into_inner(), - to.into_inner(), - ) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::from_rotation_arc_2d( + safe_transmute(from), + safe_transmute(to), + ); + safe_transmute(output) } }; output @@ -1727,12 +1681,11 @@ pub(crate) fn register_quat_functions(world: &mut World) { |from: Val<::glam::Vec3>, to: Val<::glam::Vec3>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::from_rotation_arc_colinear( - from.into_inner(), - to.into_inner(), - ) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::from_rotation_arc_colinear( + safe_transmute(from), + safe_transmute(to), + ); + safe_transmute(output) } }; output @@ -1745,11 +1698,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |angle: f32| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::from_rotation_x( - angle, - ) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::from_rotation_x( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -1762,11 +1714,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |angle: f32| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::from_rotation_y( - angle, - ) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::from_rotation_y( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -1779,11 +1730,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |angle: f32| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::from_rotation_z( - angle, - ) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::from_rotation_z( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -1796,11 +1746,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |v: Val<::glam::Vec3>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::from_scaled_axis( - v.into_inner(), - ) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::from_scaled_axis( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -1813,11 +1762,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |v: Val<::glam::Vec4>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::from_vec4( - v.into_inner(), - ) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::from_vec4( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -1830,14 +1778,13 @@ pub(crate) fn register_quat_functions(world: &mut World) { |x: f32, y: f32, z: f32, w: f32| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::from_xyzw( - x, - y, - z, - w, - ) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::from_xyzw( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -1850,11 +1797,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::inverse( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::inverse( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1867,9 +1813,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>| { let output: bool = { { - let output: bool = ::glam::Quat::is_finite(_self.into_inner()) - .into(); - output + let output: bool = ::glam::Quat::is_finite( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1882,9 +1829,8 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>| { let output: bool = { { - let output: bool = ::glam::Quat::is_nan(_self.into_inner()) - .into(); - output + let output: bool = ::glam::Quat::is_nan(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -1898,10 +1844,9 @@ pub(crate) fn register_quat_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::Quat::is_near_identity( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1915,10 +1860,9 @@ pub(crate) fn register_quat_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::Quat::is_normalized( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1931,9 +1875,8 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>| { let output: f32 = { { - let output: f32 = ::glam::Quat::length(_self.into_inner()) - .into(); - output + let output: f32 = ::glam::Quat::length(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -1946,9 +1889,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>| { let output: f32 = { { - let output: f32 = ::glam::Quat::length_recip(_self.into_inner()) - .into(); - output + let output: f32 = ::glam::Quat::length_recip( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1962,10 +1906,9 @@ pub(crate) fn register_quat_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Quat::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1978,13 +1921,12 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, end: Val<::glam::Quat>, s: f32| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::lerp( - _self.into_inner(), - end.into_inner(), - s, - ) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::lerp( + safe_transmute(_self), + safe_transmute(end), + safe_transmute(s), + ); + safe_transmute(output) } }; output @@ -1997,13 +1939,12 @@ pub(crate) fn register_quat_functions(world: &mut World) { |eye: Val<::glam::Vec3>, center: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::look_at_lh( - eye.into_inner(), - center.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::look_at_lh( + safe_transmute(eye), + safe_transmute(center), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -2016,13 +1957,12 @@ pub(crate) fn register_quat_functions(world: &mut World) { |eye: Val<::glam::Vec3>, center: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::look_at_rh( - eye.into_inner(), - center.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::look_at_rh( + safe_transmute(eye), + safe_transmute(center), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -2035,12 +1975,11 @@ pub(crate) fn register_quat_functions(world: &mut World) { |dir: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::look_to_lh( - dir.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::look_to_lh( + safe_transmute(dir), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -2053,12 +1992,11 @@ pub(crate) fn register_quat_functions(world: &mut World) { |dir: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::look_to_rh( - dir.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::look_to_rh( + safe_transmute(dir), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -2071,11 +2009,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Ref<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Mul< + let output: ::glam::Quat = <::glam::Quat as ::core::ops::Mul< &::glam::Quat, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -2088,11 +2025,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Quat as ::core::ops::Mul< + let output: ::glam::Vec3 = <::glam::Quat as ::core::ops::Mul< &::glam::Vec3, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -2105,11 +2041,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Quat as ::core::ops::Mul< + let output: ::glam::Vec3A = <::glam::Quat as ::core::ops::Mul< &::glam::Vec3A, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -2122,11 +2057,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Val<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Mul< + let output: ::glam::Quat = <::glam::Quat as ::core::ops::Mul< ::glam::Quat, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -2139,11 +2073,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Quat as ::core::ops::Mul< + let output: ::glam::Vec3 = <::glam::Quat as ::core::ops::Mul< ::glam::Vec3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -2156,11 +2089,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Quat as ::core::ops::Mul< + let output: ::glam::Vec3A = <::glam::Quat as ::core::ops::Mul< ::glam::Vec3A, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -2173,11 +2105,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: f32| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Mul< + let output: ::glam::Quat = <::glam::Quat as ::core::ops::Mul< f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -2190,12 +2121,11 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Val<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::mul_quat( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::mul_quat( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -2208,12 +2138,11 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Quat::mul_vec3( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Quat::mul_vec3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -2226,12 +2155,11 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Quat::mul_vec3a( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Quat::mul_vec3a( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -2244,11 +2172,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Quat = <::glam::Quat as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2261,11 +2188,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::normalize( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::normalize( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2278,13 +2204,12 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Ref<::glam::Quat>, rhs: Val<::glam::Quat>, max_angle: f32| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::rotate_towards( - &_self, - rhs.into_inner(), - max_angle, - ) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::rotate_towards( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_angle), + ); + safe_transmute(output) } }; output @@ -2297,13 +2222,12 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, end: Val<::glam::Quat>, s: f32| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::Quat::slerp( - _self.into_inner(), - end.into_inner(), - s, - ) - .into(); - output + let output: ::glam::Quat = ::glam::Quat::slerp( + safe_transmute(_self), + safe_transmute(end), + safe_transmute(s), + ); + safe_transmute(output) } }; output @@ -2316,11 +2240,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Ref<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Sub< + let output: ::glam::Quat = <::glam::Quat as ::core::ops::Sub< &::glam::Quat, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -2333,11 +2256,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>, rhs: Val<::glam::Quat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Sub< + let output: ::glam::Quat = <::glam::Quat as ::core::ops::Sub< ::glam::Quat, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -2350,8 +2272,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Ref<::glam::Quat>| { let output: [f32; 4] = { { - let output: [f32; 4] = ::glam::Quat::to_array(&_self).into(); - output + let output: [f32; 4] = ::glam::Quat::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2365,11 +2289,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { let output: (f32, f32, f32) = { { let output: (f32, f32, f32) = ::glam::Quat::to_euler( - _self.into_inner(), - order.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(order), + ); + safe_transmute(output) } }; output @@ -2382,11 +2305,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Quat::to_scaled_axis( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Quat::to_scaled_axis( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2399,11 +2321,10 @@ pub(crate) fn register_quat_functions(world: &mut World) { |_self: Val<::glam::Quat>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Quat::xyz( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Quat::xyz( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2413,7 +2334,11 @@ pub(crate) fn register_quat_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::Quat, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::Quat, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_vec_3_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -2424,11 +2349,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::abs( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2442,12 +2366,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::Vec3::abs_diff_eq( - _self.into_inner(), - rhs.into_inner(), - max_abs_diff, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_abs_diff), + ); + safe_transmute(output) } }; output @@ -2460,11 +2383,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Add< + let output: ::glam::Vec3 = <::glam::Vec3 as ::core::ops::Add< &::glam::Vec3, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -2477,11 +2399,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Add< + let output: ::glam::Vec3 = <::glam::Vec3 as ::core::ops::Add< ::glam::Vec3, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -2494,11 +2415,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Add< + let output: ::glam::Vec3 = <::glam::Vec3 as ::core::ops::Add< f32, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -2512,11 +2432,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec3::angle_between( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -2529,11 +2448,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::any_orthogonal_vector( - &_self, - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::any_orthogonal_vector( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2546,11 +2464,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::any_orthonormal_vector( - &_self, - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::any_orthonormal_vector( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2563,9 +2480,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Ref<::glam::Vec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::Vec3::as_dvec3(&_self) - .into(); - output + let output: ::glam::DVec3 = ::glam::Vec3::as_dvec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2578,11 +2496,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Ref<::glam::Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::Vec3::as_i16vec3( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::Vec3::as_i16vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2595,11 +2512,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Ref<::glam::Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::Vec3::as_i64vec3( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::Vec3::as_i64vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2612,9 +2528,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Ref<::glam::Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::Vec3::as_i8vec3(&_self) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::Vec3::as_i8vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2627,9 +2544,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Ref<::glam::Vec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::Vec3::as_ivec3(&_self) - .into(); - output + let output: ::glam::IVec3 = ::glam::Vec3::as_ivec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2642,11 +2560,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Ref<::glam::Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::Vec3::as_u16vec3( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::Vec3::as_u16vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2659,11 +2576,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Ref<::glam::Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::Vec3::as_u64vec3( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::Vec3::as_u64vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2676,9 +2592,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Ref<::glam::Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::Vec3::as_u8vec3(&_self) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::Vec3::as_u8vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2691,9 +2608,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Ref<::glam::Vec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::Vec3::as_uvec3(&_self) - .into(); - output + let output: ::glam::UVec3 = ::glam::Vec3::as_uvec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2706,11 +2624,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::ceil( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::ceil( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2723,13 +2640,12 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, min: Val<::glam::Vec3>, max: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -2742,13 +2658,12 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, min: f32, max: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::clamp_length( - _self.into_inner(), - min, - max, - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::clamp_length( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -2761,12 +2676,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, max: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::clamp_length_max( - _self.into_inner(), - max, - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::clamp_length_max( + safe_transmute(_self), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -2779,12 +2693,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, min: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::clamp_length_min( - _self.into_inner(), - min, - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::clamp_length_min( + safe_transmute(_self), + safe_transmute(min), + ); + safe_transmute(output) } }; output @@ -2797,11 +2710,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::Vec3 = <::glam::Vec3 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2814,12 +2726,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::Vec3::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::Vec3::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -2832,12 +2743,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::Vec3::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::Vec3::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -2850,12 +2760,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::Vec3::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::Vec3::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -2868,12 +2777,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::Vec3::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::Vec3::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -2886,12 +2794,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::Vec3::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::Vec3::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -2904,12 +2811,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::Vec3::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::Vec3::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -2922,12 +2828,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::copysign( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::copysign( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -2940,12 +2845,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::cross( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::cross( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -2959,11 +2863,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec3::distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -2977,11 +2880,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec3::distance_squared( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -2994,11 +2896,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Div< + let output: ::glam::Vec3 = <::glam::Vec3 as ::core::ops::Div< &::glam::Vec3, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -3011,11 +2912,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Div< + let output: ::glam::Vec3 = <::glam::Vec3 as ::core::ops::Div< ::glam::Vec3, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -3028,11 +2928,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Div< + let output: ::glam::Vec3 = <::glam::Vec3 as ::core::ops::Div< f32, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -3045,12 +2944,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::div_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::div_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -3064,11 +2962,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec3::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -3081,12 +2978,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -3100,10 +2996,9 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec3::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3116,9 +3011,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: f32 = { { - let output: f32 = ::glam::Vec3::element_sum(_self.into_inner()) - .into(); - output + let output: f32 = ::glam::Vec3::element_sum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3133,9 +3029,8 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { { let output: bool = <::glam::Vec3 as ::core::cmp::PartialEq< ::glam::Vec3, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -3148,11 +3043,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::exp( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::exp( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3165,12 +3059,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, w: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec3::extend( - _self.into_inner(), - w, - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec3::extend( + safe_transmute(_self), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -3183,11 +3076,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::floor( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::floor( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3200,11 +3092,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::fract( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::fract( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3217,11 +3108,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::fract_gl( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::fract_gl( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3234,9 +3124,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |a: [f32; 3]| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::from_array(a) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -3249,9 +3140,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: bool = { { - let output: bool = ::glam::Vec3::is_finite(_self.into_inner()) - .into(); - output + let output: bool = ::glam::Vec3::is_finite( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3264,11 +3156,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::Vec3::is_finite_mask( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::Vec3::is_finite_mask( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3281,9 +3172,8 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: bool = { { - let output: bool = ::glam::Vec3::is_nan(_self.into_inner()) - .into(); - output + let output: bool = ::glam::Vec3::is_nan(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -3296,11 +3186,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::Vec3::is_nan_mask( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::Vec3::is_nan_mask( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3314,10 +3203,9 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::Vec3::is_negative_bitmask( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3331,10 +3219,9 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::Vec3::is_normalized( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3347,9 +3234,8 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: f32 = { { - let output: f32 = ::glam::Vec3::length(_self.into_inner()) - .into(); - output + let output: f32 = ::glam::Vec3::length(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -3362,9 +3248,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: f32 = { { - let output: f32 = ::glam::Vec3::length_recip(_self.into_inner()) - .into(); - output + let output: f32 = ::glam::Vec3::length_recip( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3378,10 +3265,9 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec3::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3394,13 +3280,12 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>, s: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::lerp( - _self.into_inner(), - rhs.into_inner(), - s, - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::lerp( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(s), + ); + safe_transmute(output) } }; output @@ -3413,12 +3298,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -3431,9 +3315,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: f32 = { { - let output: f32 = ::glam::Vec3::max_element(_self.into_inner()) - .into(); - output + let output: f32 = ::glam::Vec3::max_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3447,10 +3332,9 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::Vec3::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3463,12 +3347,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::midpoint( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::midpoint( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -3481,12 +3364,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -3499,9 +3381,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: f32 = { { - let output: f32 = ::glam::Vec3::min_element(_self.into_inner()) - .into(); - output + let output: f32 = ::glam::Vec3::min_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3515,10 +3398,9 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::Vec3::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3531,13 +3413,12 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Ref<::glam::Vec3>, rhs: Val<::glam::Vec3>, d: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::move_towards( - &_self, - rhs.into_inner(), - d, - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::move_towards( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(d), + ); + safe_transmute(output) } }; output @@ -3550,11 +3431,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Mul< + let output: ::glam::Vec3 = <::glam::Vec3 as ::core::ops::Mul< &::glam::Vec3, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -3567,11 +3447,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Mul< + let output: ::glam::Vec3 = <::glam::Vec3 as ::core::ops::Mul< ::glam::Vec3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -3584,11 +3463,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Mul< + let output: ::glam::Vec3 = <::glam::Vec3 as ::core::ops::Mul< f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -3601,13 +3479,12 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, a: Val<::glam::Vec3>, b: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::mul_add( - _self.into_inner(), - a.into_inner(), - b.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::mul_add( + safe_transmute(_self), + safe_transmute(a), + safe_transmute(b), + ); + safe_transmute(output) } }; output @@ -3620,11 +3497,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = <::glam::Vec3 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3637,9 +3513,12 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |x: f32, y: f32, z: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::new(x, y, z) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -3652,11 +3531,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::normalize( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::normalize( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3669,12 +3547,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, fallback: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::normalize_or( - _self.into_inner(), - fallback.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::normalize_or( + safe_transmute(_self), + safe_transmute(fallback), + ); + safe_transmute(output) } }; output @@ -3687,11 +3564,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::normalize_or_zero( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::normalize_or_zero( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3704,12 +3580,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, n: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::powf( - _self.into_inner(), - n, - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::powf( + safe_transmute(_self), + safe_transmute(n), + ); + safe_transmute(output) } }; output @@ -3722,12 +3597,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::project_onto( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::project_onto( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -3740,12 +3614,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::project_onto_normalized( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::project_onto_normalized( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -3758,11 +3631,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::recip( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::recip( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3775,12 +3647,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, normal: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::reflect( - _self.into_inner(), - normal.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::reflect( + safe_transmute(_self), + safe_transmute(normal), + ); + safe_transmute(output) } }; output @@ -3793,13 +3664,12 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, normal: Val<::glam::Vec3>, eta: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::refract( - _self.into_inner(), - normal.into_inner(), - eta, - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::refract( + safe_transmute(_self), + safe_transmute(normal), + safe_transmute(eta), + ); + safe_transmute(output) } }; output @@ -3812,12 +3682,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::reject_from( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::reject_from( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -3830,12 +3699,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::reject_from_normalized( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::reject_from_normalized( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -3848,11 +3716,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Rem< + let output: ::glam::Vec3 = <::glam::Vec3 as ::core::ops::Rem< &::glam::Vec3, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -3865,11 +3732,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Rem< + let output: ::glam::Vec3 = <::glam::Vec3 as ::core::ops::Rem< ::glam::Vec3, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -3882,11 +3748,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Rem< + let output: ::glam::Vec3 = <::glam::Vec3 as ::core::ops::Rem< f32, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -3899,12 +3764,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::rem_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::rem_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -3917,13 +3781,12 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, axis: Val<::glam::Vec3>, angle: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::rotate_axis( - _self.into_inner(), - axis.into_inner(), - angle, - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::rotate_axis( + safe_transmute(_self), + safe_transmute(axis), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -3936,13 +3799,12 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>, max_angle: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::rotate_towards( - _self.into_inner(), - rhs.into_inner(), - max_angle, - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::rotate_towards( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_angle), + ); + safe_transmute(output) } }; output @@ -3955,12 +3817,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, angle: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::rotate_x( - _self.into_inner(), - angle, - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::rotate_x( + safe_transmute(_self), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -3973,12 +3834,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, angle: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::rotate_y( - _self.into_inner(), - angle, - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::rotate_y( + safe_transmute(_self), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -3991,12 +3851,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, angle: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::rotate_z( - _self.into_inner(), - angle, - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::rotate_z( + safe_transmute(_self), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -4009,11 +3868,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::round( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::round( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4030,13 +3888,12 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -4049,11 +3906,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::signum( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::signum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4066,13 +3922,12 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>, s: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::slerp( - _self.into_inner(), - rhs.into_inner(), - s, - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::slerp( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(s), + ); + safe_transmute(output) } }; output @@ -4085,8 +3940,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |v: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::splat(v).into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -4099,11 +3956,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Sub< + let output: ::glam::Vec3 = <::glam::Vec3 as ::core::ops::Sub< &::glam::Vec3, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -4116,11 +3972,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Sub< + let output: ::glam::Vec3 = <::glam::Vec3 as ::core::ops::Sub< ::glam::Vec3, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -4133,11 +3988,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, rhs: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Sub< + let output: ::glam::Vec3 = <::glam::Vec3 as ::core::ops::Sub< f32, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -4150,8 +4004,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Ref<::glam::Vec3>| { let output: [f32; 3] = { { - let output: [f32; 3] = ::glam::Vec3::to_array(&_self).into(); - output + let output: [f32; 3] = ::glam::Vec3::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4164,11 +4020,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3::to_vec3a( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3::to_vec3a( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4181,11 +4036,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::trunc( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::trunc( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4198,11 +4052,10 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec3::truncate( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec3::truncate( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4215,12 +4068,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, x: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -4233,12 +4085,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, y: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -4251,12 +4102,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { |_self: Val<::glam::Vec3>, z: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3::with_z( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3::with_z( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -4266,7 +4116,11 @@ pub(crate) fn register_vec_3_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::Vec3, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::Vec3, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_socket_addr_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -4278,10 +4132,9 @@ pub(crate) fn register_socket_addr_functions(world: &mut World) { let output: () = { { let output: () = <::core::net::SocketAddr as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4294,11 +4147,10 @@ pub(crate) fn register_socket_addr_functions(world: &mut World) { |_self: Ref<::core::net::SocketAddr>| { let output: Val<::core::net::SocketAddr> = { { - let output: Val<::core::net::SocketAddr> = <::core::net::SocketAddr as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::core::net::SocketAddr = <::core::net::SocketAddr as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4313,9 +4165,8 @@ pub(crate) fn register_socket_addr_functions(world: &mut World) { { let output: bool = <::core::net::SocketAddr as ::core::cmp::PartialEq< ::core::net::SocketAddr, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -4328,9 +4179,10 @@ pub(crate) fn register_socket_addr_functions(world: &mut World) { |_self: Ref<::core::net::SocketAddr>| { let output: bool = { { - let output: bool = ::core::net::SocketAddr::is_ipv4(&_self) - .into(); - output + let output: bool = ::core::net::SocketAddr::is_ipv4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4343,9 +4195,10 @@ pub(crate) fn register_socket_addr_functions(world: &mut World) { |_self: Ref<::core::net::SocketAddr>| { let output: bool = { { - let output: bool = ::core::net::SocketAddr::is_ipv6(&_self) - .into(); - output + let output: bool = ::core::net::SocketAddr::is_ipv6( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4358,8 +4211,10 @@ pub(crate) fn register_socket_addr_functions(world: &mut World) { |_self: Ref<::core::net::SocketAddr>| { let output: u16 = { { - let output: u16 = ::core::net::SocketAddr::port(&_self).into(); - output + let output: u16 = ::core::net::SocketAddr::port( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4373,11 +4228,10 @@ pub(crate) fn register_socket_addr_functions(world: &mut World) { let output: () = { { let output: () = ::core::net::SocketAddr::set_port( - &mut _self, - new_port, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(new_port), + ); + safe_transmute(output) } }; output @@ -4402,11 +4256,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::abs( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4419,11 +4272,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Ref<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Add< + let output: ::glam::IVec2 = <::glam::IVec2 as ::core::ops::Add< &::glam::IVec2, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -4436,11 +4288,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Add< + let output: ::glam::IVec2 = <::glam::IVec2 as ::core::ops::Add< ::glam::IVec2, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -4453,11 +4304,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: i32| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Add< + let output: ::glam::IVec2 = <::glam::IVec2 as ::core::ops::Add< i32, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -4470,9 +4320,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Ref<::glam::IVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::IVec2::as_dvec2(&_self) - .into(); - output + let output: ::glam::DVec2 = ::glam::IVec2::as_dvec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4485,11 +4336,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Ref<::glam::IVec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::IVec2::as_i16vec2( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::IVec2::as_i16vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4502,11 +4352,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Ref<::glam::IVec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::IVec2::as_i64vec2( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::IVec2::as_i64vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4519,11 +4368,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Ref<::glam::IVec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::IVec2::as_i8vec2( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::IVec2::as_i8vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4536,11 +4384,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Ref<::glam::IVec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::IVec2::as_u16vec2( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::IVec2::as_u16vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4553,11 +4400,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Ref<::glam::IVec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::IVec2::as_u64vec2( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::IVec2::as_u64vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4570,11 +4416,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Ref<::glam::IVec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::IVec2::as_u8vec2( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::IVec2::as_u8vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4587,9 +4432,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Ref<::glam::IVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::IVec2::as_uvec2(&_self) - .into(); - output + let output: ::glam::UVec2 = ::glam::IVec2::as_uvec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4602,9 +4448,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Ref<::glam::IVec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::IVec2::as_vec2(&_self) - .into(); - output + let output: ::glam::Vec2 = ::glam::IVec2::as_vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4618,10 +4465,9 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { let output: () = { { let output: () = <::glam::IVec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4635,11 +4481,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::IVec2::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -4653,11 +4498,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::IVec2::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -4674,13 +4518,12 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -4693,11 +4536,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Ref<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::IVec2 = <::glam::IVec2 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4710,12 +4552,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::IVec2::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::IVec2::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -4728,12 +4569,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::IVec2::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::IVec2::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -4746,12 +4586,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::IVec2::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::IVec2::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -4764,12 +4603,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::IVec2::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::IVec2::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -4782,12 +4620,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::IVec2::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::IVec2::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -4800,12 +4637,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::IVec2::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::IVec2::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -4819,11 +4655,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { let output: i32 = { { let output: i32 = ::glam::IVec2::distance_squared( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -4836,11 +4671,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Ref<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Div< + let output: ::glam::IVec2 = <::glam::IVec2 as ::core::ops::Div< &::glam::IVec2, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -4853,11 +4687,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Div< + let output: ::glam::IVec2 = <::glam::IVec2 as ::core::ops::Div< ::glam::IVec2, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -4870,11 +4703,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: i32| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Div< + let output: ::glam::IVec2 = <::glam::IVec2 as ::core::ops::Div< i32, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -4887,12 +4719,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::div_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::div_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -4906,11 +4737,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { let output: i32 = { { let output: i32 = ::glam::IVec2::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -4923,12 +4753,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -4942,10 +4771,9 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { let output: i32 = { { let output: i32 = ::glam::IVec2::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4958,9 +4786,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>| { let output: i32 = { { - let output: i32 = ::glam::IVec2::element_sum(_self.into_inner()) - .into(); - output + let output: i32 = ::glam::IVec2::element_sum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4975,9 +4804,8 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { { let output: bool = <::glam::IVec2 as ::core::cmp::PartialEq< ::glam::IVec2, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -4990,12 +4818,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, z: i32| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec2::extend( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec2::extend( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -5008,9 +4835,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |a: [i32; 2]| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::from_array(a) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -5024,10 +4852,9 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::IVec2::is_negative_bitmask( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5041,10 +4868,9 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { let output: i32 = { { let output: i32 = ::glam::IVec2::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5058,11 +4884,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::IVec2::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -5075,12 +4900,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -5093,9 +4917,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>| { let output: i32 = { { - let output: i32 = ::glam::IVec2::max_element(_self.into_inner()) - .into(); - output + let output: i32 = ::glam::IVec2::max_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5109,10 +4934,9 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::IVec2::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5125,12 +4949,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -5143,9 +4966,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>| { let output: i32 = { { - let output: i32 = ::glam::IVec2::min_element(_self.into_inner()) - .into(); - output + let output: i32 = ::glam::IVec2::min_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5159,10 +4983,9 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::IVec2::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5175,11 +4998,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Ref<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Mul< + let output: ::glam::IVec2 = <::glam::IVec2 as ::core::ops::Mul< &::glam::IVec2, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -5192,11 +5014,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Mul< + let output: ::glam::IVec2 = <::glam::IVec2 as ::core::ops::Mul< ::glam::IVec2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -5209,11 +5030,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: i32| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Mul< + let output: ::glam::IVec2 = <::glam::IVec2 as ::core::ops::Mul< i32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -5226,11 +5046,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = <::glam::IVec2 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5243,8 +5062,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |x: i32, y: i32| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::new(x, y).into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::new( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -5257,11 +5079,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::perp( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::perp( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5275,11 +5096,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { let output: i32 = { { let output: i32 = ::glam::IVec2::perp_dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -5292,11 +5112,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Ref<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Rem< + let output: ::glam::IVec2 = <::glam::IVec2 as ::core::ops::Rem< &::glam::IVec2, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -5309,11 +5128,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Rem< + let output: ::glam::IVec2 = <::glam::IVec2 as ::core::ops::Rem< ::glam::IVec2, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -5326,11 +5144,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: i32| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Rem< + let output: ::glam::IVec2 = <::glam::IVec2 as ::core::ops::Rem< i32, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -5343,12 +5160,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::rem_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::rem_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -5361,12 +5177,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::rotate( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::rotate( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -5379,12 +5194,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -5397,12 +5211,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::saturating_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::saturating_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -5415,12 +5228,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -5433,12 +5245,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -5451,12 +5262,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -5469,12 +5279,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::saturating_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::saturating_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -5491,13 +5300,12 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -5510,11 +5318,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::signum( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::signum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5527,8 +5334,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |v: i32| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::splat(v).into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -5541,11 +5350,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Ref<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Sub< + let output: ::glam::IVec2 = <::glam::IVec2 as ::core::ops::Sub< &::glam::IVec2, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -5558,11 +5366,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Sub< + let output: ::glam::IVec2 = <::glam::IVec2 as ::core::ops::Sub< ::glam::IVec2, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -5575,11 +5382,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: i32| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Sub< + let output: ::glam::IVec2 = <::glam::IVec2 as ::core::ops::Sub< i32, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -5592,8 +5398,10 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Ref<::glam::IVec2>| { let output: [i32; 2] = { { - let output: [i32; 2] = ::glam::IVec2::to_array(&_self).into(); - output + let output: [i32; 2] = ::glam::IVec2::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5606,12 +5414,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, x: i32| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -5624,12 +5431,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, y: i32| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -5642,12 +5448,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -5660,12 +5465,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::wrapping_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::wrapping_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -5678,12 +5482,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -5696,12 +5499,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -5714,12 +5516,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -5732,12 +5533,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { |_self: Val<::glam::IVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec2::wrapping_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec2::wrapping_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -5747,7 +5547,11 @@ pub(crate) fn register_i_vec_2_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::IVec2, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::IVec2, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_i_vec_3_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -5758,11 +5562,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::abs( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5775,11 +5578,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Ref<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Add< + let output: ::glam::IVec3 = <::glam::IVec3 as ::core::ops::Add< &::glam::IVec3, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -5792,11 +5594,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Add< + let output: ::glam::IVec3 = <::glam::IVec3 as ::core::ops::Add< ::glam::IVec3, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -5809,11 +5610,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: i32| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Add< + let output: ::glam::IVec3 = <::glam::IVec3 as ::core::ops::Add< i32, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -5826,9 +5626,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Ref<::glam::IVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::IVec3::as_dvec3(&_self) - .into(); - output + let output: ::glam::DVec3 = ::glam::IVec3::as_dvec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5841,11 +5642,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Ref<::glam::IVec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::IVec3::as_i16vec3( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::IVec3::as_i16vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5858,11 +5658,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Ref<::glam::IVec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::IVec3::as_i64vec3( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::IVec3::as_i64vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5875,11 +5674,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Ref<::glam::IVec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::IVec3::as_i8vec3( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::IVec3::as_i8vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5892,11 +5690,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Ref<::glam::IVec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::IVec3::as_u16vec3( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::IVec3::as_u16vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5909,11 +5706,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Ref<::glam::IVec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::IVec3::as_u64vec3( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::IVec3::as_u64vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5926,11 +5722,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Ref<::glam::IVec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::IVec3::as_u8vec3( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::IVec3::as_u8vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5943,9 +5738,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Ref<::glam::IVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::IVec3::as_uvec3(&_self) - .into(); - output + let output: ::glam::UVec3 = ::glam::IVec3::as_uvec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5958,9 +5754,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Ref<::glam::IVec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::IVec3::as_vec3(&_self) - .into(); - output + let output: ::glam::Vec3 = ::glam::IVec3::as_vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5973,9 +5770,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Ref<::glam::IVec3>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::IVec3::as_vec3a(&_self) - .into(); - output + let output: ::glam::Vec3A = ::glam::IVec3::as_vec3a( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5989,10 +5787,9 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { let output: () = { { let output: () = <::glam::IVec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6006,11 +5803,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::IVec3::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -6024,11 +5820,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::IVec3::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -6045,13 +5840,12 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -6064,11 +5858,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Ref<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::IVec3 = <::glam::IVec3 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6081,12 +5874,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::IVec3::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::IVec3::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -6099,12 +5891,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::IVec3::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::IVec3::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -6117,12 +5908,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::IVec3::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::IVec3::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -6135,12 +5925,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::IVec3::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::IVec3::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -6153,12 +5942,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::IVec3::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::IVec3::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -6171,12 +5959,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::IVec3::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::IVec3::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -6189,12 +5976,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::cross( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::cross( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -6208,11 +5994,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { let output: i32 = { { let output: i32 = ::glam::IVec3::distance_squared( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -6225,11 +6010,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Ref<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Div< + let output: ::glam::IVec3 = <::glam::IVec3 as ::core::ops::Div< &::glam::IVec3, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -6242,11 +6026,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Div< + let output: ::glam::IVec3 = <::glam::IVec3 as ::core::ops::Div< ::glam::IVec3, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -6259,11 +6042,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: i32| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Div< + let output: ::glam::IVec3 = <::glam::IVec3 as ::core::ops::Div< i32, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -6276,12 +6058,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::div_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::div_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -6295,11 +6076,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { let output: i32 = { { let output: i32 = ::glam::IVec3::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -6312,12 +6092,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -6331,10 +6110,9 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { let output: i32 = { { let output: i32 = ::glam::IVec3::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6347,9 +6125,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>| { let output: i32 = { { - let output: i32 = ::glam::IVec3::element_sum(_self.into_inner()) - .into(); - output + let output: i32 = ::glam::IVec3::element_sum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6364,9 +6143,8 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { { let output: bool = <::glam::IVec3 as ::core::cmp::PartialEq< ::glam::IVec3, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -6379,12 +6157,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, w: i32| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec3::extend( - _self.into_inner(), - w, - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec3::extend( + safe_transmute(_self), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -6397,9 +6174,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |a: [i32; 3]| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::from_array(a) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -6413,10 +6191,9 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::IVec3::is_negative_bitmask( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6430,10 +6207,9 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { let output: i32 = { { let output: i32 = ::glam::IVec3::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6447,11 +6223,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::IVec3::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -6464,12 +6239,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -6482,9 +6256,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>| { let output: i32 = { { - let output: i32 = ::glam::IVec3::max_element(_self.into_inner()) - .into(); - output + let output: i32 = ::glam::IVec3::max_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6498,10 +6273,9 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::IVec3::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6514,12 +6288,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -6532,9 +6305,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>| { let output: i32 = { { - let output: i32 = ::glam::IVec3::min_element(_self.into_inner()) - .into(); - output + let output: i32 = ::glam::IVec3::min_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6548,10 +6322,9 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::IVec3::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6564,11 +6337,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Ref<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Mul< + let output: ::glam::IVec3 = <::glam::IVec3 as ::core::ops::Mul< &::glam::IVec3, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -6581,11 +6353,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Mul< + let output: ::glam::IVec3 = <::glam::IVec3 as ::core::ops::Mul< ::glam::IVec3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -6598,11 +6369,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: i32| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Mul< + let output: ::glam::IVec3 = <::glam::IVec3 as ::core::ops::Mul< i32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -6615,11 +6385,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = <::glam::IVec3 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6632,9 +6401,12 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |x: i32, y: i32, z: i32| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::new(x, y, z) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -6647,11 +6419,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Ref<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Rem< + let output: ::glam::IVec3 = <::glam::IVec3 as ::core::ops::Rem< &::glam::IVec3, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -6664,11 +6435,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Rem< + let output: ::glam::IVec3 = <::glam::IVec3 as ::core::ops::Rem< ::glam::IVec3, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -6681,11 +6451,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: i32| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Rem< + let output: ::glam::IVec3 = <::glam::IVec3 as ::core::ops::Rem< i32, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -6698,12 +6467,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::rem_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::rem_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -6716,12 +6484,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -6734,12 +6501,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::saturating_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::saturating_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -6752,12 +6518,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -6770,12 +6535,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -6788,12 +6552,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -6806,12 +6569,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::saturating_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::saturating_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -6828,13 +6590,12 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -6847,11 +6608,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::signum( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::signum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6864,8 +6624,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |v: i32| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::splat(v).into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -6878,11 +6640,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Ref<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Sub< + let output: ::glam::IVec3 = <::glam::IVec3 as ::core::ops::Sub< &::glam::IVec3, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -6895,11 +6656,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Sub< + let output: ::glam::IVec3 = <::glam::IVec3 as ::core::ops::Sub< ::glam::IVec3, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -6912,11 +6672,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: i32| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Sub< + let output: ::glam::IVec3 = <::glam::IVec3 as ::core::ops::Sub< i32, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -6929,8 +6688,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Ref<::glam::IVec3>| { let output: [i32; 3] = { { - let output: [i32; 3] = ::glam::IVec3::to_array(&_self).into(); - output + let output: [i32; 3] = ::glam::IVec3::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6943,11 +6704,10 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::IVec3::truncate( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::IVec3::truncate( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6960,12 +6720,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, x: i32| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -6978,12 +6737,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, y: i32| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -6996,12 +6754,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, z: i32| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::with_z( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::with_z( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -7014,12 +6771,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -7032,12 +6788,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::wrapping_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::wrapping_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -7050,12 +6805,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -7068,12 +6822,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -7086,12 +6839,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -7104,12 +6856,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { |_self: Val<::glam::IVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec3::wrapping_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec3::wrapping_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -7119,7 +6870,11 @@ pub(crate) fn register_i_vec_3_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::IVec3, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::IVec3, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_i_vec_4_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -7130,11 +6885,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::abs( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7147,11 +6901,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Ref<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Add< + let output: ::glam::IVec4 = <::glam::IVec4 as ::core::ops::Add< &::glam::IVec4, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -7164,11 +6917,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Add< + let output: ::glam::IVec4 = <::glam::IVec4 as ::core::ops::Add< ::glam::IVec4, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -7181,11 +6933,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: i32| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Add< + let output: ::glam::IVec4 = <::glam::IVec4 as ::core::ops::Add< i32, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -7198,9 +6949,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Ref<::glam::IVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::IVec4::as_dvec4(&_self) - .into(); - output + let output: ::glam::DVec4 = ::glam::IVec4::as_dvec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7213,11 +6965,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Ref<::glam::IVec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::IVec4::as_i16vec4( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::IVec4::as_i16vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7230,11 +6981,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Ref<::glam::IVec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::IVec4::as_i64vec4( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::IVec4::as_i64vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7247,11 +6997,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Ref<::glam::IVec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::IVec4::as_i8vec4( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::IVec4::as_i8vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7264,11 +7013,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Ref<::glam::IVec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::IVec4::as_u16vec4( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::IVec4::as_u16vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7281,11 +7029,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Ref<::glam::IVec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::IVec4::as_u64vec4( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::IVec4::as_u64vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7298,11 +7045,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Ref<::glam::IVec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::IVec4::as_u8vec4( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::IVec4::as_u8vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7315,9 +7061,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Ref<::glam::IVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::IVec4::as_uvec4(&_self) - .into(); - output + let output: ::glam::UVec4 = ::glam::IVec4::as_uvec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7330,9 +7077,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Ref<::glam::IVec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::IVec4::as_vec4(&_self) - .into(); - output + let output: ::glam::Vec4 = ::glam::IVec4::as_vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7346,10 +7094,9 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { let output: () = { { let output: () = <::glam::IVec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7363,11 +7110,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::IVec4::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -7381,11 +7127,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::IVec4::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -7402,13 +7147,12 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -7421,11 +7165,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Ref<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::IVec4 = <::glam::IVec4 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7438,12 +7181,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::IVec4::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::IVec4::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -7456,12 +7198,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::IVec4::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::IVec4::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -7474,12 +7215,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::IVec4::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::IVec4::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -7492,12 +7232,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::IVec4::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::IVec4::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -7510,12 +7249,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::IVec4::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::IVec4::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -7528,12 +7266,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::IVec4::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::IVec4::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -7547,11 +7284,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { let output: i32 = { { let output: i32 = ::glam::IVec4::distance_squared( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -7564,11 +7300,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Ref<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Div< + let output: ::glam::IVec4 = <::glam::IVec4 as ::core::ops::Div< &::glam::IVec4, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -7581,11 +7316,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Div< + let output: ::glam::IVec4 = <::glam::IVec4 as ::core::ops::Div< ::glam::IVec4, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -7598,11 +7332,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: i32| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Div< + let output: ::glam::IVec4 = <::glam::IVec4 as ::core::ops::Div< i32, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -7615,12 +7348,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::div_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::div_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -7634,11 +7366,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { let output: i32 = { { let output: i32 = ::glam::IVec4::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -7651,12 +7382,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -7670,10 +7400,9 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { let output: i32 = { { let output: i32 = ::glam::IVec4::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7686,9 +7415,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>| { let output: i32 = { { - let output: i32 = ::glam::IVec4::element_sum(_self.into_inner()) - .into(); - output + let output: i32 = ::glam::IVec4::element_sum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7703,9 +7433,8 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { { let output: bool = <::glam::IVec4 as ::core::cmp::PartialEq< ::glam::IVec4, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -7718,9 +7447,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |a: [i32; 4]| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::from_array(a) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -7734,10 +7464,9 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::IVec4::is_negative_bitmask( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7751,10 +7480,9 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { let output: i32 = { { let output: i32 = ::glam::IVec4::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7768,11 +7496,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::IVec4::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -7785,12 +7512,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -7803,9 +7529,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>| { let output: i32 = { { - let output: i32 = ::glam::IVec4::max_element(_self.into_inner()) - .into(); - output + let output: i32 = ::glam::IVec4::max_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7819,10 +7546,9 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::IVec4::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7835,12 +7561,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -7853,9 +7578,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>| { let output: i32 = { { - let output: i32 = ::glam::IVec4::min_element(_self.into_inner()) - .into(); - output + let output: i32 = ::glam::IVec4::min_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7869,10 +7595,9 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::IVec4::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7885,11 +7610,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Ref<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Mul< + let output: ::glam::IVec4 = <::glam::IVec4 as ::core::ops::Mul< &::glam::IVec4, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -7902,11 +7626,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Mul< + let output: ::glam::IVec4 = <::glam::IVec4 as ::core::ops::Mul< ::glam::IVec4, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -7919,11 +7642,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: i32| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Mul< + let output: ::glam::IVec4 = <::glam::IVec4 as ::core::ops::Mul< i32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -7936,11 +7658,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::IVec4 = <::glam::IVec4 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -7953,9 +7674,13 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |x: i32, y: i32, z: i32, w: i32| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::new(x, y, z, w) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -7968,11 +7693,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Ref<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Rem< + let output: ::glam::IVec4 = <::glam::IVec4 as ::core::ops::Rem< &::glam::IVec4, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -7985,11 +7709,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Rem< + let output: ::glam::IVec4 = <::glam::IVec4 as ::core::ops::Rem< ::glam::IVec4, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -8002,11 +7725,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: i32| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Rem< + let output: ::glam::IVec4 = <::glam::IVec4 as ::core::ops::Rem< i32, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -8019,12 +7741,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::rem_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::rem_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8037,12 +7758,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8055,12 +7775,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::saturating_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::saturating_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8073,12 +7792,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8091,12 +7809,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8109,12 +7826,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8127,12 +7843,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::saturating_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::saturating_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8149,13 +7864,12 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -8168,11 +7882,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::signum( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::signum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8185,8 +7898,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |v: i32| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::splat(v).into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -8199,11 +7914,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Ref<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Sub< + let output: ::glam::IVec4 = <::glam::IVec4 as ::core::ops::Sub< &::glam::IVec4, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -8216,11 +7930,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Sub< + let output: ::glam::IVec4 = <::glam::IVec4 as ::core::ops::Sub< ::glam::IVec4, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -8233,11 +7946,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: i32| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Sub< + let output: ::glam::IVec4 = <::glam::IVec4 as ::core::ops::Sub< i32, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -8250,8 +7962,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Ref<::glam::IVec4>| { let output: [i32; 4] = { { - let output: [i32; 4] = ::glam::IVec4::to_array(&_self).into(); - output + let output: [i32; 4] = ::glam::IVec4::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8264,11 +7978,10 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::IVec4::truncate( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::IVec4::truncate( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8281,12 +7994,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, w: i32| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::with_w( - _self.into_inner(), - w, - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::with_w( + safe_transmute(_self), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -8299,12 +8011,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, x: i32| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -8317,12 +8028,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, y: i32| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -8335,12 +8045,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, z: i32| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::with_z( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::with_z( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -8353,12 +8062,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8371,12 +8079,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::wrapping_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::wrapping_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8389,12 +8096,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8407,12 +8113,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8425,12 +8130,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8443,12 +8147,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { |_self: Val<::glam::IVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::IVec4::wrapping_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::IVec4::wrapping_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8458,7 +8161,11 @@ pub(crate) fn register_i_vec_4_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::IVec4, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::IVec4, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -8469,11 +8176,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::abs( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8486,11 +8192,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Ref<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Add< + let output: ::glam::I8Vec2 = <::glam::I8Vec2 as ::core::ops::Add< &::glam::I8Vec2, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -8503,11 +8208,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Add< + let output: ::glam::I8Vec2 = <::glam::I8Vec2 as ::core::ops::Add< ::glam::I8Vec2, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -8520,11 +8224,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: i8| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Add< + let output: ::glam::I8Vec2 = <::glam::I8Vec2 as ::core::ops::Add< i8, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -8537,9 +8240,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I8Vec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::I8Vec2::as_dvec2(&_self) - .into(); - output + let output: ::glam::DVec2 = ::glam::I8Vec2::as_dvec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8552,11 +8256,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I8Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I8Vec2::as_i16vec2( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I8Vec2::as_i16vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8569,11 +8272,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I8Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I8Vec2::as_i64vec2( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I8Vec2::as_i64vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8586,9 +8288,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I8Vec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::I8Vec2::as_ivec2(&_self) - .into(); - output + let output: ::glam::IVec2 = ::glam::I8Vec2::as_ivec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8601,11 +8304,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I8Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::I8Vec2::as_u16vec2( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::I8Vec2::as_u16vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8618,11 +8320,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I8Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::I8Vec2::as_u64vec2( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::I8Vec2::as_u64vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8635,11 +8336,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::I8Vec2::as_u8vec2( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::I8Vec2::as_u8vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8652,9 +8352,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I8Vec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::I8Vec2::as_uvec2(&_self) - .into(); - output + let output: ::glam::UVec2 = ::glam::I8Vec2::as_uvec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8667,9 +8368,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I8Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::I8Vec2::as_vec2(&_self) - .into(); - output + let output: ::glam::Vec2 = ::glam::I8Vec2::as_vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8683,10 +8385,9 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { let output: () = { { let output: () = <::glam::I8Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8700,11 +8401,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { let output: u8 = { { let output: u8 = ::glam::I8Vec2::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8718,11 +8418,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::I8Vec2::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8739,13 +8438,12 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -8758,11 +8456,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec2 = <::glam::I8Vec2 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -8775,12 +8472,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::I8Vec2::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::I8Vec2::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8793,12 +8489,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::I8Vec2::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::I8Vec2::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8811,12 +8506,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::I8Vec2::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::I8Vec2::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8829,12 +8523,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::I8Vec2::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::I8Vec2::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8847,12 +8540,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::I8Vec2::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::I8Vec2::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8865,12 +8557,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::I8Vec2::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::I8Vec2::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8884,11 +8575,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { let output: i8 = { { let output: i8 = ::glam::I8Vec2::distance_squared( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8901,11 +8591,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Ref<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Div< + let output: ::glam::I8Vec2 = <::glam::I8Vec2 as ::core::ops::Div< &::glam::I8Vec2, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -8918,11 +8607,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Div< + let output: ::glam::I8Vec2 = <::glam::I8Vec2 as ::core::ops::Div< ::glam::I8Vec2, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -8935,11 +8623,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: i8| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Div< + let output: ::glam::I8Vec2 = <::glam::I8Vec2 as ::core::ops::Div< i8, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -8952,12 +8639,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::div_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::div_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8971,11 +8657,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { let output: i8 = { { let output: i8 = ::glam::I8Vec2::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -8988,12 +8673,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -9007,10 +8691,9 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { let output: i8 = { { let output: i8 = ::glam::I8Vec2::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9023,9 +8706,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>| { let output: i8 = { { - let output: i8 = ::glam::I8Vec2::element_sum(_self.into_inner()) - .into(); - output + let output: i8 = ::glam::I8Vec2::element_sum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9040,9 +8724,8 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { { let output: bool = <::glam::I8Vec2 as ::core::cmp::PartialEq< ::glam::I8Vec2, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -9055,12 +8738,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, z: i8| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec2::extend( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec2::extend( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -9073,9 +8755,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |a: [i8; 2]| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::from_array(a) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -9089,10 +8772,9 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::I8Vec2::is_negative_bitmask( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9106,10 +8788,9 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { let output: i8 = { { let output: i8 = ::glam::I8Vec2::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9123,11 +8804,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { let output: u8 = { { let output: u8 = ::glam::I8Vec2::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -9140,12 +8820,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -9158,9 +8837,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>| { let output: i8 = { { - let output: i8 = ::glam::I8Vec2::max_element(_self.into_inner()) - .into(); - output + let output: i8 = ::glam::I8Vec2::max_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9174,10 +8854,9 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::I8Vec2::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9190,12 +8869,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -9208,9 +8886,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>| { let output: i8 = { { - let output: i8 = ::glam::I8Vec2::min_element(_self.into_inner()) - .into(); - output + let output: i8 = ::glam::I8Vec2::min_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9224,10 +8903,9 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::I8Vec2::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9240,11 +8918,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Ref<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Mul< + let output: ::glam::I8Vec2 = <::glam::I8Vec2 as ::core::ops::Mul< &::glam::I8Vec2, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -9257,11 +8934,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Mul< + let output: ::glam::I8Vec2 = <::glam::I8Vec2 as ::core::ops::Mul< ::glam::I8Vec2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -9274,11 +8950,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: i8| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Mul< + let output: ::glam::I8Vec2 = <::glam::I8Vec2 as ::core::ops::Mul< i8, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -9291,11 +8966,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = <::glam::I8Vec2 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9308,9 +8982,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |x: i8, y: i8| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::new(x, y) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::new( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -9323,11 +8999,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::perp( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::perp( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9341,11 +9016,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { let output: i8 = { { let output: i8 = ::glam::I8Vec2::perp_dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -9358,11 +9032,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Ref<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Rem< + let output: ::glam::I8Vec2 = <::glam::I8Vec2 as ::core::ops::Rem< &::glam::I8Vec2, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -9375,11 +9048,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Rem< + let output: ::glam::I8Vec2 = <::glam::I8Vec2 as ::core::ops::Rem< ::glam::I8Vec2, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -9392,11 +9064,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: i8| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Rem< + let output: ::glam::I8Vec2 = <::glam::I8Vec2 as ::core::ops::Rem< i8, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -9409,12 +9080,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::rem_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::rem_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -9427,12 +9097,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::rotate( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::rotate( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -9445,12 +9114,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -9463,12 +9131,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::saturating_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::saturating_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -9481,12 +9148,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -9499,12 +9165,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -9517,12 +9182,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -9535,12 +9199,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::saturating_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::saturating_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -9557,13 +9220,12 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -9576,11 +9238,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::signum( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::signum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9593,9 +9254,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |v: i8| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::splat(v) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -9608,11 +9270,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Ref<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Sub< + let output: ::glam::I8Vec2 = <::glam::I8Vec2 as ::core::ops::Sub< &::glam::I8Vec2, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -9625,11 +9286,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Sub< + let output: ::glam::I8Vec2 = <::glam::I8Vec2 as ::core::ops::Sub< ::glam::I8Vec2, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -9642,11 +9302,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: i8| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Sub< + let output: ::glam::I8Vec2 = <::glam::I8Vec2 as ::core::ops::Sub< i8, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -9659,8 +9318,10 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I8Vec2>| { let output: [i8; 2] = { { - let output: [i8; 2] = ::glam::I8Vec2::to_array(&_self).into(); - output + let output: [i8; 2] = ::glam::I8Vec2::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9673,12 +9334,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, x: i8| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -9691,12 +9351,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, y: i8| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -9709,12 +9368,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -9727,12 +9385,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::wrapping_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::wrapping_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -9745,12 +9402,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -9763,12 +9419,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -9781,12 +9436,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -9799,12 +9453,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::I8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::wrapping_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec2::wrapping_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -9814,7 +9467,11 @@ pub(crate) fn register_i_8_vec_2_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::I8Vec2, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::I8Vec2, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -9825,11 +9482,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::abs( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9842,11 +9498,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Ref<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Add< + let output: ::glam::I8Vec3 = <::glam::I8Vec3 as ::core::ops::Add< &::glam::I8Vec3, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -9859,11 +9514,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Add< + let output: ::glam::I8Vec3 = <::glam::I8Vec3 as ::core::ops::Add< ::glam::I8Vec3, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -9876,11 +9530,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: i8| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Add< + let output: ::glam::I8Vec3 = <::glam::I8Vec3 as ::core::ops::Add< i8, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -9893,9 +9546,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I8Vec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::I8Vec3::as_dvec3(&_self) - .into(); - output + let output: ::glam::DVec3 = ::glam::I8Vec3::as_dvec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9908,11 +9562,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I8Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I8Vec3::as_i16vec3( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I8Vec3::as_i16vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9925,11 +9578,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I8Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I8Vec3::as_i64vec3( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I8Vec3::as_i64vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9942,9 +9594,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I8Vec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::I8Vec3::as_ivec3(&_self) - .into(); - output + let output: ::glam::IVec3 = ::glam::I8Vec3::as_ivec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9957,11 +9610,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I8Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::I8Vec3::as_u16vec3( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::I8Vec3::as_u16vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9974,11 +9626,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I8Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::I8Vec3::as_u64vec3( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::I8Vec3::as_u64vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -9991,11 +9642,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::I8Vec3::as_u8vec3( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::I8Vec3::as_u8vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -10008,9 +9658,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I8Vec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::I8Vec3::as_uvec3(&_self) - .into(); - output + let output: ::glam::UVec3 = ::glam::I8Vec3::as_uvec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -10023,9 +9674,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I8Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::I8Vec3::as_vec3(&_self) - .into(); - output + let output: ::glam::Vec3 = ::glam::I8Vec3::as_vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -10038,9 +9690,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I8Vec3>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::I8Vec3::as_vec3a(&_self) - .into(); - output + let output: ::glam::Vec3A = ::glam::I8Vec3::as_vec3a( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -10054,10 +9707,9 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { let output: () = { { let output: () = <::glam::I8Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -10071,11 +9723,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { let output: u8 = { { let output: u8 = ::glam::I8Vec3::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -10089,11 +9740,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::I8Vec3::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -10110,13 +9760,12 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -10129,11 +9778,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec3 = <::glam::I8Vec3 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -10146,12 +9794,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::I8Vec3::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::I8Vec3::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -10164,12 +9811,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::I8Vec3::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::I8Vec3::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -10182,12 +9828,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::I8Vec3::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::I8Vec3::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -10200,12 +9845,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::I8Vec3::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::I8Vec3::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -10218,12 +9862,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::I8Vec3::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::I8Vec3::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -10236,12 +9879,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::I8Vec3::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::I8Vec3::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -10254,12 +9896,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::cross( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::cross( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -10273,11 +9914,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { let output: i8 = { { let output: i8 = ::glam::I8Vec3::distance_squared( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -10290,11 +9930,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Ref<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Div< + let output: ::glam::I8Vec3 = <::glam::I8Vec3 as ::core::ops::Div< &::glam::I8Vec3, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -10307,11 +9946,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Div< + let output: ::glam::I8Vec3 = <::glam::I8Vec3 as ::core::ops::Div< ::glam::I8Vec3, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -10324,11 +9962,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: i8| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Div< + let output: ::glam::I8Vec3 = <::glam::I8Vec3 as ::core::ops::Div< i8, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -10341,12 +9978,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::div_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::div_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -10360,11 +9996,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { let output: i8 = { { let output: i8 = ::glam::I8Vec3::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -10377,12 +10012,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -10396,10 +10030,9 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { let output: i8 = { { let output: i8 = ::glam::I8Vec3::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -10412,9 +10045,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>| { let output: i8 = { { - let output: i8 = ::glam::I8Vec3::element_sum(_self.into_inner()) - .into(); - output + let output: i8 = ::glam::I8Vec3::element_sum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -10429,9 +10063,8 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { { let output: bool = <::glam::I8Vec3 as ::core::cmp::PartialEq< ::glam::I8Vec3, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -10444,12 +10077,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, w: i8| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec3::extend( - _self.into_inner(), - w, - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec3::extend( + safe_transmute(_self), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -10462,9 +10094,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |a: [i8; 3]| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::from_array(a) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -10478,10 +10111,9 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::I8Vec3::is_negative_bitmask( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -10495,10 +10127,9 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { let output: i8 = { { let output: i8 = ::glam::I8Vec3::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -10512,11 +10143,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { let output: u8 = { { let output: u8 = ::glam::I8Vec3::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -10529,12 +10159,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -10547,9 +10176,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>| { let output: i8 = { { - let output: i8 = ::glam::I8Vec3::max_element(_self.into_inner()) - .into(); - output + let output: i8 = ::glam::I8Vec3::max_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -10563,10 +10193,9 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::I8Vec3::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -10579,12 +10208,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -10597,9 +10225,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>| { let output: i8 = { { - let output: i8 = ::glam::I8Vec3::min_element(_self.into_inner()) - .into(); - output + let output: i8 = ::glam::I8Vec3::min_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -10613,10 +10242,9 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::I8Vec3::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -10629,11 +10257,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Ref<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Mul< + let output: ::glam::I8Vec3 = <::glam::I8Vec3 as ::core::ops::Mul< &::glam::I8Vec3, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -10646,11 +10273,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Mul< + let output: ::glam::I8Vec3 = <::glam::I8Vec3 as ::core::ops::Mul< ::glam::I8Vec3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -10663,11 +10289,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: i8| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Mul< + let output: ::glam::I8Vec3 = <::glam::I8Vec3 as ::core::ops::Mul< i8, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -10680,11 +10305,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = <::glam::I8Vec3 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -10697,9 +10321,12 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |x: i8, y: i8, z: i8| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::new(x, y, z) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -10712,11 +10339,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Ref<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Rem< + let output: ::glam::I8Vec3 = <::glam::I8Vec3 as ::core::ops::Rem< &::glam::I8Vec3, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -10729,11 +10355,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Rem< + let output: ::glam::I8Vec3 = <::glam::I8Vec3 as ::core::ops::Rem< ::glam::I8Vec3, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -10746,11 +10371,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: i8| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Rem< + let output: ::glam::I8Vec3 = <::glam::I8Vec3 as ::core::ops::Rem< i8, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -10763,12 +10387,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::rem_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::rem_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -10781,12 +10404,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -10799,12 +10421,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::saturating_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::saturating_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -10817,12 +10438,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -10835,12 +10455,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -10853,12 +10472,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -10871,12 +10489,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::saturating_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::saturating_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -10893,13 +10510,12 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -10912,11 +10528,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::signum( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::signum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -10929,9 +10544,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |v: i8| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::splat(v) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -10944,11 +10560,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Ref<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Sub< + let output: ::glam::I8Vec3 = <::glam::I8Vec3 as ::core::ops::Sub< &::glam::I8Vec3, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -10961,11 +10576,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Sub< + let output: ::glam::I8Vec3 = <::glam::I8Vec3 as ::core::ops::Sub< ::glam::I8Vec3, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -10978,11 +10592,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: i8| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Sub< + let output: ::glam::I8Vec3 = <::glam::I8Vec3 as ::core::ops::Sub< i8, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -10995,8 +10608,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I8Vec3>| { let output: [i8; 3] = { { - let output: [i8; 3] = ::glam::I8Vec3::to_array(&_self).into(); - output + let output: [i8; 3] = ::glam::I8Vec3::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -11009,11 +10624,10 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I8Vec3::truncate( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I8Vec3::truncate( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -11026,12 +10640,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, x: i8| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -11044,12 +10657,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, y: i8| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -11062,12 +10674,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, z: i8| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::with_z( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::with_z( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -11080,12 +10691,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -11098,12 +10708,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::wrapping_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::wrapping_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -11116,12 +10725,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -11134,12 +10742,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -11152,12 +10759,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -11170,12 +10776,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::I8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::wrapping_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec3::wrapping_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -11185,7 +10790,11 @@ pub(crate) fn register_i_8_vec_3_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::I8Vec3, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::I8Vec3, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -11196,11 +10805,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::abs( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -11213,11 +10821,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Ref<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Add< + let output: ::glam::I8Vec4 = <::glam::I8Vec4 as ::core::ops::Add< &::glam::I8Vec4, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -11230,11 +10837,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Add< + let output: ::glam::I8Vec4 = <::glam::I8Vec4 as ::core::ops::Add< ::glam::I8Vec4, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -11247,11 +10853,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: i8| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Add< + let output: ::glam::I8Vec4 = <::glam::I8Vec4 as ::core::ops::Add< i8, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -11264,9 +10869,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I8Vec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::I8Vec4::as_dvec4(&_self) - .into(); - output + let output: ::glam::DVec4 = ::glam::I8Vec4::as_dvec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -11279,11 +10885,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I8Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I8Vec4::as_i16vec4( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I8Vec4::as_i16vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -11296,11 +10901,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I8Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I8Vec4::as_i64vec4( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I8Vec4::as_i64vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -11313,9 +10917,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I8Vec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::I8Vec4::as_ivec4(&_self) - .into(); - output + let output: ::glam::IVec4 = ::glam::I8Vec4::as_ivec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -11328,11 +10933,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I8Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::I8Vec4::as_u16vec4( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::I8Vec4::as_u16vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -11345,11 +10949,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I8Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::I8Vec4::as_u64vec4( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::I8Vec4::as_u64vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -11362,11 +10965,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::I8Vec4::as_u8vec4( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::I8Vec4::as_u8vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -11379,9 +10981,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I8Vec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::I8Vec4::as_uvec4(&_self) - .into(); - output + let output: ::glam::UVec4 = ::glam::I8Vec4::as_uvec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -11394,9 +10997,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I8Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::I8Vec4::as_vec4(&_self) - .into(); - output + let output: ::glam::Vec4 = ::glam::I8Vec4::as_vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -11410,10 +11014,9 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { let output: () = { { let output: () = <::glam::I8Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -11427,11 +11030,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { let output: u8 = { { let output: u8 = ::glam::I8Vec4::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -11445,11 +11047,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::I8Vec4::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -11466,13 +11067,12 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -11485,11 +11085,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec4 = <::glam::I8Vec4 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -11502,12 +11101,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::I8Vec4::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::I8Vec4::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -11520,12 +11118,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::I8Vec4::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::I8Vec4::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -11538,12 +11135,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::I8Vec4::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::I8Vec4::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -11556,12 +11152,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::I8Vec4::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::I8Vec4::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -11574,12 +11169,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::I8Vec4::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::I8Vec4::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -11592,12 +11186,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::I8Vec4::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::I8Vec4::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -11611,11 +11204,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { let output: i8 = { { let output: i8 = ::glam::I8Vec4::distance_squared( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -11628,11 +11220,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Ref<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Div< + let output: ::glam::I8Vec4 = <::glam::I8Vec4 as ::core::ops::Div< &::glam::I8Vec4, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -11645,11 +11236,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Div< + let output: ::glam::I8Vec4 = <::glam::I8Vec4 as ::core::ops::Div< ::glam::I8Vec4, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -11662,11 +11252,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: i8| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Div< + let output: ::glam::I8Vec4 = <::glam::I8Vec4 as ::core::ops::Div< i8, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -11679,12 +11268,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::div_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::div_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -11698,11 +11286,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { let output: i8 = { { let output: i8 = ::glam::I8Vec4::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -11715,12 +11302,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -11734,10 +11320,9 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { let output: i8 = { { let output: i8 = ::glam::I8Vec4::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -11750,9 +11335,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>| { let output: i8 = { { - let output: i8 = ::glam::I8Vec4::element_sum(_self.into_inner()) - .into(); - output + let output: i8 = ::glam::I8Vec4::element_sum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -11767,9 +11353,8 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { { let output: bool = <::glam::I8Vec4 as ::core::cmp::PartialEq< ::glam::I8Vec4, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -11782,9 +11367,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |a: [i8; 4]| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::from_array(a) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -11798,10 +11384,9 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::I8Vec4::is_negative_bitmask( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -11815,10 +11400,9 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { let output: i8 = { { let output: i8 = ::glam::I8Vec4::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -11832,11 +11416,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { let output: u8 = { { let output: u8 = ::glam::I8Vec4::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -11849,12 +11432,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -11867,9 +11449,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>| { let output: i8 = { { - let output: i8 = ::glam::I8Vec4::max_element(_self.into_inner()) - .into(); - output + let output: i8 = ::glam::I8Vec4::max_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -11883,10 +11466,9 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::I8Vec4::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -11899,12 +11481,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -11917,9 +11498,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>| { let output: i8 = { { - let output: i8 = ::glam::I8Vec4::min_element(_self.into_inner()) - .into(); - output + let output: i8 = ::glam::I8Vec4::min_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -11933,10 +11515,9 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::I8Vec4::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -11949,11 +11530,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Ref<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Mul< + let output: ::glam::I8Vec4 = <::glam::I8Vec4 as ::core::ops::Mul< &::glam::I8Vec4, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -11966,11 +11546,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Mul< + let output: ::glam::I8Vec4 = <::glam::I8Vec4 as ::core::ops::Mul< ::glam::I8Vec4, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -11983,11 +11562,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: i8| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Mul< + let output: ::glam::I8Vec4 = <::glam::I8Vec4 as ::core::ops::Mul< i8, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -12000,11 +11578,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec4 = <::glam::I8Vec4 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -12017,9 +11594,13 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |x: i8, y: i8, z: i8, w: i8| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::new(x, y, z, w) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -12032,11 +11613,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Ref<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Rem< + let output: ::glam::I8Vec4 = <::glam::I8Vec4 as ::core::ops::Rem< &::glam::I8Vec4, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -12049,11 +11629,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Rem< + let output: ::glam::I8Vec4 = <::glam::I8Vec4 as ::core::ops::Rem< ::glam::I8Vec4, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -12066,11 +11645,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: i8| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Rem< + let output: ::glam::I8Vec4 = <::glam::I8Vec4 as ::core::ops::Rem< i8, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -12083,12 +11661,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::rem_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::rem_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -12101,12 +11678,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -12119,12 +11695,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::saturating_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::saturating_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -12137,12 +11712,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -12155,12 +11729,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -12173,12 +11746,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -12191,12 +11763,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::saturating_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::saturating_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -12213,13 +11784,12 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -12232,11 +11802,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::signum( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::signum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -12249,9 +11818,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |v: i8| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::splat(v) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -12264,11 +11834,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Ref<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Sub< + let output: ::glam::I8Vec4 = <::glam::I8Vec4 as ::core::ops::Sub< &::glam::I8Vec4, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -12281,11 +11850,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Sub< + let output: ::glam::I8Vec4 = <::glam::I8Vec4 as ::core::ops::Sub< ::glam::I8Vec4, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -12298,11 +11866,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: i8| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Sub< + let output: ::glam::I8Vec4 = <::glam::I8Vec4 as ::core::ops::Sub< i8, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -12315,8 +11882,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I8Vec4>| { let output: [i8; 4] = { { - let output: [i8; 4] = ::glam::I8Vec4::to_array(&_self).into(); - output + let output: [i8; 4] = ::glam::I8Vec4::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -12329,11 +11898,10 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I8Vec4::truncate( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I8Vec4::truncate( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -12346,12 +11914,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, w: i8| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::with_w( - _self.into_inner(), - w, - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::with_w( + safe_transmute(_self), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -12364,12 +11931,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, x: i8| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -12382,12 +11948,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, y: i8| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -12400,12 +11965,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, z: i8| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::with_z( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::with_z( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -12418,12 +11982,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -12436,12 +11999,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::wrapping_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::wrapping_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -12454,12 +12016,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -12472,12 +12033,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -12490,12 +12050,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -12508,12 +12067,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::I8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::wrapping_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I8Vec4::wrapping_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -12523,7 +12081,11 @@ pub(crate) fn register_i_8_vec_4_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::I8Vec4, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::I8Vec4, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -12534,11 +12096,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::abs( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -12551,11 +12112,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Ref<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Add< + let output: ::glam::I16Vec2 = <::glam::I16Vec2 as ::core::ops::Add< &::glam::I16Vec2, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -12568,11 +12128,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Add< + let output: ::glam::I16Vec2 = <::glam::I16Vec2 as ::core::ops::Add< ::glam::I16Vec2, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -12585,11 +12144,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: i16| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Add< + let output: ::glam::I16Vec2 = <::glam::I16Vec2 as ::core::ops::Add< i16, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -12602,11 +12160,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I16Vec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::I16Vec2::as_dvec2( - &_self, - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::I16Vec2::as_dvec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -12619,11 +12176,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I16Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I16Vec2::as_i64vec2( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I16Vec2::as_i64vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -12636,11 +12192,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I16Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I16Vec2::as_i8vec2( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I16Vec2::as_i8vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -12653,11 +12208,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I16Vec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::I16Vec2::as_ivec2( - &_self, - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::I16Vec2::as_ivec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -12670,11 +12224,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::I16Vec2::as_u16vec2( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::I16Vec2::as_u16vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -12687,11 +12240,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I16Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::I16Vec2::as_u64vec2( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::I16Vec2::as_u64vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -12704,11 +12256,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I16Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::I16Vec2::as_u8vec2( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::I16Vec2::as_u8vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -12721,11 +12272,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I16Vec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::I16Vec2::as_uvec2( - &_self, - ) - .into(); - output + let output: ::glam::UVec2 = ::glam::I16Vec2::as_uvec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -12738,9 +12288,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I16Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::I16Vec2::as_vec2(&_self) - .into(); - output + let output: ::glam::Vec2 = ::glam::I16Vec2::as_vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -12754,10 +12305,9 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { let output: () = { { let output: () = <::glam::I16Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -12771,11 +12321,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::I16Vec2::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -12789,11 +12338,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::I16Vec2::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -12810,13 +12358,12 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -12829,11 +12376,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec2 = <::glam::I16Vec2 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -12846,12 +12392,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::I16Vec2::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::I16Vec2::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -12864,12 +12409,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::I16Vec2::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::I16Vec2::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -12882,12 +12426,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::I16Vec2::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::I16Vec2::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -12900,12 +12443,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::I16Vec2::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::I16Vec2::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -12918,12 +12460,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::I16Vec2::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::I16Vec2::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -12936,12 +12477,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::I16Vec2::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::I16Vec2::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -12955,11 +12495,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { let output: i16 = { { let output: i16 = ::glam::I16Vec2::distance_squared( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -12972,11 +12511,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Ref<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Div< + let output: ::glam::I16Vec2 = <::glam::I16Vec2 as ::core::ops::Div< &::glam::I16Vec2, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -12989,11 +12527,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Div< + let output: ::glam::I16Vec2 = <::glam::I16Vec2 as ::core::ops::Div< ::glam::I16Vec2, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -13006,11 +12543,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: i16| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Div< + let output: ::glam::I16Vec2 = <::glam::I16Vec2 as ::core::ops::Div< i16, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -13023,12 +12559,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::div_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::div_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -13042,11 +12577,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { let output: i16 = { { let output: i16 = ::glam::I16Vec2::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -13059,12 +12593,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -13078,10 +12611,9 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { let output: i16 = { { let output: i16 = ::glam::I16Vec2::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -13095,10 +12627,9 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { let output: i16 = { { let output: i16 = ::glam::I16Vec2::element_sum( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -13113,9 +12644,8 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { { let output: bool = <::glam::I16Vec2 as ::core::cmp::PartialEq< ::glam::I16Vec2, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -13128,12 +12658,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, z: i16| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec2::extend( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec2::extend( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -13146,9 +12675,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |a: [i16; 2]| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::from_array(a) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -13162,10 +12692,9 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::I16Vec2::is_negative_bitmask( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -13179,10 +12708,9 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { let output: i16 = { { let output: i16 = ::glam::I16Vec2::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -13196,11 +12724,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::I16Vec2::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -13213,12 +12740,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -13232,10 +12758,9 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { let output: i16 = { { let output: i16 = ::glam::I16Vec2::max_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -13249,10 +12774,9 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::I16Vec2::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -13265,12 +12789,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -13284,10 +12807,9 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { let output: i16 = { { let output: i16 = ::glam::I16Vec2::min_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -13301,10 +12823,9 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::I16Vec2::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -13317,11 +12838,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Ref<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Mul< + let output: ::glam::I16Vec2 = <::glam::I16Vec2 as ::core::ops::Mul< &::glam::I16Vec2, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -13334,11 +12854,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Mul< + let output: ::glam::I16Vec2 = <::glam::I16Vec2 as ::core::ops::Mul< ::glam::I16Vec2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -13351,11 +12870,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: i16| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Mul< + let output: ::glam::I16Vec2 = <::glam::I16Vec2 as ::core::ops::Mul< i16, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -13368,11 +12886,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = <::glam::I16Vec2 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -13385,9 +12902,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |x: i16, y: i16| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::new(x, y) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::new( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -13400,11 +12919,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::perp( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::perp( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -13418,11 +12936,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { let output: i16 = { { let output: i16 = ::glam::I16Vec2::perp_dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -13435,11 +12952,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Ref<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Rem< + let output: ::glam::I16Vec2 = <::glam::I16Vec2 as ::core::ops::Rem< &::glam::I16Vec2, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -13452,11 +12968,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Rem< + let output: ::glam::I16Vec2 = <::glam::I16Vec2 as ::core::ops::Rem< ::glam::I16Vec2, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -13469,11 +12984,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: i16| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Rem< + let output: ::glam::I16Vec2 = <::glam::I16Vec2 as ::core::ops::Rem< i16, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -13486,12 +13000,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::rem_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::rem_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -13504,12 +13017,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::rotate( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::rotate( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -13522,12 +13034,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -13540,12 +13051,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::saturating_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::saturating_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -13558,12 +13068,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -13576,12 +13085,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -13594,12 +13102,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -13612,12 +13119,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::saturating_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::saturating_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -13634,13 +13140,12 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -13653,11 +13158,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::signum( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::signum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -13670,9 +13174,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |v: i16| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::splat(v) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -13685,11 +13190,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Ref<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Sub< + let output: ::glam::I16Vec2 = <::glam::I16Vec2 as ::core::ops::Sub< &::glam::I16Vec2, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -13702,11 +13206,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Sub< + let output: ::glam::I16Vec2 = <::glam::I16Vec2 as ::core::ops::Sub< ::glam::I16Vec2, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -13719,11 +13222,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: i16| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Sub< + let output: ::glam::I16Vec2 = <::glam::I16Vec2 as ::core::ops::Sub< i16, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -13736,8 +13238,10 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I16Vec2>| { let output: [i16; 2] = { { - let output: [i16; 2] = ::glam::I16Vec2::to_array(&_self).into(); - output + let output: [i16; 2] = ::glam::I16Vec2::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -13750,12 +13254,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, x: i16| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -13768,12 +13271,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, y: i16| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -13786,12 +13288,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -13804,12 +13305,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::wrapping_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::wrapping_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -13822,12 +13322,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -13840,12 +13339,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -13858,12 +13356,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -13876,12 +13373,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::I16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::wrapping_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec2::wrapping_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -13891,7 +13387,11 @@ pub(crate) fn register_i_16_vec_2_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::I16Vec2, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::I16Vec2, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -13902,11 +13402,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::abs( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -13919,11 +13418,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Ref<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Add< + let output: ::glam::I16Vec3 = <::glam::I16Vec3 as ::core::ops::Add< &::glam::I16Vec3, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -13936,11 +13434,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Add< + let output: ::glam::I16Vec3 = <::glam::I16Vec3 as ::core::ops::Add< ::glam::I16Vec3, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -13953,11 +13450,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: i16| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Add< + let output: ::glam::I16Vec3 = <::glam::I16Vec3 as ::core::ops::Add< i16, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -13970,11 +13466,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I16Vec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::I16Vec3::as_dvec3( - &_self, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::I16Vec3::as_dvec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -13987,11 +13482,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I16Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I16Vec3::as_i64vec3( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I16Vec3::as_i64vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -14004,11 +13498,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I16Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I16Vec3::as_i8vec3( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I16Vec3::as_i8vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -14021,11 +13514,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I16Vec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::I16Vec3::as_ivec3( - &_self, - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::I16Vec3::as_ivec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -14038,11 +13530,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::I16Vec3::as_u16vec3( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::I16Vec3::as_u16vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -14055,11 +13546,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I16Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::I16Vec3::as_u64vec3( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::I16Vec3::as_u64vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -14072,11 +13562,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I16Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::I16Vec3::as_u8vec3( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::I16Vec3::as_u8vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -14089,11 +13578,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I16Vec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::I16Vec3::as_uvec3( - &_self, - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::I16Vec3::as_uvec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -14106,9 +13594,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I16Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::I16Vec3::as_vec3(&_self) - .into(); - output + let output: ::glam::Vec3 = ::glam::I16Vec3::as_vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -14121,11 +13610,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I16Vec3>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::I16Vec3::as_vec3a( - &_self, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::I16Vec3::as_vec3a( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -14139,10 +13627,9 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { let output: () = { { let output: () = <::glam::I16Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -14156,11 +13643,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::I16Vec3::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -14174,11 +13660,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::I16Vec3::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -14195,13 +13680,12 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -14214,11 +13698,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec3 = <::glam::I16Vec3 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -14231,12 +13714,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::I16Vec3::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::I16Vec3::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -14249,12 +13731,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::I16Vec3::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::I16Vec3::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -14267,12 +13748,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::I16Vec3::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::I16Vec3::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -14285,12 +13765,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::I16Vec3::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::I16Vec3::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -14303,12 +13782,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::I16Vec3::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::I16Vec3::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -14321,12 +13799,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::I16Vec3::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::I16Vec3::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -14339,12 +13816,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::cross( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::cross( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -14358,11 +13834,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { let output: i16 = { { let output: i16 = ::glam::I16Vec3::distance_squared( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -14375,11 +13850,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Ref<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Div< + let output: ::glam::I16Vec3 = <::glam::I16Vec3 as ::core::ops::Div< &::glam::I16Vec3, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -14392,11 +13866,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Div< + let output: ::glam::I16Vec3 = <::glam::I16Vec3 as ::core::ops::Div< ::glam::I16Vec3, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -14409,11 +13882,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: i16| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Div< + let output: ::glam::I16Vec3 = <::glam::I16Vec3 as ::core::ops::Div< i16, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -14426,12 +13898,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::div_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::div_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -14445,11 +13916,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { let output: i16 = { { let output: i16 = ::glam::I16Vec3::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -14462,12 +13932,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -14481,10 +13950,9 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { let output: i16 = { { let output: i16 = ::glam::I16Vec3::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -14498,10 +13966,9 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { let output: i16 = { { let output: i16 = ::glam::I16Vec3::element_sum( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -14516,9 +13983,8 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { { let output: bool = <::glam::I16Vec3 as ::core::cmp::PartialEq< ::glam::I16Vec3, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -14531,12 +13997,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, w: i16| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec3::extend( - _self.into_inner(), - w, - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec3::extend( + safe_transmute(_self), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -14549,9 +14014,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |a: [i16; 3]| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::from_array(a) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -14565,10 +14031,9 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::I16Vec3::is_negative_bitmask( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -14582,10 +14047,9 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { let output: i16 = { { let output: i16 = ::glam::I16Vec3::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -14599,11 +14063,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::I16Vec3::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -14616,12 +14079,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -14635,10 +14097,9 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { let output: i16 = { { let output: i16 = ::glam::I16Vec3::max_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -14652,10 +14113,9 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::I16Vec3::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -14668,12 +14128,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -14687,10 +14146,9 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { let output: i16 = { { let output: i16 = ::glam::I16Vec3::min_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -14704,10 +14162,9 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::I16Vec3::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -14720,11 +14177,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Ref<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Mul< + let output: ::glam::I16Vec3 = <::glam::I16Vec3 as ::core::ops::Mul< &::glam::I16Vec3, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -14737,11 +14193,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Mul< + let output: ::glam::I16Vec3 = <::glam::I16Vec3 as ::core::ops::Mul< ::glam::I16Vec3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -14754,11 +14209,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: i16| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Mul< + let output: ::glam::I16Vec3 = <::glam::I16Vec3 as ::core::ops::Mul< i16, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -14771,11 +14225,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = <::glam::I16Vec3 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -14788,9 +14241,12 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |x: i16, y: i16, z: i16| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::new(x, y, z) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -14803,11 +14259,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Ref<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Rem< + let output: ::glam::I16Vec3 = <::glam::I16Vec3 as ::core::ops::Rem< &::glam::I16Vec3, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -14820,11 +14275,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Rem< + let output: ::glam::I16Vec3 = <::glam::I16Vec3 as ::core::ops::Rem< ::glam::I16Vec3, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -14837,11 +14291,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: i16| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Rem< + let output: ::glam::I16Vec3 = <::glam::I16Vec3 as ::core::ops::Rem< i16, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -14854,12 +14307,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::rem_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::rem_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -14872,12 +14324,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -14890,12 +14341,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::saturating_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::saturating_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -14908,12 +14358,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -14926,12 +14375,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -14944,12 +14392,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -14962,12 +14409,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::saturating_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::saturating_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -14984,13 +14430,12 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -15003,11 +14448,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::signum( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::signum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -15020,9 +14464,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |v: i16| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::splat(v) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -15035,11 +14480,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Ref<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Sub< + let output: ::glam::I16Vec3 = <::glam::I16Vec3 as ::core::ops::Sub< &::glam::I16Vec3, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -15052,11 +14496,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Sub< + let output: ::glam::I16Vec3 = <::glam::I16Vec3 as ::core::ops::Sub< ::glam::I16Vec3, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -15069,11 +14512,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: i16| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Sub< + let output: ::glam::I16Vec3 = <::glam::I16Vec3 as ::core::ops::Sub< i16, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -15086,8 +14528,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I16Vec3>| { let output: [i16; 3] = { { - let output: [i16; 3] = ::glam::I16Vec3::to_array(&_self).into(); - output + let output: [i16; 3] = ::glam::I16Vec3::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -15100,11 +14544,10 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I16Vec3::truncate( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I16Vec3::truncate( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -15117,12 +14560,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, x: i16| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -15135,12 +14577,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, y: i16| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -15153,12 +14594,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, z: i16| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::with_z( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::with_z( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -15171,12 +14611,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -15189,12 +14628,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::wrapping_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::wrapping_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -15207,12 +14645,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -15225,12 +14662,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -15243,12 +14679,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -15261,12 +14696,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::I16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::wrapping_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec3::wrapping_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -15276,7 +14710,11 @@ pub(crate) fn register_i_16_vec_3_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::I16Vec3, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::I16Vec3, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -15287,11 +14725,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::abs( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -15304,11 +14741,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Ref<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Add< + let output: ::glam::I16Vec4 = <::glam::I16Vec4 as ::core::ops::Add< &::glam::I16Vec4, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -15321,11 +14757,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Add< + let output: ::glam::I16Vec4 = <::glam::I16Vec4 as ::core::ops::Add< ::glam::I16Vec4, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -15338,11 +14773,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: i16| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Add< + let output: ::glam::I16Vec4 = <::glam::I16Vec4 as ::core::ops::Add< i16, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -15355,11 +14789,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I16Vec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::I16Vec4::as_dvec4( - &_self, - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::I16Vec4::as_dvec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -15372,11 +14805,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I16Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I16Vec4::as_i64vec4( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I16Vec4::as_i64vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -15389,11 +14821,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I16Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I16Vec4::as_i8vec4( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I16Vec4::as_i8vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -15406,11 +14837,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I16Vec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::I16Vec4::as_ivec4( - &_self, - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::I16Vec4::as_ivec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -15423,11 +14853,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::I16Vec4::as_u16vec4( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::I16Vec4::as_u16vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -15440,11 +14869,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I16Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::I16Vec4::as_u64vec4( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::I16Vec4::as_u64vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -15457,11 +14885,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I16Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::I16Vec4::as_u8vec4( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::I16Vec4::as_u8vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -15474,11 +14901,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I16Vec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::I16Vec4::as_uvec4( - &_self, - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::I16Vec4::as_uvec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -15491,9 +14917,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I16Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::I16Vec4::as_vec4(&_self) - .into(); - output + let output: ::glam::Vec4 = ::glam::I16Vec4::as_vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -15507,10 +14934,9 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { let output: () = { { let output: () = <::glam::I16Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -15524,11 +14950,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::I16Vec4::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -15542,11 +14967,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::I16Vec4::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -15563,13 +14987,12 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -15582,11 +15005,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec4 = <::glam::I16Vec4 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -15599,12 +15021,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::I16Vec4::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::I16Vec4::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -15617,12 +15038,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::I16Vec4::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::I16Vec4::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -15635,12 +15055,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::I16Vec4::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::I16Vec4::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -15653,12 +15072,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::I16Vec4::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::I16Vec4::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -15671,12 +15089,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::I16Vec4::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::I16Vec4::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -15689,12 +15106,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::I16Vec4::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::I16Vec4::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -15708,11 +15124,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { let output: i16 = { { let output: i16 = ::glam::I16Vec4::distance_squared( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -15725,11 +15140,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Ref<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Div< + let output: ::glam::I16Vec4 = <::glam::I16Vec4 as ::core::ops::Div< &::glam::I16Vec4, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -15742,11 +15156,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Div< + let output: ::glam::I16Vec4 = <::glam::I16Vec4 as ::core::ops::Div< ::glam::I16Vec4, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -15759,11 +15172,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: i16| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Div< + let output: ::glam::I16Vec4 = <::glam::I16Vec4 as ::core::ops::Div< i16, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -15776,12 +15188,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::div_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::div_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -15795,11 +15206,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { let output: i16 = { { let output: i16 = ::glam::I16Vec4::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -15812,12 +15222,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -15831,10 +15240,9 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { let output: i16 = { { let output: i16 = ::glam::I16Vec4::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -15848,10 +15256,9 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { let output: i16 = { { let output: i16 = ::glam::I16Vec4::element_sum( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -15866,9 +15273,8 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { { let output: bool = <::glam::I16Vec4 as ::core::cmp::PartialEq< ::glam::I16Vec4, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -15881,9 +15287,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |a: [i16; 4]| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::from_array(a) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -15897,10 +15304,9 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::I16Vec4::is_negative_bitmask( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -15914,10 +15320,9 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { let output: i16 = { { let output: i16 = ::glam::I16Vec4::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -15931,11 +15336,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::I16Vec4::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -15948,12 +15352,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -15967,10 +15370,9 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { let output: i16 = { { let output: i16 = ::glam::I16Vec4::max_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -15984,10 +15386,9 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::I16Vec4::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -16000,12 +15401,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -16019,10 +15419,9 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { let output: i16 = { { let output: i16 = ::glam::I16Vec4::min_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -16036,10 +15435,9 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::I16Vec4::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -16052,11 +15450,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Ref<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Mul< + let output: ::glam::I16Vec4 = <::glam::I16Vec4 as ::core::ops::Mul< &::glam::I16Vec4, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -16069,11 +15466,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Mul< + let output: ::glam::I16Vec4 = <::glam::I16Vec4 as ::core::ops::Mul< ::glam::I16Vec4, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -16086,11 +15482,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: i16| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Mul< + let output: ::glam::I16Vec4 = <::glam::I16Vec4 as ::core::ops::Mul< i16, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -16103,11 +15498,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec4 = <::glam::I16Vec4 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -16120,14 +15514,13 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |x: i16, y: i16, z: i16, w: i16| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::new( - x, - y, - z, - w, - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -16140,11 +15533,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Ref<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Rem< + let output: ::glam::I16Vec4 = <::glam::I16Vec4 as ::core::ops::Rem< &::glam::I16Vec4, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -16157,11 +15549,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Rem< + let output: ::glam::I16Vec4 = <::glam::I16Vec4 as ::core::ops::Rem< ::glam::I16Vec4, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -16174,11 +15565,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: i16| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Rem< + let output: ::glam::I16Vec4 = <::glam::I16Vec4 as ::core::ops::Rem< i16, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -16191,12 +15581,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::rem_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::rem_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -16209,12 +15598,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -16227,12 +15615,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::saturating_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::saturating_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -16245,12 +15632,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -16263,12 +15649,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -16281,12 +15666,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -16299,12 +15683,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::saturating_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::saturating_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -16321,13 +15704,12 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -16340,11 +15722,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::signum( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::signum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -16357,9 +15738,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |v: i16| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::splat(v) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -16372,11 +15754,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Ref<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Sub< + let output: ::glam::I16Vec4 = <::glam::I16Vec4 as ::core::ops::Sub< &::glam::I16Vec4, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -16389,11 +15770,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Sub< + let output: ::glam::I16Vec4 = <::glam::I16Vec4 as ::core::ops::Sub< ::glam::I16Vec4, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -16406,11 +15786,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: i16| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Sub< + let output: ::glam::I16Vec4 = <::glam::I16Vec4 as ::core::ops::Sub< i16, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -16423,8 +15802,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I16Vec4>| { let output: [i16; 4] = { { - let output: [i16; 4] = ::glam::I16Vec4::to_array(&_self).into(); - output + let output: [i16; 4] = ::glam::I16Vec4::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -16437,11 +15818,10 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I16Vec4::truncate( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I16Vec4::truncate( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -16454,12 +15834,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, w: i16| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::with_w( - _self.into_inner(), - w, - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::with_w( + safe_transmute(_self), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -16472,12 +15851,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, x: i16| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -16490,12 +15868,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, y: i16| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -16508,12 +15885,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, z: i16| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::with_z( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::with_z( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -16526,12 +15902,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -16544,12 +15919,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::wrapping_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::wrapping_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -16562,12 +15936,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -16580,12 +15953,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -16598,12 +15970,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -16616,12 +15987,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::I16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::wrapping_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I16Vec4::wrapping_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -16631,7 +16001,11 @@ pub(crate) fn register_i_16_vec_4_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::I16Vec4, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::I16Vec4, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -16642,11 +16016,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::abs( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -16659,11 +16032,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Ref<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Add< + let output: ::glam::I64Vec2 = <::glam::I64Vec2 as ::core::ops::Add< &::glam::I64Vec2, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -16676,11 +16048,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Add< + let output: ::glam::I64Vec2 = <::glam::I64Vec2 as ::core::ops::Add< ::glam::I64Vec2, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -16693,11 +16064,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: i64| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Add< + let output: ::glam::I64Vec2 = <::glam::I64Vec2 as ::core::ops::Add< i64, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -16710,11 +16080,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I64Vec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::I64Vec2::as_dvec2( - &_self, - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::I64Vec2::as_dvec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -16727,11 +16096,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I64Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::I64Vec2::as_i16vec2( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::I64Vec2::as_i16vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -16744,11 +16112,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I64Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::I64Vec2::as_i8vec2( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::I64Vec2::as_i8vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -16761,11 +16128,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I64Vec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::I64Vec2::as_ivec2( - &_self, - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::I64Vec2::as_ivec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -16778,11 +16144,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I64Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::I64Vec2::as_u16vec2( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::I64Vec2::as_u16vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -16795,11 +16160,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::I64Vec2::as_u64vec2( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::I64Vec2::as_u64vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -16812,11 +16176,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I64Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::I64Vec2::as_u8vec2( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::I64Vec2::as_u8vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -16829,11 +16192,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I64Vec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::I64Vec2::as_uvec2( - &_self, - ) - .into(); - output + let output: ::glam::UVec2 = ::glam::I64Vec2::as_uvec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -16846,9 +16208,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I64Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::I64Vec2::as_vec2(&_self) - .into(); - output + let output: ::glam::Vec2 = ::glam::I64Vec2::as_vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -16862,10 +16225,9 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { let output: () = { { let output: () = <::glam::I64Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -16879,11 +16241,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::I64Vec2::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -16897,11 +16258,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::I64Vec2::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -16918,13 +16278,12 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -16937,11 +16296,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec2 = <::glam::I64Vec2 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -16954,12 +16312,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::I64Vec2::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::I64Vec2::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -16972,12 +16329,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::I64Vec2::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::I64Vec2::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -16990,12 +16346,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::I64Vec2::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::I64Vec2::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17008,12 +16363,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::I64Vec2::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::I64Vec2::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17026,12 +16380,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::I64Vec2::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::I64Vec2::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17044,12 +16397,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::I64Vec2::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::I64Vec2::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17063,11 +16415,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { let output: i64 = { { let output: i64 = ::glam::I64Vec2::distance_squared( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17080,11 +16431,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Ref<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Div< + let output: ::glam::I64Vec2 = <::glam::I64Vec2 as ::core::ops::Div< &::glam::I64Vec2, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -17097,11 +16447,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Div< + let output: ::glam::I64Vec2 = <::glam::I64Vec2 as ::core::ops::Div< ::glam::I64Vec2, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -17114,11 +16463,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: i64| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Div< + let output: ::glam::I64Vec2 = <::glam::I64Vec2 as ::core::ops::Div< i64, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -17131,12 +16479,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::div_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::div_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17150,11 +16497,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { let output: i64 = { { let output: i64 = ::glam::I64Vec2::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17167,12 +16513,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17186,10 +16531,9 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { let output: i64 = { { let output: i64 = ::glam::I64Vec2::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -17203,10 +16547,9 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { let output: i64 = { { let output: i64 = ::glam::I64Vec2::element_sum( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -17221,9 +16564,8 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { { let output: bool = <::glam::I64Vec2 as ::core::cmp::PartialEq< ::glam::I64Vec2, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -17236,12 +16578,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, z: i64| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec2::extend( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec2::extend( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -17254,9 +16595,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |a: [i64; 2]| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::from_array(a) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -17270,10 +16612,9 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::I64Vec2::is_negative_bitmask( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -17287,10 +16628,9 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { let output: i64 = { { let output: i64 = ::glam::I64Vec2::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -17304,11 +16644,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::I64Vec2::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17321,12 +16660,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17340,10 +16678,9 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { let output: i64 = { { let output: i64 = ::glam::I64Vec2::max_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -17357,10 +16694,9 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::I64Vec2::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -17373,12 +16709,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17392,10 +16727,9 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { let output: i64 = { { let output: i64 = ::glam::I64Vec2::min_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -17409,10 +16743,9 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::I64Vec2::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -17425,11 +16758,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Ref<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Mul< + let output: ::glam::I64Vec2 = <::glam::I64Vec2 as ::core::ops::Mul< &::glam::I64Vec2, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -17442,11 +16774,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Mul< + let output: ::glam::I64Vec2 = <::glam::I64Vec2 as ::core::ops::Mul< ::glam::I64Vec2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -17459,11 +16790,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: i64| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Mul< + let output: ::glam::I64Vec2 = <::glam::I64Vec2 as ::core::ops::Mul< i64, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -17476,11 +16806,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = <::glam::I64Vec2 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -17493,9 +16822,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |x: i64, y: i64| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::new(x, y) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::new( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -17508,11 +16839,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::perp( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::perp( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -17526,11 +16856,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { let output: i64 = { { let output: i64 = ::glam::I64Vec2::perp_dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17543,11 +16872,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Ref<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Rem< + let output: ::glam::I64Vec2 = <::glam::I64Vec2 as ::core::ops::Rem< &::glam::I64Vec2, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -17560,11 +16888,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Rem< + let output: ::glam::I64Vec2 = <::glam::I64Vec2 as ::core::ops::Rem< ::glam::I64Vec2, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -17577,11 +16904,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: i64| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Rem< + let output: ::glam::I64Vec2 = <::glam::I64Vec2 as ::core::ops::Rem< i64, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -17594,12 +16920,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::rem_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::rem_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17612,12 +16937,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::rotate( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::rotate( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17630,12 +16954,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17648,12 +16971,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::saturating_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::saturating_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17666,12 +16988,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17684,12 +17005,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17702,12 +17022,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17720,12 +17039,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::saturating_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::saturating_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17742,13 +17060,12 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -17761,11 +17078,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::signum( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::signum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -17778,9 +17094,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |v: i64| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::splat(v) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -17793,11 +17110,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Ref<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Sub< + let output: ::glam::I64Vec2 = <::glam::I64Vec2 as ::core::ops::Sub< &::glam::I64Vec2, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -17810,11 +17126,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Sub< + let output: ::glam::I64Vec2 = <::glam::I64Vec2 as ::core::ops::Sub< ::glam::I64Vec2, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -17827,11 +17142,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: i64| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Sub< + let output: ::glam::I64Vec2 = <::glam::I64Vec2 as ::core::ops::Sub< i64, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -17844,8 +17158,10 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::I64Vec2>| { let output: [i64; 2] = { { - let output: [i64; 2] = ::glam::I64Vec2::to_array(&_self).into(); - output + let output: [i64; 2] = ::glam::I64Vec2::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -17858,12 +17174,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, x: i64| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -17876,12 +17191,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, y: i64| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -17894,12 +17208,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17912,12 +17225,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::wrapping_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::wrapping_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17930,12 +17242,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17948,12 +17259,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17966,12 +17276,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17984,12 +17293,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::I64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::wrapping_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec2::wrapping_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -17999,7 +17307,11 @@ pub(crate) fn register_i_64_vec_2_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::I64Vec2, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::I64Vec2, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -18010,11 +17322,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::abs( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -18027,11 +17338,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Ref<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Add< + let output: ::glam::I64Vec3 = <::glam::I64Vec3 as ::core::ops::Add< &::glam::I64Vec3, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -18044,11 +17354,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Add< + let output: ::glam::I64Vec3 = <::glam::I64Vec3 as ::core::ops::Add< ::glam::I64Vec3, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -18061,11 +17370,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: i64| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Add< + let output: ::glam::I64Vec3 = <::glam::I64Vec3 as ::core::ops::Add< i64, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -18078,11 +17386,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I64Vec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::I64Vec3::as_dvec3( - &_self, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::I64Vec3::as_dvec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -18095,11 +17402,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I64Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::I64Vec3::as_i16vec3( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::I64Vec3::as_i16vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -18112,11 +17418,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I64Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::I64Vec3::as_i8vec3( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::I64Vec3::as_i8vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -18129,11 +17434,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I64Vec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::I64Vec3::as_ivec3( - &_self, - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::I64Vec3::as_ivec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -18146,11 +17450,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I64Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::I64Vec3::as_u16vec3( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::I64Vec3::as_u16vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -18163,11 +17466,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::I64Vec3::as_u64vec3( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::I64Vec3::as_u64vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -18180,11 +17482,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I64Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::I64Vec3::as_u8vec3( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::I64Vec3::as_u8vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -18197,11 +17498,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I64Vec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::I64Vec3::as_uvec3( - &_self, - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::I64Vec3::as_uvec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -18214,9 +17514,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I64Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::I64Vec3::as_vec3(&_self) - .into(); - output + let output: ::glam::Vec3 = ::glam::I64Vec3::as_vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -18229,11 +17530,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I64Vec3>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::I64Vec3::as_vec3a( - &_self, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::I64Vec3::as_vec3a( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -18247,10 +17547,9 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { let output: () = { { let output: () = <::glam::I64Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -18264,11 +17563,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::I64Vec3::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -18282,11 +17580,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::I64Vec3::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -18303,13 +17600,12 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -18322,11 +17618,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec3 = <::glam::I64Vec3 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -18339,12 +17634,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::I64Vec3::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::I64Vec3::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -18357,12 +17651,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::I64Vec3::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::I64Vec3::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -18375,12 +17668,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::I64Vec3::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::I64Vec3::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -18393,12 +17685,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::I64Vec3::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::I64Vec3::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -18411,12 +17702,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::I64Vec3::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::I64Vec3::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -18429,12 +17719,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::I64Vec3::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::I64Vec3::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -18447,12 +17736,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::cross( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::cross( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -18466,11 +17754,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { let output: i64 = { { let output: i64 = ::glam::I64Vec3::distance_squared( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -18483,11 +17770,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Ref<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Div< + let output: ::glam::I64Vec3 = <::glam::I64Vec3 as ::core::ops::Div< &::glam::I64Vec3, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -18500,11 +17786,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Div< + let output: ::glam::I64Vec3 = <::glam::I64Vec3 as ::core::ops::Div< ::glam::I64Vec3, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -18517,11 +17802,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: i64| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Div< + let output: ::glam::I64Vec3 = <::glam::I64Vec3 as ::core::ops::Div< i64, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -18534,12 +17818,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::div_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::div_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -18553,11 +17836,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { let output: i64 = { { let output: i64 = ::glam::I64Vec3::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -18570,12 +17852,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -18589,10 +17870,9 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { let output: i64 = { { let output: i64 = ::glam::I64Vec3::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -18606,10 +17886,9 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { let output: i64 = { { let output: i64 = ::glam::I64Vec3::element_sum( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -18624,9 +17903,8 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { { let output: bool = <::glam::I64Vec3 as ::core::cmp::PartialEq< ::glam::I64Vec3, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -18639,12 +17917,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, w: i64| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec3::extend( - _self.into_inner(), - w, - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec3::extend( + safe_transmute(_self), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -18657,9 +17934,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |a: [i64; 3]| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::from_array(a) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -18673,10 +17951,9 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::I64Vec3::is_negative_bitmask( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -18690,10 +17967,9 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { let output: i64 = { { let output: i64 = ::glam::I64Vec3::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -18707,11 +17983,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::I64Vec3::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -18724,12 +17999,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -18743,10 +18017,9 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { let output: i64 = { { let output: i64 = ::glam::I64Vec3::max_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -18760,10 +18033,9 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::I64Vec3::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -18776,12 +18048,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -18795,10 +18066,9 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { let output: i64 = { { let output: i64 = ::glam::I64Vec3::min_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -18812,10 +18082,9 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::I64Vec3::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -18828,11 +18097,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Ref<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Mul< + let output: ::glam::I64Vec3 = <::glam::I64Vec3 as ::core::ops::Mul< &::glam::I64Vec3, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -18845,11 +18113,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Mul< + let output: ::glam::I64Vec3 = <::glam::I64Vec3 as ::core::ops::Mul< ::glam::I64Vec3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -18862,11 +18129,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: i64| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Mul< + let output: ::glam::I64Vec3 = <::glam::I64Vec3 as ::core::ops::Mul< i64, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -18879,11 +18145,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = <::glam::I64Vec3 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -18896,9 +18161,12 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |x: i64, y: i64, z: i64| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::new(x, y, z) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -18911,11 +18179,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Ref<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Rem< + let output: ::glam::I64Vec3 = <::glam::I64Vec3 as ::core::ops::Rem< &::glam::I64Vec3, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -18928,11 +18195,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Rem< + let output: ::glam::I64Vec3 = <::glam::I64Vec3 as ::core::ops::Rem< ::glam::I64Vec3, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -18945,11 +18211,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: i64| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Rem< + let output: ::glam::I64Vec3 = <::glam::I64Vec3 as ::core::ops::Rem< i64, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -18962,12 +18227,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::rem_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::rem_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -18980,12 +18244,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -18998,12 +18261,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::saturating_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::saturating_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -19016,12 +18278,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -19034,12 +18295,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -19052,12 +18312,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -19070,12 +18329,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::saturating_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::saturating_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -19092,13 +18350,12 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -19111,11 +18368,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::signum( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::signum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -19128,9 +18384,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |v: i64| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::splat(v) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -19143,11 +18400,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Ref<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Sub< + let output: ::glam::I64Vec3 = <::glam::I64Vec3 as ::core::ops::Sub< &::glam::I64Vec3, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -19160,11 +18416,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Sub< + let output: ::glam::I64Vec3 = <::glam::I64Vec3 as ::core::ops::Sub< ::glam::I64Vec3, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -19177,11 +18432,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: i64| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Sub< + let output: ::glam::I64Vec3 = <::glam::I64Vec3 as ::core::ops::Sub< i64, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -19194,8 +18448,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::I64Vec3>| { let output: [i64; 3] = { { - let output: [i64; 3] = ::glam::I64Vec3::to_array(&_self).into(); - output + let output: [i64; 3] = ::glam::I64Vec3::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -19208,11 +18464,10 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::I64Vec3::truncate( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::I64Vec3::truncate( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -19225,12 +18480,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, x: i64| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -19243,12 +18497,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, y: i64| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -19261,12 +18514,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, z: i64| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::with_z( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::with_z( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -19279,12 +18531,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -19297,12 +18548,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::wrapping_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::wrapping_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -19315,12 +18565,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -19333,12 +18582,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -19351,12 +18599,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -19369,12 +18616,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::I64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::wrapping_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec3::wrapping_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -19384,7 +18630,11 @@ pub(crate) fn register_i_64_vec_3_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::I64Vec3, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::I64Vec3, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -19395,11 +18645,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::abs( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -19412,11 +18661,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Ref<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Add< + let output: ::glam::I64Vec4 = <::glam::I64Vec4 as ::core::ops::Add< &::glam::I64Vec4, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -19429,11 +18677,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Add< + let output: ::glam::I64Vec4 = <::glam::I64Vec4 as ::core::ops::Add< ::glam::I64Vec4, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -19446,11 +18693,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: i64| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Add< + let output: ::glam::I64Vec4 = <::glam::I64Vec4 as ::core::ops::Add< i64, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -19463,11 +18709,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I64Vec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::I64Vec4::as_dvec4( - &_self, - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::I64Vec4::as_dvec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -19480,11 +18725,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I64Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::I64Vec4::as_i16vec4( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::I64Vec4::as_i16vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -19497,11 +18741,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I64Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::I64Vec4::as_i8vec4( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::I64Vec4::as_i8vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -19514,11 +18757,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I64Vec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::I64Vec4::as_ivec4( - &_self, - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::I64Vec4::as_ivec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -19531,11 +18773,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I64Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::I64Vec4::as_u16vec4( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::I64Vec4::as_u16vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -19548,11 +18789,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::I64Vec4::as_u64vec4( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::I64Vec4::as_u64vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -19565,11 +18805,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I64Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::I64Vec4::as_u8vec4( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::I64Vec4::as_u8vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -19582,11 +18821,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I64Vec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::I64Vec4::as_uvec4( - &_self, - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::I64Vec4::as_uvec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -19599,9 +18837,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I64Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::I64Vec4::as_vec4(&_self) - .into(); - output + let output: ::glam::Vec4 = ::glam::I64Vec4::as_vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -19615,10 +18854,9 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { let output: () = { { let output: () = <::glam::I64Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -19632,11 +18870,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::I64Vec4::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -19650,11 +18887,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::I64Vec4::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -19671,13 +18907,12 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -19690,11 +18925,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec4 = <::glam::I64Vec4 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -19707,12 +18941,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::I64Vec4::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::I64Vec4::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -19725,12 +18958,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::I64Vec4::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::I64Vec4::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -19743,12 +18975,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::I64Vec4::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::I64Vec4::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -19761,12 +18992,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::I64Vec4::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::I64Vec4::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -19779,12 +19009,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::I64Vec4::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::I64Vec4::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -19797,12 +19026,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::I64Vec4::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::I64Vec4::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -19816,11 +19044,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { let output: i64 = { { let output: i64 = ::glam::I64Vec4::distance_squared( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -19833,11 +19060,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Ref<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Div< + let output: ::glam::I64Vec4 = <::glam::I64Vec4 as ::core::ops::Div< &::glam::I64Vec4, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -19850,11 +19076,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Div< + let output: ::glam::I64Vec4 = <::glam::I64Vec4 as ::core::ops::Div< ::glam::I64Vec4, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -19867,11 +19092,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: i64| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Div< + let output: ::glam::I64Vec4 = <::glam::I64Vec4 as ::core::ops::Div< i64, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -19884,12 +19108,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::div_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::div_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -19903,11 +19126,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { let output: i64 = { { let output: i64 = ::glam::I64Vec4::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -19920,12 +19142,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -19939,10 +19160,9 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { let output: i64 = { { let output: i64 = ::glam::I64Vec4::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -19956,10 +19176,9 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { let output: i64 = { { let output: i64 = ::glam::I64Vec4::element_sum( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -19974,9 +19193,8 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { { let output: bool = <::glam::I64Vec4 as ::core::cmp::PartialEq< ::glam::I64Vec4, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -19989,9 +19207,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |a: [i64; 4]| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::from_array(a) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -20005,10 +19224,9 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::I64Vec4::is_negative_bitmask( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -20022,10 +19240,9 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { let output: i64 = { { let output: i64 = ::glam::I64Vec4::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -20039,11 +19256,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::I64Vec4::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -20056,12 +19272,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -20075,10 +19290,9 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { let output: i64 = { { let output: i64 = ::glam::I64Vec4::max_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -20092,10 +19306,9 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::I64Vec4::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -20108,12 +19321,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -20127,10 +19339,9 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { let output: i64 = { { let output: i64 = ::glam::I64Vec4::min_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -20144,10 +19355,9 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::I64Vec4::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -20160,11 +19370,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Ref<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Mul< + let output: ::glam::I64Vec4 = <::glam::I64Vec4 as ::core::ops::Mul< &::glam::I64Vec4, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -20177,11 +19386,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Mul< + let output: ::glam::I64Vec4 = <::glam::I64Vec4 as ::core::ops::Mul< ::glam::I64Vec4, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -20194,11 +19402,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: i64| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Mul< + let output: ::glam::I64Vec4 = <::glam::I64Vec4 as ::core::ops::Mul< i64, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -20211,11 +19418,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec4 = <::glam::I64Vec4 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -20228,14 +19434,13 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |x: i64, y: i64, z: i64, w: i64| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::new( - x, - y, - z, - w, - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -20248,11 +19453,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Ref<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Rem< + let output: ::glam::I64Vec4 = <::glam::I64Vec4 as ::core::ops::Rem< &::glam::I64Vec4, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -20265,11 +19469,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Rem< + let output: ::glam::I64Vec4 = <::glam::I64Vec4 as ::core::ops::Rem< ::glam::I64Vec4, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -20282,11 +19485,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: i64| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Rem< + let output: ::glam::I64Vec4 = <::glam::I64Vec4 as ::core::ops::Rem< i64, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -20299,12 +19501,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::rem_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::rem_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -20317,12 +19518,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -20335,12 +19535,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::saturating_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::saturating_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -20353,12 +19552,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -20371,12 +19569,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -20389,12 +19586,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -20407,12 +19603,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::saturating_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::saturating_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -20429,13 +19624,12 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -20448,11 +19642,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::signum( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::signum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -20465,9 +19658,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |v: i64| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::splat(v) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -20480,11 +19674,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Ref<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Sub< + let output: ::glam::I64Vec4 = <::glam::I64Vec4 as ::core::ops::Sub< &::glam::I64Vec4, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -20497,11 +19690,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Sub< + let output: ::glam::I64Vec4 = <::glam::I64Vec4 as ::core::ops::Sub< ::glam::I64Vec4, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -20514,11 +19706,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: i64| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Sub< + let output: ::glam::I64Vec4 = <::glam::I64Vec4 as ::core::ops::Sub< i64, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -20531,8 +19722,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::I64Vec4>| { let output: [i64; 4] = { { - let output: [i64; 4] = ::glam::I64Vec4::to_array(&_self).into(); - output + let output: [i64; 4] = ::glam::I64Vec4::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -20545,11 +19738,10 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::I64Vec4::truncate( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::I64Vec4::truncate( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -20562,12 +19754,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, w: i64| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::with_w( - _self.into_inner(), - w, - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::with_w( + safe_transmute(_self), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -20580,12 +19771,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, x: i64| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -20598,12 +19788,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, y: i64| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -20616,12 +19805,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, z: i64| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::with_z( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::with_z( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -20634,12 +19822,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -20652,12 +19839,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::wrapping_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::wrapping_add_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -20670,12 +19856,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -20688,12 +19873,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -20706,12 +19890,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -20724,12 +19907,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::I64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::wrapping_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::I64Vec4::wrapping_sub_unsigned( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -20739,7 +19921,11 @@ pub(crate) fn register_i_64_vec_4_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::I64Vec4, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::I64Vec4, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_u_vec_2_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -20750,11 +19936,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Ref<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Add< + let output: ::glam::UVec2 = <::glam::UVec2 as ::core::ops::Add< &::glam::UVec2, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -20767,11 +19952,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Add< + let output: ::glam::UVec2 = <::glam::UVec2 as ::core::ops::Add< ::glam::UVec2, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -20784,11 +19968,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: u32| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Add< + let output: ::glam::UVec2 = <::glam::UVec2 as ::core::ops::Add< u32, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -20801,9 +19984,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Ref<::glam::UVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::UVec2::as_dvec2(&_self) - .into(); - output + let output: ::glam::DVec2 = ::glam::UVec2::as_dvec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -20816,11 +20000,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Ref<::glam::UVec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::UVec2::as_i16vec2( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::UVec2::as_i16vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -20833,11 +20016,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Ref<::glam::UVec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::UVec2::as_i64vec2( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::UVec2::as_i64vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -20850,11 +20032,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Ref<::glam::UVec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::UVec2::as_i8vec2( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::UVec2::as_i8vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -20867,9 +20048,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Ref<::glam::UVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::UVec2::as_ivec2(&_self) - .into(); - output + let output: ::glam::IVec2 = ::glam::UVec2::as_ivec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -20882,11 +20064,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Ref<::glam::UVec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::UVec2::as_u16vec2( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::UVec2::as_u16vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -20899,11 +20080,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Ref<::glam::UVec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::UVec2::as_u64vec2( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::UVec2::as_u64vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -20916,11 +20096,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Ref<::glam::UVec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::UVec2::as_u8vec2( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::UVec2::as_u8vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -20933,9 +20112,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Ref<::glam::UVec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::UVec2::as_vec2(&_self) - .into(); - output + let output: ::glam::Vec2 = ::glam::UVec2::as_vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -20949,10 +20129,9 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { let output: () = { { let output: () = <::glam::UVec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -20966,11 +20145,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::UVec2::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -20984,11 +20162,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::UVec2::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -21005,13 +20182,12 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::UVec2::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::UVec2 = ::glam::UVec2::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -21024,11 +20200,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Ref<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::UVec2 = <::glam::UVec2 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -21041,12 +20216,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::UVec2::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::UVec2::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -21059,12 +20233,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::UVec2::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::UVec2::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -21077,12 +20250,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::UVec2::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::UVec2::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -21095,12 +20267,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::UVec2::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::UVec2::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -21113,12 +20284,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::UVec2::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::UVec2::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -21131,12 +20301,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::UVec2::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::UVec2::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -21149,11 +20318,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Ref<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Div< + let output: ::glam::UVec2 = <::glam::UVec2 as ::core::ops::Div< &::glam::UVec2, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -21166,11 +20334,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Div< + let output: ::glam::UVec2 = <::glam::UVec2 as ::core::ops::Div< ::glam::UVec2, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -21183,11 +20350,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: u32| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Div< + let output: ::glam::UVec2 = <::glam::UVec2 as ::core::ops::Div< u32, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -21201,11 +20367,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::UVec2::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -21218,12 +20383,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::UVec2::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec2 = ::glam::UVec2::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -21237,10 +20401,9 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::UVec2::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -21253,9 +20416,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>| { let output: u32 = { { - let output: u32 = ::glam::UVec2::element_sum(_self.into_inner()) - .into(); - output + let output: u32 = ::glam::UVec2::element_sum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -21270,9 +20434,8 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { { let output: bool = <::glam::UVec2 as ::core::cmp::PartialEq< ::glam::UVec2, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -21285,12 +20448,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, z: u32| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec2::extend( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::UVec2::extend( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -21303,9 +20465,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |a: [u32; 2]| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::UVec2::from_array(a) - .into(); - output + let output: ::glam::UVec2 = ::glam::UVec2::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -21319,10 +20482,9 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::UVec2::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -21336,11 +20498,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::UVec2::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -21353,12 +20514,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::UVec2::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec2 = ::glam::UVec2::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -21371,9 +20531,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>| { let output: u32 = { { - let output: u32 = ::glam::UVec2::max_element(_self.into_inner()) - .into(); - output + let output: u32 = ::glam::UVec2::max_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -21387,10 +20548,9 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::UVec2::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -21403,12 +20563,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::UVec2::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec2 = ::glam::UVec2::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -21421,9 +20580,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>| { let output: u32 = { { - let output: u32 = ::glam::UVec2::min_element(_self.into_inner()) - .into(); - output + let output: u32 = ::glam::UVec2::min_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -21437,10 +20597,9 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::UVec2::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -21453,11 +20612,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Ref<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Mul< + let output: ::glam::UVec2 = <::glam::UVec2 as ::core::ops::Mul< &::glam::UVec2, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -21470,11 +20628,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Mul< + let output: ::glam::UVec2 = <::glam::UVec2 as ::core::ops::Mul< ::glam::UVec2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -21487,11 +20644,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: u32| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Mul< + let output: ::glam::UVec2 = <::glam::UVec2 as ::core::ops::Mul< u32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -21504,8 +20660,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |x: u32, y: u32| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::UVec2::new(x, y).into(); - output + let output: ::glam::UVec2 = ::glam::UVec2::new( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -21518,11 +20677,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Ref<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Rem< + let output: ::glam::UVec2 = <::glam::UVec2 as ::core::ops::Rem< &::glam::UVec2, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -21535,11 +20693,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Rem< + let output: ::glam::UVec2 = <::glam::UVec2 as ::core::ops::Rem< ::glam::UVec2, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -21552,11 +20709,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: u32| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Rem< + let output: ::glam::UVec2 = <::glam::UVec2 as ::core::ops::Rem< u32, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -21569,12 +20725,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::UVec2::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec2 = ::glam::UVec2::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -21587,12 +20742,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::UVec2::saturating_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec2 = ::glam::UVec2::saturating_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -21605,12 +20759,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::UVec2::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec2 = ::glam::UVec2::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -21623,12 +20776,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::UVec2::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec2 = ::glam::UVec2::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -21641,12 +20793,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::UVec2::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec2 = ::glam::UVec2::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -21663,13 +20814,12 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::UVec2::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::UVec2 = ::glam::UVec2::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -21682,8 +20832,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |v: u32| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::UVec2::splat(v).into(); - output + let output: ::glam::UVec2 = ::glam::UVec2::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -21696,11 +20848,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Ref<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Sub< + let output: ::glam::UVec2 = <::glam::UVec2 as ::core::ops::Sub< &::glam::UVec2, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -21713,11 +20864,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Sub< + let output: ::glam::UVec2 = <::glam::UVec2 as ::core::ops::Sub< ::glam::UVec2, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -21730,11 +20880,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: u32| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Sub< + let output: ::glam::UVec2 = <::glam::UVec2 as ::core::ops::Sub< u32, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -21747,8 +20896,10 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Ref<::glam::UVec2>| { let output: [u32; 2] = { { - let output: [u32; 2] = ::glam::UVec2::to_array(&_self).into(); - output + let output: [u32; 2] = ::glam::UVec2::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -21761,12 +20912,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, x: u32| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::UVec2::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::UVec2 = ::glam::UVec2::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -21779,12 +20929,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, y: u32| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::UVec2::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::UVec2 = ::glam::UVec2::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -21797,12 +20946,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::UVec2::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec2 = ::glam::UVec2::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -21815,12 +20963,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::IVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::UVec2::wrapping_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec2 = ::glam::UVec2::wrapping_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -21833,12 +20980,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::UVec2::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec2 = ::glam::UVec2::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -21851,12 +20997,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::UVec2::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec2 = ::glam::UVec2::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -21869,12 +21014,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { |_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::UVec2::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec2 = ::glam::UVec2::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -21884,7 +21028,11 @@ pub(crate) fn register_u_vec_2_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::UVec2, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::UVec2, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_u_vec_3_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -21895,11 +21043,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Ref<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Add< + let output: ::glam::UVec3 = <::glam::UVec3 as ::core::ops::Add< &::glam::UVec3, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -21912,11 +21059,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Add< + let output: ::glam::UVec3 = <::glam::UVec3 as ::core::ops::Add< ::glam::UVec3, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -21929,11 +21075,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: u32| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Add< + let output: ::glam::UVec3 = <::glam::UVec3 as ::core::ops::Add< u32, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -21946,9 +21091,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Ref<::glam::UVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::UVec3::as_dvec3(&_self) - .into(); - output + let output: ::glam::DVec3 = ::glam::UVec3::as_dvec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -21961,11 +21107,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Ref<::glam::UVec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::UVec3::as_i16vec3( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::UVec3::as_i16vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -21978,11 +21123,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Ref<::glam::UVec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::UVec3::as_i64vec3( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::UVec3::as_i64vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -21995,11 +21139,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Ref<::glam::UVec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::UVec3::as_i8vec3( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::UVec3::as_i8vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -22012,9 +21155,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Ref<::glam::UVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::UVec3::as_ivec3(&_self) - .into(); - output + let output: ::glam::IVec3 = ::glam::UVec3::as_ivec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -22027,11 +21171,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Ref<::glam::UVec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::UVec3::as_u16vec3( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::UVec3::as_u16vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -22044,11 +21187,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Ref<::glam::UVec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::UVec3::as_u64vec3( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::UVec3::as_u64vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -22061,11 +21203,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Ref<::glam::UVec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::UVec3::as_u8vec3( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::UVec3::as_u8vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -22078,9 +21219,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Ref<::glam::UVec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::UVec3::as_vec3(&_self) - .into(); - output + let output: ::glam::Vec3 = ::glam::UVec3::as_vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -22093,9 +21235,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Ref<::glam::UVec3>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::UVec3::as_vec3a(&_self) - .into(); - output + let output: ::glam::Vec3A = ::glam::UVec3::as_vec3a( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -22109,10 +21252,9 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { let output: () = { { let output: () = <::glam::UVec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -22126,11 +21268,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::UVec3::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -22144,11 +21285,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::UVec3::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -22165,13 +21305,12 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec3::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::UVec3::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -22184,11 +21323,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Ref<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::UVec3 = <::glam::UVec3 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -22201,12 +21339,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::UVec3::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::UVec3::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -22219,12 +21356,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::UVec3::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::UVec3::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -22237,12 +21373,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::UVec3::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::UVec3::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -22255,12 +21390,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::UVec3::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::UVec3::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -22273,12 +21407,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::UVec3::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::UVec3::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -22291,12 +21424,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::UVec3::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::UVec3::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -22309,12 +21441,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec3::cross( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::UVec3::cross( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -22327,11 +21458,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Ref<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Div< + let output: ::glam::UVec3 = <::glam::UVec3 as ::core::ops::Div< &::glam::UVec3, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -22344,11 +21474,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Div< + let output: ::glam::UVec3 = <::glam::UVec3 as ::core::ops::Div< ::glam::UVec3, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -22361,11 +21490,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: u32| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Div< + let output: ::glam::UVec3 = <::glam::UVec3 as ::core::ops::Div< u32, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -22379,11 +21507,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::UVec3::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -22396,12 +21523,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec3::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::UVec3::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -22415,10 +21541,9 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::UVec3::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -22431,9 +21556,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>| { let output: u32 = { { - let output: u32 = ::glam::UVec3::element_sum(_self.into_inner()) - .into(); - output + let output: u32 = ::glam::UVec3::element_sum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -22448,9 +21574,8 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { { let output: bool = <::glam::UVec3 as ::core::cmp::PartialEq< ::glam::UVec3, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -22463,12 +21588,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, w: u32| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::UVec3::extend( - _self.into_inner(), - w, - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::UVec3::extend( + safe_transmute(_self), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -22481,9 +21605,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |a: [u32; 3]| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec3::from_array(a) - .into(); - output + let output: ::glam::UVec3 = ::glam::UVec3::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -22497,10 +21622,9 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::UVec3::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -22514,11 +21638,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::UVec3::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -22531,12 +21654,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec3::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::UVec3::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -22549,9 +21671,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>| { let output: u32 = { { - let output: u32 = ::glam::UVec3::max_element(_self.into_inner()) - .into(); - output + let output: u32 = ::glam::UVec3::max_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -22565,10 +21688,9 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::UVec3::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -22581,12 +21703,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec3::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::UVec3::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -22599,9 +21720,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>| { let output: u32 = { { - let output: u32 = ::glam::UVec3::min_element(_self.into_inner()) - .into(); - output + let output: u32 = ::glam::UVec3::min_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -22615,10 +21737,9 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::UVec3::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -22631,11 +21752,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Ref<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Mul< + let output: ::glam::UVec3 = <::glam::UVec3 as ::core::ops::Mul< &::glam::UVec3, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -22648,11 +21768,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Mul< + let output: ::glam::UVec3 = <::glam::UVec3 as ::core::ops::Mul< ::glam::UVec3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -22665,11 +21784,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: u32| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Mul< + let output: ::glam::UVec3 = <::glam::UVec3 as ::core::ops::Mul< u32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -22682,9 +21800,12 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |x: u32, y: u32, z: u32| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec3::new(x, y, z) - .into(); - output + let output: ::glam::UVec3 = ::glam::UVec3::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -22697,11 +21818,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Ref<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Rem< + let output: ::glam::UVec3 = <::glam::UVec3 as ::core::ops::Rem< &::glam::UVec3, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -22714,11 +21834,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Rem< + let output: ::glam::UVec3 = <::glam::UVec3 as ::core::ops::Rem< ::glam::UVec3, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -22731,11 +21850,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: u32| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Rem< + let output: ::glam::UVec3 = <::glam::UVec3 as ::core::ops::Rem< u32, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -22748,12 +21866,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec3::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::UVec3::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -22766,12 +21883,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec3::saturating_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::UVec3::saturating_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -22784,12 +21900,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec3::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::UVec3::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -22802,12 +21917,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec3::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::UVec3::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -22820,12 +21934,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec3::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::UVec3::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -22842,13 +21955,12 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec3::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::UVec3::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -22861,8 +21973,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |v: u32| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec3::splat(v).into(); - output + let output: ::glam::UVec3 = ::glam::UVec3::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -22875,11 +21989,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Ref<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Sub< + let output: ::glam::UVec3 = <::glam::UVec3 as ::core::ops::Sub< &::glam::UVec3, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -22892,11 +22005,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Sub< + let output: ::glam::UVec3 = <::glam::UVec3 as ::core::ops::Sub< ::glam::UVec3, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -22909,11 +22021,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: u32| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Sub< + let output: ::glam::UVec3 = <::glam::UVec3 as ::core::ops::Sub< u32, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -22926,8 +22037,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Ref<::glam::UVec3>| { let output: [u32; 3] = { { - let output: [u32; 3] = ::glam::UVec3::to_array(&_self).into(); - output + let output: [u32; 3] = ::glam::UVec3::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -22940,11 +22053,10 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::UVec3::truncate( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::UVec2 = ::glam::UVec3::truncate( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -22957,12 +22069,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, x: u32| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec3::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::UVec3::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -22975,12 +22086,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, y: u32| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec3::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::UVec3::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -22993,12 +22103,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, z: u32| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec3::with_z( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::UVec3::with_z( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -23011,12 +22120,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec3::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::UVec3::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -23029,12 +22137,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::IVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec3::wrapping_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::UVec3::wrapping_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -23047,12 +22154,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec3::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::UVec3::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -23065,12 +22171,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec3::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::UVec3::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -23083,12 +22188,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { |_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec3::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::UVec3::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -23098,7 +22202,11 @@ pub(crate) fn register_u_vec_3_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::UVec3, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::UVec3, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_u_vec_4_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -23109,11 +22217,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Ref<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Add< + let output: ::glam::UVec4 = <::glam::UVec4 as ::core::ops::Add< &::glam::UVec4, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -23126,11 +22233,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Add< + let output: ::glam::UVec4 = <::glam::UVec4 as ::core::ops::Add< ::glam::UVec4, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -23143,11 +22249,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: u32| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Add< + let output: ::glam::UVec4 = <::glam::UVec4 as ::core::ops::Add< u32, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -23160,9 +22265,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Ref<::glam::UVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::UVec4::as_dvec4(&_self) - .into(); - output + let output: ::glam::DVec4 = ::glam::UVec4::as_dvec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -23175,11 +22281,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Ref<::glam::UVec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::UVec4::as_i16vec4( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::UVec4::as_i16vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -23192,11 +22297,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Ref<::glam::UVec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::UVec4::as_i64vec4( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::UVec4::as_i64vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -23209,11 +22313,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Ref<::glam::UVec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::UVec4::as_i8vec4( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::UVec4::as_i8vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -23226,9 +22329,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Ref<::glam::UVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::UVec4::as_ivec4(&_self) - .into(); - output + let output: ::glam::IVec4 = ::glam::UVec4::as_ivec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -23241,11 +22345,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Ref<::glam::UVec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::UVec4::as_u16vec4( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::UVec4::as_u16vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -23258,11 +22361,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Ref<::glam::UVec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::UVec4::as_u64vec4( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::UVec4::as_u64vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -23275,11 +22377,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Ref<::glam::UVec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::UVec4::as_u8vec4( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::UVec4::as_u8vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -23292,9 +22393,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Ref<::glam::UVec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::UVec4::as_vec4(&_self) - .into(); - output + let output: ::glam::Vec4 = ::glam::UVec4::as_vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -23308,10 +22410,9 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { let output: () = { { let output: () = <::glam::UVec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -23325,11 +22426,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::UVec4::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -23343,11 +22443,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::UVec4::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -23364,13 +22463,12 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::UVec4::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::UVec4::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -23383,11 +22481,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Ref<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::UVec4 = <::glam::UVec4 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -23400,12 +22497,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::UVec4::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::UVec4::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -23418,12 +22514,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::UVec4::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::UVec4::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -23436,12 +22531,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::UVec4::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::UVec4::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -23454,12 +22548,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::UVec4::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::UVec4::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -23472,12 +22565,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::UVec4::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::UVec4::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -23490,12 +22582,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::UVec4::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::UVec4::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -23508,11 +22599,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Ref<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Div< + let output: ::glam::UVec4 = <::glam::UVec4 as ::core::ops::Div< &::glam::UVec4, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -23525,11 +22615,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Div< + let output: ::glam::UVec4 = <::glam::UVec4 as ::core::ops::Div< ::glam::UVec4, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -23542,11 +22631,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: u32| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Div< + let output: ::glam::UVec4 = <::glam::UVec4 as ::core::ops::Div< u32, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -23560,11 +22648,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::UVec4::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -23577,12 +22664,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::UVec4::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::UVec4::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -23596,10 +22682,9 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::UVec4::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -23612,9 +22697,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>| { let output: u32 = { { - let output: u32 = ::glam::UVec4::element_sum(_self.into_inner()) - .into(); - output + let output: u32 = ::glam::UVec4::element_sum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -23629,9 +22715,8 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { { let output: bool = <::glam::UVec4 as ::core::cmp::PartialEq< ::glam::UVec4, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -23644,9 +22729,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |a: [u32; 4]| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::UVec4::from_array(a) - .into(); - output + let output: ::glam::UVec4 = ::glam::UVec4::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -23660,10 +22746,9 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::UVec4::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -23677,11 +22762,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::UVec4::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -23694,12 +22778,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::UVec4::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::UVec4::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -23712,9 +22795,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>| { let output: u32 = { { - let output: u32 = ::glam::UVec4::max_element(_self.into_inner()) - .into(); - output + let output: u32 = ::glam::UVec4::max_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -23728,10 +22812,9 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::UVec4::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -23744,12 +22827,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::UVec4::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::UVec4::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -23762,9 +22844,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>| { let output: u32 = { { - let output: u32 = ::glam::UVec4::min_element(_self.into_inner()) - .into(); - output + let output: u32 = ::glam::UVec4::min_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -23778,10 +22861,9 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::UVec4::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -23794,11 +22876,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Ref<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Mul< + let output: ::glam::UVec4 = <::glam::UVec4 as ::core::ops::Mul< &::glam::UVec4, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -23811,11 +22892,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Mul< + let output: ::glam::UVec4 = <::glam::UVec4 as ::core::ops::Mul< ::glam::UVec4, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -23828,11 +22908,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: u32| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Mul< + let output: ::glam::UVec4 = <::glam::UVec4 as ::core::ops::Mul< u32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -23845,9 +22924,13 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |x: u32, y: u32, z: u32, w: u32| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::UVec4::new(x, y, z, w) - .into(); - output + let output: ::glam::UVec4 = ::glam::UVec4::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -23860,11 +22943,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Ref<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Rem< + let output: ::glam::UVec4 = <::glam::UVec4 as ::core::ops::Rem< &::glam::UVec4, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -23877,11 +22959,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Rem< + let output: ::glam::UVec4 = <::glam::UVec4 as ::core::ops::Rem< ::glam::UVec4, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -23894,11 +22975,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: u32| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Rem< + let output: ::glam::UVec4 = <::glam::UVec4 as ::core::ops::Rem< u32, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -23911,12 +22991,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::UVec4::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::UVec4::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -23929,12 +23008,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::UVec4::saturating_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::UVec4::saturating_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -23947,12 +23025,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::UVec4::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::UVec4::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -23965,12 +23042,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::UVec4::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::UVec4::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -23983,12 +23059,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::UVec4::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::UVec4::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -24005,13 +23080,12 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::UVec4::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::UVec4::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -24024,8 +23098,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |v: u32| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::UVec4::splat(v).into(); - output + let output: ::glam::UVec4 = ::glam::UVec4::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -24038,11 +23114,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Ref<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Sub< + let output: ::glam::UVec4 = <::glam::UVec4 as ::core::ops::Sub< &::glam::UVec4, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -24055,11 +23130,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Sub< + let output: ::glam::UVec4 = <::glam::UVec4 as ::core::ops::Sub< ::glam::UVec4, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -24072,11 +23146,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: u32| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Sub< + let output: ::glam::UVec4 = <::glam::UVec4 as ::core::ops::Sub< u32, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -24089,8 +23162,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Ref<::glam::UVec4>| { let output: [u32; 4] = { { - let output: [u32; 4] = ::glam::UVec4::to_array(&_self).into(); - output + let output: [u32; 4] = ::glam::UVec4::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -24103,11 +23178,10 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::UVec4::truncate( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::UVec4::truncate( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -24120,12 +23194,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, w: u32| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::UVec4::with_w( - _self.into_inner(), - w, - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::UVec4::with_w( + safe_transmute(_self), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -24138,12 +23211,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, x: u32| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::UVec4::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::UVec4::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -24156,12 +23228,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, y: u32| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::UVec4::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::UVec4::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -24174,12 +23245,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, z: u32| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::UVec4::with_z( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::UVec4::with_z( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -24192,12 +23262,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::UVec4::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::UVec4::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -24210,12 +23279,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::IVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::UVec4::wrapping_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::UVec4::wrapping_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -24228,12 +23296,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::UVec4::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::UVec4::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -24246,12 +23313,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::UVec4::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::UVec4::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -24264,12 +23330,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { |_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::UVec4::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::UVec4::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -24279,7 +23344,11 @@ pub(crate) fn register_u_vec_4_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::UVec4, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::UVec4, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -24290,11 +23359,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Ref<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Add< + let output: ::glam::U8Vec2 = <::glam::U8Vec2 as ::core::ops::Add< &::glam::U8Vec2, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -24307,11 +23375,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Add< + let output: ::glam::U8Vec2 = <::glam::U8Vec2 as ::core::ops::Add< ::glam::U8Vec2, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -24324,11 +23391,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: u8| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Add< + let output: ::glam::U8Vec2 = <::glam::U8Vec2 as ::core::ops::Add< u8, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -24341,9 +23407,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U8Vec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::U8Vec2::as_dvec2(&_self) - .into(); - output + let output: ::glam::DVec2 = ::glam::U8Vec2::as_dvec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -24356,11 +23423,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U8Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::U8Vec2::as_i16vec2( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::U8Vec2::as_i16vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -24373,11 +23439,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U8Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::U8Vec2::as_i64vec2( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::U8Vec2::as_i64vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -24390,11 +23455,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U8Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::U8Vec2::as_i8vec2( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::U8Vec2::as_i8vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -24407,9 +23471,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U8Vec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::U8Vec2::as_ivec2(&_self) - .into(); - output + let output: ::glam::IVec2 = ::glam::U8Vec2::as_ivec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -24422,11 +23487,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U8Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::U8Vec2::as_u16vec2( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::U8Vec2::as_u16vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -24439,11 +23503,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U8Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::U8Vec2::as_u64vec2( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::U8Vec2::as_u64vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -24456,9 +23519,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U8Vec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::U8Vec2::as_uvec2(&_self) - .into(); - output + let output: ::glam::UVec2 = ::glam::U8Vec2::as_uvec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -24471,9 +23535,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U8Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::U8Vec2::as_vec2(&_self) - .into(); - output + let output: ::glam::Vec2 = ::glam::U8Vec2::as_vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -24487,10 +23552,9 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { let output: () = { { let output: () = <::glam::U8Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -24504,11 +23568,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { let output: u8 = { { let output: u8 = ::glam::U8Vec2::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -24522,11 +23585,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::U8Vec2::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -24543,13 +23605,12 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::U8Vec2::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -24562,11 +23623,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec2 = <::glam::U8Vec2 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -24579,12 +23639,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::U8Vec2::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::U8Vec2::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -24597,12 +23656,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::U8Vec2::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::U8Vec2::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -24615,12 +23673,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::U8Vec2::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::U8Vec2::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -24633,12 +23690,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::U8Vec2::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::U8Vec2::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -24651,12 +23707,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::U8Vec2::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::U8Vec2::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -24669,12 +23724,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::U8Vec2::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::U8Vec2::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -24687,11 +23741,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Ref<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Div< + let output: ::glam::U8Vec2 = <::glam::U8Vec2 as ::core::ops::Div< &::glam::U8Vec2, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -24704,11 +23757,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Div< + let output: ::glam::U8Vec2 = <::glam::U8Vec2 as ::core::ops::Div< ::glam::U8Vec2, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -24721,11 +23773,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: u8| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Div< + let output: ::glam::U8Vec2 = <::glam::U8Vec2 as ::core::ops::Div< u8, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -24739,11 +23790,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { let output: u8 = { { let output: u8 = ::glam::U8Vec2::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -24756,12 +23806,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::U8Vec2::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -24775,10 +23824,9 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { let output: u8 = { { let output: u8 = ::glam::U8Vec2::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -24791,9 +23839,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>| { let output: u8 = { { - let output: u8 = ::glam::U8Vec2::element_sum(_self.into_inner()) - .into(); - output + let output: u8 = ::glam::U8Vec2::element_sum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -24808,9 +23857,8 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { { let output: bool = <::glam::U8Vec2 as ::core::cmp::PartialEq< ::glam::U8Vec2, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -24823,12 +23871,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, z: u8| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec2::extend( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec2::extend( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -24841,9 +23888,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |a: [u8; 2]| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::from_array(a) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::U8Vec2::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -24857,10 +23905,9 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { let output: u8 = { { let output: u8 = ::glam::U8Vec2::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -24874,11 +23921,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { let output: u8 = { { let output: u8 = ::glam::U8Vec2::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -24891,12 +23937,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::U8Vec2::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -24909,9 +23954,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>| { let output: u8 = { { - let output: u8 = ::glam::U8Vec2::max_element(_self.into_inner()) - .into(); - output + let output: u8 = ::glam::U8Vec2::max_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -24925,10 +23971,9 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::U8Vec2::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -24941,12 +23986,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::U8Vec2::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -24959,9 +24003,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>| { let output: u8 = { { - let output: u8 = ::glam::U8Vec2::min_element(_self.into_inner()) - .into(); - output + let output: u8 = ::glam::U8Vec2::min_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -24975,10 +24020,9 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::U8Vec2::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -24991,11 +24035,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Ref<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Mul< + let output: ::glam::U8Vec2 = <::glam::U8Vec2 as ::core::ops::Mul< &::glam::U8Vec2, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -25008,11 +24051,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Mul< + let output: ::glam::U8Vec2 = <::glam::U8Vec2 as ::core::ops::Mul< ::glam::U8Vec2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -25025,11 +24067,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: u8| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Mul< + let output: ::glam::U8Vec2 = <::glam::U8Vec2 as ::core::ops::Mul< u8, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -25042,9 +24083,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |x: u8, y: u8| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::new(x, y) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::U8Vec2::new( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -25057,11 +24100,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Ref<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Rem< + let output: ::glam::U8Vec2 = <::glam::U8Vec2 as ::core::ops::Rem< &::glam::U8Vec2, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -25074,11 +24116,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Rem< + let output: ::glam::U8Vec2 = <::glam::U8Vec2 as ::core::ops::Rem< ::glam::U8Vec2, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -25091,11 +24132,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: u8| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Rem< + let output: ::glam::U8Vec2 = <::glam::U8Vec2 as ::core::ops::Rem< u8, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -25108,12 +24148,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::U8Vec2::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -25126,12 +24165,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::saturating_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::U8Vec2::saturating_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -25144,12 +24182,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::U8Vec2::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -25162,12 +24199,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::U8Vec2::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -25180,12 +24216,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::U8Vec2::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -25202,13 +24237,12 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::U8Vec2::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -25221,9 +24255,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |v: u8| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::splat(v) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::U8Vec2::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -25236,11 +24271,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Ref<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Sub< + let output: ::glam::U8Vec2 = <::glam::U8Vec2 as ::core::ops::Sub< &::glam::U8Vec2, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -25253,11 +24287,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Sub< + let output: ::glam::U8Vec2 = <::glam::U8Vec2 as ::core::ops::Sub< ::glam::U8Vec2, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -25270,11 +24303,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: u8| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Sub< + let output: ::glam::U8Vec2 = <::glam::U8Vec2 as ::core::ops::Sub< u8, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -25287,8 +24319,10 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U8Vec2>| { let output: [u8; 2] = { { - let output: [u8; 2] = ::glam::U8Vec2::to_array(&_self).into(); - output + let output: [u8; 2] = ::glam::U8Vec2::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -25301,12 +24335,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, x: u8| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::U8Vec2::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -25319,12 +24352,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, y: u8| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::U8Vec2::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -25337,12 +24369,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::U8Vec2::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -25355,12 +24386,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::I8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::wrapping_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::U8Vec2::wrapping_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -25373,12 +24403,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::U8Vec2::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -25391,12 +24420,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::U8Vec2::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -25409,12 +24437,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { |_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::U8Vec2::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -25424,7 +24451,11 @@ pub(crate) fn register_u_8_vec_2_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::U8Vec2, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::U8Vec2, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -25435,11 +24466,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Ref<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Add< + let output: ::glam::U8Vec3 = <::glam::U8Vec3 as ::core::ops::Add< &::glam::U8Vec3, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -25452,11 +24482,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Add< + let output: ::glam::U8Vec3 = <::glam::U8Vec3 as ::core::ops::Add< ::glam::U8Vec3, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -25469,11 +24498,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: u8| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Add< + let output: ::glam::U8Vec3 = <::glam::U8Vec3 as ::core::ops::Add< u8, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -25486,9 +24514,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U8Vec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::U8Vec3::as_dvec3(&_self) - .into(); - output + let output: ::glam::DVec3 = ::glam::U8Vec3::as_dvec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -25501,11 +24530,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U8Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::U8Vec3::as_i16vec3( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::U8Vec3::as_i16vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -25518,11 +24546,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U8Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::U8Vec3::as_i64vec3( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::U8Vec3::as_i64vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -25535,11 +24562,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U8Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::U8Vec3::as_i8vec3( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::U8Vec3::as_i8vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -25552,9 +24578,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U8Vec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::U8Vec3::as_ivec3(&_self) - .into(); - output + let output: ::glam::IVec3 = ::glam::U8Vec3::as_ivec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -25567,11 +24594,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U8Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U8Vec3::as_u16vec3( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U8Vec3::as_u16vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -25584,11 +24610,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U8Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U8Vec3::as_u64vec3( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U8Vec3::as_u64vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -25601,9 +24626,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U8Vec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::U8Vec3::as_uvec3(&_self) - .into(); - output + let output: ::glam::UVec3 = ::glam::U8Vec3::as_uvec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -25616,9 +24642,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U8Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::U8Vec3::as_vec3(&_self) - .into(); - output + let output: ::glam::Vec3 = ::glam::U8Vec3::as_vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -25631,9 +24658,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U8Vec3>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::U8Vec3::as_vec3a(&_self) - .into(); - output + let output: ::glam::Vec3A = ::glam::U8Vec3::as_vec3a( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -25647,10 +24675,9 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { let output: () = { { let output: () = <::glam::U8Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -25664,11 +24691,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { let output: u8 = { { let output: u8 = ::glam::U8Vec3::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -25682,11 +24708,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::U8Vec3::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -25703,13 +24728,12 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec3::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -25722,11 +24746,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec3 = <::glam::U8Vec3 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -25739,12 +24762,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::U8Vec3::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::U8Vec3::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -25757,12 +24779,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::U8Vec3::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::U8Vec3::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -25775,12 +24796,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::U8Vec3::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::U8Vec3::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -25793,12 +24813,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::U8Vec3::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::U8Vec3::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -25811,12 +24830,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::U8Vec3::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::U8Vec3::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -25829,12 +24847,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::U8Vec3::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::U8Vec3::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -25847,12 +24864,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::cross( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec3::cross( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -25865,11 +24881,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Ref<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Div< + let output: ::glam::U8Vec3 = <::glam::U8Vec3 as ::core::ops::Div< &::glam::U8Vec3, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -25882,11 +24897,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Div< + let output: ::glam::U8Vec3 = <::glam::U8Vec3 as ::core::ops::Div< ::glam::U8Vec3, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -25899,11 +24913,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: u8| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Div< + let output: ::glam::U8Vec3 = <::glam::U8Vec3 as ::core::ops::Div< u8, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -25917,11 +24930,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { let output: u8 = { { let output: u8 = ::glam::U8Vec3::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -25934,12 +24946,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec3::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -25953,10 +24964,9 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { let output: u8 = { { let output: u8 = ::glam::U8Vec3::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -25969,9 +24979,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>| { let output: u8 = { { - let output: u8 = ::glam::U8Vec3::element_sum(_self.into_inner()) - .into(); - output + let output: u8 = ::glam::U8Vec3::element_sum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -25986,9 +24997,8 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { { let output: bool = <::glam::U8Vec3 as ::core::cmp::PartialEq< ::glam::U8Vec3, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -26001,12 +25011,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, w: u8| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U8Vec3::extend( - _self.into_inner(), - w, - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U8Vec3::extend( + safe_transmute(_self), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -26019,9 +25028,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |a: [u8; 3]| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::from_array(a) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec3::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -26035,10 +25045,9 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { let output: u8 = { { let output: u8 = ::glam::U8Vec3::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -26052,11 +25061,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { let output: u8 = { { let output: u8 = ::glam::U8Vec3::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -26069,12 +25077,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec3::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -26087,9 +25094,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>| { let output: u8 = { { - let output: u8 = ::glam::U8Vec3::max_element(_self.into_inner()) - .into(); - output + let output: u8 = ::glam::U8Vec3::max_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -26103,10 +25111,9 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::U8Vec3::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -26119,12 +25126,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec3::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -26137,9 +25143,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>| { let output: u8 = { { - let output: u8 = ::glam::U8Vec3::min_element(_self.into_inner()) - .into(); - output + let output: u8 = ::glam::U8Vec3::min_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -26153,10 +25160,9 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::U8Vec3::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -26169,11 +25175,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Ref<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Mul< + let output: ::glam::U8Vec3 = <::glam::U8Vec3 as ::core::ops::Mul< &::glam::U8Vec3, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -26186,11 +25191,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Mul< + let output: ::glam::U8Vec3 = <::glam::U8Vec3 as ::core::ops::Mul< ::glam::U8Vec3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -26203,11 +25207,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: u8| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Mul< + let output: ::glam::U8Vec3 = <::glam::U8Vec3 as ::core::ops::Mul< u8, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -26220,9 +25223,12 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |x: u8, y: u8, z: u8| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::new(x, y, z) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec3::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -26235,11 +25241,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Ref<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Rem< + let output: ::glam::U8Vec3 = <::glam::U8Vec3 as ::core::ops::Rem< &::glam::U8Vec3, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -26252,11 +25257,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Rem< + let output: ::glam::U8Vec3 = <::glam::U8Vec3 as ::core::ops::Rem< ::glam::U8Vec3, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -26269,11 +25273,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: u8| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Rem< + let output: ::glam::U8Vec3 = <::glam::U8Vec3 as ::core::ops::Rem< u8, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -26286,12 +25289,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec3::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -26304,12 +25306,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::saturating_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec3::saturating_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -26322,12 +25323,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec3::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -26340,12 +25340,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec3::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -26358,12 +25357,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec3::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -26380,13 +25378,12 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec3::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -26399,9 +25396,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |v: u8| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::splat(v) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec3::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -26414,11 +25412,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Ref<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Sub< + let output: ::glam::U8Vec3 = <::glam::U8Vec3 as ::core::ops::Sub< &::glam::U8Vec3, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -26431,11 +25428,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Sub< + let output: ::glam::U8Vec3 = <::glam::U8Vec3 as ::core::ops::Sub< ::glam::U8Vec3, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -26448,11 +25444,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: u8| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Sub< + let output: ::glam::U8Vec3 = <::glam::U8Vec3 as ::core::ops::Sub< u8, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -26465,8 +25460,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U8Vec3>| { let output: [u8; 3] = { { - let output: [u8; 3] = ::glam::U8Vec3::to_array(&_self).into(); - output + let output: [u8; 3] = ::glam::U8Vec3::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -26479,11 +25476,10 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::U8Vec3::truncate( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::U8Vec3::truncate( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -26496,12 +25492,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, x: u8| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec3::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -26514,12 +25509,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, y: u8| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec3::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -26532,12 +25526,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, z: u8| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::with_z( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec3::with_z( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -26550,12 +25543,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec3::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -26568,12 +25560,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::I8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::wrapping_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec3::wrapping_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -26586,12 +25577,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec3::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -26604,12 +25594,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec3::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -26622,12 +25611,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { |_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec3::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -26637,7 +25625,11 @@ pub(crate) fn register_u_8_vec_3_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::U8Vec3, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::U8Vec3, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -26648,11 +25640,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Ref<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Add< + let output: ::glam::U8Vec4 = <::glam::U8Vec4 as ::core::ops::Add< &::glam::U8Vec4, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -26665,11 +25656,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Add< + let output: ::glam::U8Vec4 = <::glam::U8Vec4 as ::core::ops::Add< ::glam::U8Vec4, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -26682,11 +25672,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: u8| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Add< + let output: ::glam::U8Vec4 = <::glam::U8Vec4 as ::core::ops::Add< u8, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -26699,9 +25688,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U8Vec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::U8Vec4::as_dvec4(&_self) - .into(); - output + let output: ::glam::DVec4 = ::glam::U8Vec4::as_dvec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -26714,11 +25704,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U8Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::U8Vec4::as_i16vec4( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::U8Vec4::as_i16vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -26731,11 +25720,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U8Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::U8Vec4::as_i64vec4( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::U8Vec4::as_i64vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -26748,11 +25736,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U8Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::U8Vec4::as_i8vec4( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::U8Vec4::as_i8vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -26765,9 +25752,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U8Vec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::U8Vec4::as_ivec4(&_self) - .into(); - output + let output: ::glam::IVec4 = ::glam::U8Vec4::as_ivec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -26780,11 +25768,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U8Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U8Vec4::as_u16vec4( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U8Vec4::as_u16vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -26797,11 +25784,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U8Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U8Vec4::as_u64vec4( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U8Vec4::as_u64vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -26814,9 +25800,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U8Vec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::U8Vec4::as_uvec4(&_self) - .into(); - output + let output: ::glam::UVec4 = ::glam::U8Vec4::as_uvec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -26829,9 +25816,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U8Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::U8Vec4::as_vec4(&_self) - .into(); - output + let output: ::glam::Vec4 = ::glam::U8Vec4::as_vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -26845,10 +25833,9 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { let output: () = { { let output: () = <::glam::U8Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -26862,11 +25849,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { let output: u8 = { { let output: u8 = ::glam::U8Vec4::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -26880,11 +25866,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::U8Vec4::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -26901,13 +25886,12 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U8Vec4::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -26920,11 +25904,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec4 = <::glam::U8Vec4 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -26937,12 +25920,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::U8Vec4::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::U8Vec4::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -26955,12 +25937,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::U8Vec4::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::U8Vec4::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -26973,12 +25954,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::U8Vec4::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::U8Vec4::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -26991,12 +25971,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::U8Vec4::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::U8Vec4::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -27009,12 +25988,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::U8Vec4::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::U8Vec4::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -27027,12 +26005,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::U8Vec4::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::U8Vec4::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -27045,11 +26022,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Ref<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Div< + let output: ::glam::U8Vec4 = <::glam::U8Vec4 as ::core::ops::Div< &::glam::U8Vec4, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -27062,11 +26038,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Div< + let output: ::glam::U8Vec4 = <::glam::U8Vec4 as ::core::ops::Div< ::glam::U8Vec4, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -27079,11 +26054,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: u8| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Div< + let output: ::glam::U8Vec4 = <::glam::U8Vec4 as ::core::ops::Div< u8, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -27097,11 +26071,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { let output: u8 = { { let output: u8 = ::glam::U8Vec4::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -27114,12 +26087,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U8Vec4::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -27133,10 +26105,9 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { let output: u8 = { { let output: u8 = ::glam::U8Vec4::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -27149,9 +26120,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>| { let output: u8 = { { - let output: u8 = ::glam::U8Vec4::element_sum(_self.into_inner()) - .into(); - output + let output: u8 = ::glam::U8Vec4::element_sum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -27166,9 +26138,8 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { { let output: bool = <::glam::U8Vec4 as ::core::cmp::PartialEq< ::glam::U8Vec4, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -27181,9 +26152,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |a: [u8; 4]| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::from_array(a) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U8Vec4::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -27197,10 +26169,9 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { let output: u8 = { { let output: u8 = ::glam::U8Vec4::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -27214,11 +26185,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { let output: u8 = { { let output: u8 = ::glam::U8Vec4::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -27231,12 +26201,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U8Vec4::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -27249,9 +26218,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>| { let output: u8 = { { - let output: u8 = ::glam::U8Vec4::max_element(_self.into_inner()) - .into(); - output + let output: u8 = ::glam::U8Vec4::max_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -27265,10 +26235,9 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::U8Vec4::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -27281,12 +26250,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U8Vec4::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -27299,9 +26267,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>| { let output: u8 = { { - let output: u8 = ::glam::U8Vec4::min_element(_self.into_inner()) - .into(); - output + let output: u8 = ::glam::U8Vec4::min_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -27315,10 +26284,9 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::U8Vec4::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -27331,11 +26299,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Ref<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Mul< + let output: ::glam::U8Vec4 = <::glam::U8Vec4 as ::core::ops::Mul< &::glam::U8Vec4, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -27348,11 +26315,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Mul< + let output: ::glam::U8Vec4 = <::glam::U8Vec4 as ::core::ops::Mul< ::glam::U8Vec4, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -27365,11 +26331,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: u8| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Mul< + let output: ::glam::U8Vec4 = <::glam::U8Vec4 as ::core::ops::Mul< u8, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -27382,9 +26347,13 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |x: u8, y: u8, z: u8, w: u8| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::new(x, y, z, w) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U8Vec4::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -27397,11 +26366,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Ref<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Rem< + let output: ::glam::U8Vec4 = <::glam::U8Vec4 as ::core::ops::Rem< &::glam::U8Vec4, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -27414,11 +26382,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Rem< + let output: ::glam::U8Vec4 = <::glam::U8Vec4 as ::core::ops::Rem< ::glam::U8Vec4, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -27431,11 +26398,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: u8| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Rem< + let output: ::glam::U8Vec4 = <::glam::U8Vec4 as ::core::ops::Rem< u8, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -27448,12 +26414,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U8Vec4::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -27466,12 +26431,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::saturating_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U8Vec4::saturating_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -27484,12 +26448,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U8Vec4::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -27502,12 +26465,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U8Vec4::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -27520,12 +26482,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U8Vec4::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -27542,13 +26503,12 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U8Vec4::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -27561,9 +26521,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |v: u8| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::splat(v) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U8Vec4::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -27576,11 +26537,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Ref<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Sub< + let output: ::glam::U8Vec4 = <::glam::U8Vec4 as ::core::ops::Sub< &::glam::U8Vec4, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -27593,11 +26553,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Sub< + let output: ::glam::U8Vec4 = <::glam::U8Vec4 as ::core::ops::Sub< ::glam::U8Vec4, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -27610,11 +26569,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: u8| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Sub< + let output: ::glam::U8Vec4 = <::glam::U8Vec4 as ::core::ops::Sub< u8, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -27627,8 +26585,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U8Vec4>| { let output: [u8; 4] = { { - let output: [u8; 4] = ::glam::U8Vec4::to_array(&_self).into(); - output + let output: [u8; 4] = ::glam::U8Vec4::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -27641,11 +26601,10 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U8Vec4::truncate( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U8Vec4::truncate( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -27658,12 +26617,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, w: u8| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::with_w( - _self.into_inner(), - w, - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U8Vec4::with_w( + safe_transmute(_self), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -27676,12 +26634,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, x: u8| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U8Vec4::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -27694,12 +26651,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, y: u8| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U8Vec4::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -27712,12 +26668,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, z: u8| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::with_z( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U8Vec4::with_z( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -27730,12 +26685,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U8Vec4::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -27748,12 +26702,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::I8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::wrapping_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U8Vec4::wrapping_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -27766,12 +26719,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U8Vec4::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -27784,12 +26736,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U8Vec4::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -27802,12 +26753,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { |_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U8Vec4::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -27817,7 +26767,11 @@ pub(crate) fn register_u_8_vec_4_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::U8Vec4, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::U8Vec4, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -27828,11 +26782,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Ref<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Add< + let output: ::glam::U16Vec2 = <::glam::U16Vec2 as ::core::ops::Add< &::glam::U16Vec2, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -27845,11 +26798,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Add< + let output: ::glam::U16Vec2 = <::glam::U16Vec2 as ::core::ops::Add< ::glam::U16Vec2, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -27862,11 +26814,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: u16| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Add< + let output: ::glam::U16Vec2 = <::glam::U16Vec2 as ::core::ops::Add< u16, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -27879,11 +26830,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U16Vec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::U16Vec2::as_dvec2( - &_self, - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::U16Vec2::as_dvec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -27896,11 +26846,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U16Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::U16Vec2::as_i16vec2( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::U16Vec2::as_i16vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -27913,11 +26862,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U16Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::U16Vec2::as_i64vec2( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::U16Vec2::as_i64vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -27930,11 +26878,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U16Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::U16Vec2::as_i8vec2( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::U16Vec2::as_i8vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -27947,11 +26894,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U16Vec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::U16Vec2::as_ivec2( - &_self, - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::U16Vec2::as_ivec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -27964,11 +26910,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U16Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::U16Vec2::as_u64vec2( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::U16Vec2::as_u64vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -27981,11 +26926,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U16Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::U16Vec2::as_u8vec2( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::U16Vec2::as_u8vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -27998,11 +26942,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U16Vec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::U16Vec2::as_uvec2( - &_self, - ) - .into(); - output + let output: ::glam::UVec2 = ::glam::U16Vec2::as_uvec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -28015,9 +26958,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U16Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::U16Vec2::as_vec2(&_self) - .into(); - output + let output: ::glam::Vec2 = ::glam::U16Vec2::as_vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -28031,10 +26975,9 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { let output: () = { { let output: () = <::glam::U16Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -28048,11 +26991,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec2::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -28066,11 +27008,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::U16Vec2::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -28087,13 +27028,12 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::U16Vec2::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -28106,11 +27046,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec2 = <::glam::U16Vec2 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -28123,12 +27062,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::U16Vec2::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::U16Vec2::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -28141,12 +27079,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::U16Vec2::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::U16Vec2::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -28159,12 +27096,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::U16Vec2::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::U16Vec2::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -28177,12 +27113,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::U16Vec2::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::U16Vec2::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -28195,12 +27130,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::U16Vec2::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::U16Vec2::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -28213,12 +27147,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::U16Vec2::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::U16Vec2::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -28231,11 +27164,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Ref<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Div< + let output: ::glam::U16Vec2 = <::glam::U16Vec2 as ::core::ops::Div< &::glam::U16Vec2, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -28248,11 +27180,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Div< + let output: ::glam::U16Vec2 = <::glam::U16Vec2 as ::core::ops::Div< ::glam::U16Vec2, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -28265,11 +27196,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: u16| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Div< + let output: ::glam::U16Vec2 = <::glam::U16Vec2 as ::core::ops::Div< u16, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -28283,11 +27213,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec2::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -28300,12 +27229,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::U16Vec2::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -28319,10 +27247,9 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec2::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -28336,10 +27263,9 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec2::element_sum( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -28354,9 +27280,8 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { { let output: bool = <::glam::U16Vec2 as ::core::cmp::PartialEq< ::glam::U16Vec2, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -28369,12 +27294,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, z: u16| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec2::extend( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec2::extend( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -28387,9 +27311,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |a: [u16; 2]| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::from_array(a) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::U16Vec2::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -28403,10 +27328,9 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec2::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -28420,11 +27344,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec2::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -28437,12 +27360,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::U16Vec2::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -28456,10 +27378,9 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec2::max_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -28473,10 +27394,9 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::U16Vec2::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -28489,12 +27409,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::U16Vec2::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -28508,10 +27427,9 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec2::min_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -28525,10 +27443,9 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::U16Vec2::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -28541,11 +27458,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Ref<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Mul< + let output: ::glam::U16Vec2 = <::glam::U16Vec2 as ::core::ops::Mul< &::glam::U16Vec2, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -28558,11 +27474,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Mul< + let output: ::glam::U16Vec2 = <::glam::U16Vec2 as ::core::ops::Mul< ::glam::U16Vec2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -28575,11 +27490,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: u16| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Mul< + let output: ::glam::U16Vec2 = <::glam::U16Vec2 as ::core::ops::Mul< u16, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -28592,9 +27506,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |x: u16, y: u16| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::new(x, y) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::U16Vec2::new( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -28607,11 +27523,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Ref<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Rem< + let output: ::glam::U16Vec2 = <::glam::U16Vec2 as ::core::ops::Rem< &::glam::U16Vec2, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -28624,11 +27539,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Rem< + let output: ::glam::U16Vec2 = <::glam::U16Vec2 as ::core::ops::Rem< ::glam::U16Vec2, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -28641,11 +27555,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: u16| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Rem< + let output: ::glam::U16Vec2 = <::glam::U16Vec2 as ::core::ops::Rem< u16, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -28658,12 +27571,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::U16Vec2::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -28676,12 +27588,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::saturating_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::U16Vec2::saturating_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -28694,12 +27605,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::U16Vec2::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -28712,12 +27622,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::U16Vec2::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -28730,12 +27639,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::U16Vec2::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -28752,13 +27660,12 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::U16Vec2::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -28771,9 +27678,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |v: u16| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::splat(v) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::U16Vec2::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -28786,11 +27694,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Ref<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Sub< + let output: ::glam::U16Vec2 = <::glam::U16Vec2 as ::core::ops::Sub< &::glam::U16Vec2, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -28803,11 +27710,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Sub< + let output: ::glam::U16Vec2 = <::glam::U16Vec2 as ::core::ops::Sub< ::glam::U16Vec2, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -28820,11 +27726,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: u16| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Sub< + let output: ::glam::U16Vec2 = <::glam::U16Vec2 as ::core::ops::Sub< u16, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -28837,8 +27742,10 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U16Vec2>| { let output: [u16; 2] = { { - let output: [u16; 2] = ::glam::U16Vec2::to_array(&_self).into(); - output + let output: [u16; 2] = ::glam::U16Vec2::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -28851,12 +27758,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, x: u16| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::U16Vec2::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -28869,12 +27775,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, y: u16| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::U16Vec2::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -28887,12 +27792,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::U16Vec2::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -28905,12 +27809,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::I16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::wrapping_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::U16Vec2::wrapping_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -28923,12 +27826,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::U16Vec2::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -28941,12 +27843,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::U16Vec2::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -28959,12 +27860,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { |_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::U16Vec2::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -28974,7 +27874,11 @@ pub(crate) fn register_u_16_vec_2_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::U16Vec2, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::U16Vec2, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -28985,11 +27889,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Ref<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Add< + let output: ::glam::U16Vec3 = <::glam::U16Vec3 as ::core::ops::Add< &::glam::U16Vec3, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -29002,11 +27905,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Add< + let output: ::glam::U16Vec3 = <::glam::U16Vec3 as ::core::ops::Add< ::glam::U16Vec3, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -29019,11 +27921,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: u16| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Add< + let output: ::glam::U16Vec3 = <::glam::U16Vec3 as ::core::ops::Add< u16, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -29036,11 +27937,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U16Vec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::U16Vec3::as_dvec3( - &_self, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::U16Vec3::as_dvec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -29053,11 +27953,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U16Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::U16Vec3::as_i16vec3( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::U16Vec3::as_i16vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -29070,11 +27969,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U16Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::U16Vec3::as_i64vec3( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::U16Vec3::as_i64vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -29087,11 +27985,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U16Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::U16Vec3::as_i8vec3( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::U16Vec3::as_i8vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -29104,11 +28001,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U16Vec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::U16Vec3::as_ivec3( - &_self, - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::U16Vec3::as_ivec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -29121,11 +28017,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U16Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U16Vec3::as_u64vec3( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U16Vec3::as_u64vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -29138,11 +28033,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U16Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U16Vec3::as_u8vec3( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U16Vec3::as_u8vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -29155,11 +28049,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U16Vec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::U16Vec3::as_uvec3( - &_self, - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::U16Vec3::as_uvec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -29172,9 +28065,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U16Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::U16Vec3::as_vec3(&_self) - .into(); - output + let output: ::glam::Vec3 = ::glam::U16Vec3::as_vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -29187,11 +28081,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U16Vec3>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::U16Vec3::as_vec3a( - &_self, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::U16Vec3::as_vec3a( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -29205,10 +28098,9 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { let output: () = { { let output: () = <::glam::U16Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -29222,11 +28114,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec3::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -29240,11 +28131,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::U16Vec3::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -29261,13 +28151,12 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec3::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -29280,11 +28169,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec3 = <::glam::U16Vec3 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -29297,12 +28185,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::U16Vec3::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::U16Vec3::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -29315,12 +28202,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::U16Vec3::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::U16Vec3::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -29333,12 +28219,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::U16Vec3::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::U16Vec3::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -29351,12 +28236,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::U16Vec3::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::U16Vec3::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -29369,12 +28253,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::U16Vec3::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::U16Vec3::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -29387,12 +28270,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::U16Vec3::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::U16Vec3::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -29405,12 +28287,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::cross( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec3::cross( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -29423,11 +28304,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Ref<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Div< + let output: ::glam::U16Vec3 = <::glam::U16Vec3 as ::core::ops::Div< &::glam::U16Vec3, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -29440,11 +28320,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Div< + let output: ::glam::U16Vec3 = <::glam::U16Vec3 as ::core::ops::Div< ::glam::U16Vec3, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -29457,11 +28336,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: u16| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Div< + let output: ::glam::U16Vec3 = <::glam::U16Vec3 as ::core::ops::Div< u16, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -29475,11 +28353,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec3::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -29492,12 +28369,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec3::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -29511,10 +28387,9 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec3::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -29528,10 +28403,9 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec3::element_sum( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -29546,9 +28420,8 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { { let output: bool = <::glam::U16Vec3 as ::core::cmp::PartialEq< ::glam::U16Vec3, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -29561,12 +28434,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, w: u16| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U16Vec3::extend( - _self.into_inner(), - w, - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U16Vec3::extend( + safe_transmute(_self), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -29579,9 +28451,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |a: [u16; 3]| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::from_array(a) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec3::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -29595,10 +28468,9 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec3::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -29612,11 +28484,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec3::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -29629,12 +28500,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec3::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -29648,10 +28518,9 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec3::max_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -29665,10 +28534,9 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::U16Vec3::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -29681,12 +28549,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec3::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -29700,10 +28567,9 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec3::min_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -29717,10 +28583,9 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::U16Vec3::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -29733,11 +28598,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Ref<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Mul< + let output: ::glam::U16Vec3 = <::glam::U16Vec3 as ::core::ops::Mul< &::glam::U16Vec3, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -29750,11 +28614,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Mul< + let output: ::glam::U16Vec3 = <::glam::U16Vec3 as ::core::ops::Mul< ::glam::U16Vec3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -29767,11 +28630,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: u16| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Mul< + let output: ::glam::U16Vec3 = <::glam::U16Vec3 as ::core::ops::Mul< u16, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -29784,9 +28646,12 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |x: u16, y: u16, z: u16| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::new(x, y, z) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec3::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -29799,11 +28664,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Ref<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Rem< + let output: ::glam::U16Vec3 = <::glam::U16Vec3 as ::core::ops::Rem< &::glam::U16Vec3, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -29816,11 +28680,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Rem< + let output: ::glam::U16Vec3 = <::glam::U16Vec3 as ::core::ops::Rem< ::glam::U16Vec3, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -29833,11 +28696,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: u16| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Rem< + let output: ::glam::U16Vec3 = <::glam::U16Vec3 as ::core::ops::Rem< u16, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -29850,12 +28712,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec3::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -29868,12 +28729,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::saturating_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec3::saturating_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -29886,12 +28746,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec3::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -29904,12 +28763,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec3::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -29922,12 +28780,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec3::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -29944,13 +28801,12 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec3::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -29963,9 +28819,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |v: u16| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::splat(v) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec3::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -29978,11 +28835,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Ref<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Sub< + let output: ::glam::U16Vec3 = <::glam::U16Vec3 as ::core::ops::Sub< &::glam::U16Vec3, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -29995,11 +28851,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Sub< + let output: ::glam::U16Vec3 = <::glam::U16Vec3 as ::core::ops::Sub< ::glam::U16Vec3, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -30012,11 +28867,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: u16| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Sub< + let output: ::glam::U16Vec3 = <::glam::U16Vec3 as ::core::ops::Sub< u16, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -30029,8 +28883,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U16Vec3>| { let output: [u16; 3] = { { - let output: [u16; 3] = ::glam::U16Vec3::to_array(&_self).into(); - output + let output: [u16; 3] = ::glam::U16Vec3::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -30043,11 +28899,10 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::U16Vec3::truncate( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::U16Vec3::truncate( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -30060,12 +28915,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, x: u16| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec3::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -30078,12 +28932,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, y: u16| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec3::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -30096,12 +28949,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, z: u16| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::with_z( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec3::with_z( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -30114,12 +28966,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec3::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -30132,12 +28983,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::I16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::wrapping_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec3::wrapping_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -30150,12 +29000,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec3::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -30168,12 +29017,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec3::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -30186,12 +29034,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { |_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec3::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -30201,7 +29048,11 @@ pub(crate) fn register_u_16_vec_3_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::U16Vec3, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::U16Vec3, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -30212,11 +29063,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Ref<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Add< + let output: ::glam::U16Vec4 = <::glam::U16Vec4 as ::core::ops::Add< &::glam::U16Vec4, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -30229,11 +29079,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Add< + let output: ::glam::U16Vec4 = <::glam::U16Vec4 as ::core::ops::Add< ::glam::U16Vec4, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -30246,11 +29095,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: u16| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Add< + let output: ::glam::U16Vec4 = <::glam::U16Vec4 as ::core::ops::Add< u16, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -30263,11 +29111,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U16Vec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::U16Vec4::as_dvec4( - &_self, - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::U16Vec4::as_dvec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -30280,11 +29127,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U16Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::U16Vec4::as_i16vec4( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::U16Vec4::as_i16vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -30297,11 +29143,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U16Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::U16Vec4::as_i64vec4( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::U16Vec4::as_i64vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -30314,11 +29159,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U16Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::U16Vec4::as_i8vec4( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::U16Vec4::as_i8vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -30331,11 +29175,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U16Vec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::U16Vec4::as_ivec4( - &_self, - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::U16Vec4::as_ivec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -30348,11 +29191,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U16Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U16Vec4::as_u64vec4( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U16Vec4::as_u64vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -30365,11 +29207,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U16Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U16Vec4::as_u8vec4( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U16Vec4::as_u8vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -30382,11 +29223,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U16Vec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::U16Vec4::as_uvec4( - &_self, - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::U16Vec4::as_uvec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -30399,9 +29239,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U16Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::U16Vec4::as_vec4(&_self) - .into(); - output + let output: ::glam::Vec4 = ::glam::U16Vec4::as_vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -30415,10 +29256,9 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { let output: () = { { let output: () = <::glam::U16Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -30432,11 +29272,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec4::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -30450,11 +29289,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::U16Vec4::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -30471,13 +29309,12 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U16Vec4::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -30490,11 +29327,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec4 = <::glam::U16Vec4 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -30507,12 +29343,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::U16Vec4::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::U16Vec4::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -30525,12 +29360,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::U16Vec4::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::U16Vec4::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -30543,12 +29377,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::U16Vec4::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::U16Vec4::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -30561,12 +29394,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::U16Vec4::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::U16Vec4::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -30579,12 +29411,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::U16Vec4::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::U16Vec4::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -30597,12 +29428,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::U16Vec4::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::U16Vec4::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -30615,11 +29445,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Ref<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Div< + let output: ::glam::U16Vec4 = <::glam::U16Vec4 as ::core::ops::Div< &::glam::U16Vec4, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -30632,11 +29461,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Div< + let output: ::glam::U16Vec4 = <::glam::U16Vec4 as ::core::ops::Div< ::glam::U16Vec4, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -30649,11 +29477,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: u16| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Div< + let output: ::glam::U16Vec4 = <::glam::U16Vec4 as ::core::ops::Div< u16, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -30667,11 +29494,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec4::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -30684,12 +29510,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U16Vec4::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -30703,10 +29528,9 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec4::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -30720,10 +29544,9 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec4::element_sum( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -30738,9 +29561,8 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { { let output: bool = <::glam::U16Vec4 as ::core::cmp::PartialEq< ::glam::U16Vec4, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -30753,9 +29575,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |a: [u16; 4]| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::from_array(a) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U16Vec4::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -30769,10 +29592,9 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec4::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -30786,11 +29608,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec4::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -30803,12 +29624,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U16Vec4::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -30822,10 +29642,9 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec4::max_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -30839,10 +29658,9 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::U16Vec4::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -30855,12 +29673,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U16Vec4::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -30874,10 +29691,9 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { let output: u16 = { { let output: u16 = ::glam::U16Vec4::min_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -30891,10 +29707,9 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::U16Vec4::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -30907,11 +29722,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Ref<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Mul< + let output: ::glam::U16Vec4 = <::glam::U16Vec4 as ::core::ops::Mul< &::glam::U16Vec4, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -30924,11 +29738,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Mul< + let output: ::glam::U16Vec4 = <::glam::U16Vec4 as ::core::ops::Mul< ::glam::U16Vec4, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -30941,11 +29754,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: u16| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Mul< + let output: ::glam::U16Vec4 = <::glam::U16Vec4 as ::core::ops::Mul< u16, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -30958,14 +29770,13 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |x: u16, y: u16, z: u16, w: u16| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::new( - x, - y, - z, - w, - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U16Vec4::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -30978,11 +29789,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Ref<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Rem< + let output: ::glam::U16Vec4 = <::glam::U16Vec4 as ::core::ops::Rem< &::glam::U16Vec4, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -30995,11 +29805,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Rem< + let output: ::glam::U16Vec4 = <::glam::U16Vec4 as ::core::ops::Rem< ::glam::U16Vec4, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -31012,11 +29821,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: u16| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Rem< + let output: ::glam::U16Vec4 = <::glam::U16Vec4 as ::core::ops::Rem< u16, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -31029,12 +29837,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U16Vec4::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -31047,12 +29854,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::saturating_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U16Vec4::saturating_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -31065,12 +29871,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U16Vec4::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -31083,12 +29888,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U16Vec4::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -31101,12 +29905,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U16Vec4::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -31123,13 +29926,12 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U16Vec4::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -31142,9 +29944,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |v: u16| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::splat(v) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U16Vec4::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -31157,11 +29960,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Ref<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Sub< + let output: ::glam::U16Vec4 = <::glam::U16Vec4 as ::core::ops::Sub< &::glam::U16Vec4, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -31174,11 +29976,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Sub< + let output: ::glam::U16Vec4 = <::glam::U16Vec4 as ::core::ops::Sub< ::glam::U16Vec4, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -31191,11 +29992,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: u16| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Sub< + let output: ::glam::U16Vec4 = <::glam::U16Vec4 as ::core::ops::Sub< u16, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -31208,8 +30008,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U16Vec4>| { let output: [u16; 4] = { { - let output: [u16; 4] = ::glam::U16Vec4::to_array(&_self).into(); - output + let output: [u16; 4] = ::glam::U16Vec4::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -31222,11 +30024,10 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U16Vec4::truncate( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U16Vec4::truncate( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -31239,12 +30040,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, w: u16| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::with_w( - _self.into_inner(), - w, - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U16Vec4::with_w( + safe_transmute(_self), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -31257,12 +30057,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, x: u16| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U16Vec4::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -31275,12 +30074,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, y: u16| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U16Vec4::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -31293,12 +30091,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, z: u16| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::with_z( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U16Vec4::with_z( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -31311,12 +30108,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U16Vec4::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -31329,12 +30125,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::I16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::wrapping_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U16Vec4::wrapping_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -31347,12 +30142,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U16Vec4::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -31365,12 +30159,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U16Vec4::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -31383,12 +30176,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { |_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U16Vec4::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -31398,7 +30190,11 @@ pub(crate) fn register_u_16_vec_4_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::U16Vec4, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::U16Vec4, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -31409,11 +30205,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Ref<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Add< + let output: ::glam::U64Vec2 = <::glam::U64Vec2 as ::core::ops::Add< &::glam::U64Vec2, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -31426,11 +30221,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Add< + let output: ::glam::U64Vec2 = <::glam::U64Vec2 as ::core::ops::Add< ::glam::U64Vec2, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -31443,11 +30237,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: u64| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Add< + let output: ::glam::U64Vec2 = <::glam::U64Vec2 as ::core::ops::Add< u64, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -31460,11 +30253,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U64Vec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::U64Vec2::as_dvec2( - &_self, - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::U64Vec2::as_dvec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -31477,11 +30269,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U64Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::U64Vec2::as_i16vec2( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::U64Vec2::as_i16vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -31494,11 +30285,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U64Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::U64Vec2::as_i64vec2( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::U64Vec2::as_i64vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -31511,11 +30301,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U64Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::U64Vec2::as_i8vec2( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::U64Vec2::as_i8vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -31528,11 +30317,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U64Vec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::U64Vec2::as_ivec2( - &_self, - ) - .into(); - output + let output: ::glam::IVec2 = ::glam::U64Vec2::as_ivec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -31545,11 +30333,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U64Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::U64Vec2::as_u16vec2( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::U64Vec2::as_u16vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -31562,11 +30349,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U64Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::U64Vec2::as_u8vec2( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::U64Vec2::as_u8vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -31579,11 +30365,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U64Vec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::U64Vec2::as_uvec2( - &_self, - ) - .into(); - output + let output: ::glam::UVec2 = ::glam::U64Vec2::as_uvec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -31596,9 +30381,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U64Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::U64Vec2::as_vec2(&_self) - .into(); - output + let output: ::glam::Vec2 = ::glam::U64Vec2::as_vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -31612,10 +30398,9 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { let output: () = { { let output: () = <::glam::U64Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -31629,11 +30414,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec2::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -31647,11 +30431,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::U64Vec2::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -31668,13 +30451,12 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::U64Vec2::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -31687,11 +30469,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec2 = <::glam::U64Vec2 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -31704,12 +30485,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::U64Vec2::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::U64Vec2::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -31722,12 +30502,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::U64Vec2::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::U64Vec2::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -31740,12 +30519,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::U64Vec2::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::U64Vec2::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -31758,12 +30536,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::U64Vec2::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::U64Vec2::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -31776,12 +30553,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::U64Vec2::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::U64Vec2::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -31794,12 +30570,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::U64Vec2::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::U64Vec2::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -31812,11 +30587,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Ref<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Div< + let output: ::glam::U64Vec2 = <::glam::U64Vec2 as ::core::ops::Div< &::glam::U64Vec2, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -31829,11 +30603,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Div< + let output: ::glam::U64Vec2 = <::glam::U64Vec2 as ::core::ops::Div< ::glam::U64Vec2, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -31846,11 +30619,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: u64| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Div< + let output: ::glam::U64Vec2 = <::glam::U64Vec2 as ::core::ops::Div< u64, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -31864,11 +30636,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec2::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -31881,12 +30652,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::U64Vec2::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -31900,10 +30670,9 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec2::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -31917,10 +30686,9 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec2::element_sum( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -31935,9 +30703,8 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { { let output: bool = <::glam::U64Vec2 as ::core::cmp::PartialEq< ::glam::U64Vec2, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -31950,12 +30717,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, z: u64| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec2::extend( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec2::extend( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -31968,9 +30734,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |a: [u64; 2]| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::from_array(a) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::U64Vec2::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -31984,10 +30751,9 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec2::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -32001,11 +30767,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec2::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -32018,12 +30783,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::U64Vec2::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -32037,10 +30801,9 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec2::max_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -32054,10 +30817,9 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::U64Vec2::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -32070,12 +30832,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::U64Vec2::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -32089,10 +30850,9 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec2::min_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -32106,10 +30866,9 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::U64Vec2::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -32122,11 +30881,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Ref<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Mul< + let output: ::glam::U64Vec2 = <::glam::U64Vec2 as ::core::ops::Mul< &::glam::U64Vec2, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -32139,11 +30897,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Mul< + let output: ::glam::U64Vec2 = <::glam::U64Vec2 as ::core::ops::Mul< ::glam::U64Vec2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -32156,11 +30913,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: u64| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Mul< + let output: ::glam::U64Vec2 = <::glam::U64Vec2 as ::core::ops::Mul< u64, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -32173,9 +30929,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |x: u64, y: u64| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::new(x, y) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::U64Vec2::new( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -32188,11 +30946,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Ref<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Rem< + let output: ::glam::U64Vec2 = <::glam::U64Vec2 as ::core::ops::Rem< &::glam::U64Vec2, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -32205,11 +30962,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Rem< + let output: ::glam::U64Vec2 = <::glam::U64Vec2 as ::core::ops::Rem< ::glam::U64Vec2, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -32222,11 +30978,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: u64| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Rem< + let output: ::glam::U64Vec2 = <::glam::U64Vec2 as ::core::ops::Rem< u64, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -32239,12 +30994,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::U64Vec2::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -32257,12 +31011,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::saturating_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::U64Vec2::saturating_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -32275,12 +31028,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::U64Vec2::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -32293,12 +31045,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::U64Vec2::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -32311,12 +31062,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::U64Vec2::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -32333,13 +31083,12 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::U64Vec2::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -32352,9 +31101,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |v: u64| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::splat(v) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::U64Vec2::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -32367,11 +31117,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Ref<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Sub< + let output: ::glam::U64Vec2 = <::glam::U64Vec2 as ::core::ops::Sub< &::glam::U64Vec2, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -32384,11 +31133,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Sub< + let output: ::glam::U64Vec2 = <::glam::U64Vec2 as ::core::ops::Sub< ::glam::U64Vec2, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -32401,11 +31149,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: u64| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Sub< + let output: ::glam::U64Vec2 = <::glam::U64Vec2 as ::core::ops::Sub< u64, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -32418,8 +31165,10 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Ref<::glam::U64Vec2>| { let output: [u64; 2] = { { - let output: [u64; 2] = ::glam::U64Vec2::to_array(&_self).into(); - output + let output: [u64; 2] = ::glam::U64Vec2::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -32432,12 +31181,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, x: u64| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::U64Vec2::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -32450,12 +31198,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, y: u64| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::U64Vec2::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -32468,12 +31215,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::U64Vec2::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -32486,12 +31232,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::I64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::wrapping_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::U64Vec2::wrapping_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -32504,12 +31249,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::U64Vec2::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -32522,12 +31266,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::U64Vec2::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -32540,12 +31283,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { |_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::U64Vec2::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -32555,7 +31297,11 @@ pub(crate) fn register_u_64_vec_2_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::U64Vec2, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::U64Vec2, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -32566,11 +31312,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Ref<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Add< + let output: ::glam::U64Vec3 = <::glam::U64Vec3 as ::core::ops::Add< &::glam::U64Vec3, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -32583,11 +31328,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Add< + let output: ::glam::U64Vec3 = <::glam::U64Vec3 as ::core::ops::Add< ::glam::U64Vec3, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -32600,11 +31344,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: u64| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Add< + let output: ::glam::U64Vec3 = <::glam::U64Vec3 as ::core::ops::Add< u64, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -32617,11 +31360,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U64Vec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::U64Vec3::as_dvec3( - &_self, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::U64Vec3::as_dvec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -32634,11 +31376,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U64Vec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::U64Vec3::as_i16vec3( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::U64Vec3::as_i16vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -32651,11 +31392,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U64Vec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::U64Vec3::as_i64vec3( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::U64Vec3::as_i64vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -32668,11 +31408,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U64Vec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::U64Vec3::as_i8vec3( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::U64Vec3::as_i8vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -32685,11 +31424,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U64Vec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::U64Vec3::as_ivec3( - &_self, - ) - .into(); - output + let output: ::glam::IVec3 = ::glam::U64Vec3::as_ivec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -32702,11 +31440,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U64Vec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::U64Vec3::as_u16vec3( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::U64Vec3::as_u16vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -32719,11 +31456,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U64Vec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::U64Vec3::as_u8vec3( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::U64Vec3::as_u8vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -32736,11 +31472,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U64Vec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::U64Vec3::as_uvec3( - &_self, - ) - .into(); - output + let output: ::glam::UVec3 = ::glam::U64Vec3::as_uvec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -32753,9 +31488,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U64Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::U64Vec3::as_vec3(&_self) - .into(); - output + let output: ::glam::Vec3 = ::glam::U64Vec3::as_vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -32768,11 +31504,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U64Vec3>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::U64Vec3::as_vec3a( - &_self, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::U64Vec3::as_vec3a( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -32786,10 +31521,9 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { let output: () = { { let output: () = <::glam::U64Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -32803,11 +31537,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec3::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -32821,11 +31554,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::U64Vec3::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -32842,13 +31574,12 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec3::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -32861,11 +31592,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec3 = <::glam::U64Vec3 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -32878,12 +31608,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::U64Vec3::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::U64Vec3::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -32896,12 +31625,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::U64Vec3::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::U64Vec3::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -32914,12 +31642,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::U64Vec3::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::U64Vec3::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -32932,12 +31659,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::U64Vec3::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::U64Vec3::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -32950,12 +31676,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::U64Vec3::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::U64Vec3::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -32968,12 +31693,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::U64Vec3::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::U64Vec3::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -32986,12 +31710,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::cross( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec3::cross( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -33004,11 +31727,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Ref<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Div< + let output: ::glam::U64Vec3 = <::glam::U64Vec3 as ::core::ops::Div< &::glam::U64Vec3, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -33021,11 +31743,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Div< + let output: ::glam::U64Vec3 = <::glam::U64Vec3 as ::core::ops::Div< ::glam::U64Vec3, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -33038,11 +31759,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: u64| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Div< + let output: ::glam::U64Vec3 = <::glam::U64Vec3 as ::core::ops::Div< u64, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -33056,11 +31776,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec3::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -33073,12 +31792,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec3::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -33092,10 +31810,9 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec3::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -33109,10 +31826,9 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec3::element_sum( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -33127,9 +31843,8 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { { let output: bool = <::glam::U64Vec3 as ::core::cmp::PartialEq< ::glam::U64Vec3, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -33142,12 +31857,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, w: u64| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U64Vec3::extend( - _self.into_inner(), - w, - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U64Vec3::extend( + safe_transmute(_self), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -33160,9 +31874,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |a: [u64; 3]| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::from_array(a) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec3::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -33176,10 +31891,9 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec3::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -33193,11 +31907,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec3::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -33210,12 +31923,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec3::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -33229,10 +31941,9 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec3::max_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -33246,10 +31957,9 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::U64Vec3::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -33262,12 +31972,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec3::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -33281,10 +31990,9 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec3::min_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -33298,10 +32006,9 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::U64Vec3::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -33314,11 +32021,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Ref<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Mul< + let output: ::glam::U64Vec3 = <::glam::U64Vec3 as ::core::ops::Mul< &::glam::U64Vec3, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -33331,11 +32037,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Mul< + let output: ::glam::U64Vec3 = <::glam::U64Vec3 as ::core::ops::Mul< ::glam::U64Vec3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -33348,11 +32053,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: u64| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Mul< + let output: ::glam::U64Vec3 = <::glam::U64Vec3 as ::core::ops::Mul< u64, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -33365,9 +32069,12 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |x: u64, y: u64, z: u64| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::new(x, y, z) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec3::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -33380,11 +32087,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Ref<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Rem< + let output: ::glam::U64Vec3 = <::glam::U64Vec3 as ::core::ops::Rem< &::glam::U64Vec3, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -33397,11 +32103,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Rem< + let output: ::glam::U64Vec3 = <::glam::U64Vec3 as ::core::ops::Rem< ::glam::U64Vec3, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -33414,11 +32119,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: u64| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Rem< + let output: ::glam::U64Vec3 = <::glam::U64Vec3 as ::core::ops::Rem< u64, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -33431,12 +32135,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec3::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -33449,12 +32152,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::saturating_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec3::saturating_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -33467,12 +32169,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec3::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -33485,12 +32186,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec3::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -33503,12 +32203,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec3::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -33525,13 +32224,12 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec3::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -33544,9 +32242,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |v: u64| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::splat(v) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec3::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -33559,11 +32258,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Ref<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Sub< + let output: ::glam::U64Vec3 = <::glam::U64Vec3 as ::core::ops::Sub< &::glam::U64Vec3, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -33576,11 +32274,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Sub< + let output: ::glam::U64Vec3 = <::glam::U64Vec3 as ::core::ops::Sub< ::glam::U64Vec3, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -33593,11 +32290,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: u64| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Sub< + let output: ::glam::U64Vec3 = <::glam::U64Vec3 as ::core::ops::Sub< u64, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -33610,8 +32306,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Ref<::glam::U64Vec3>| { let output: [u64; 3] = { { - let output: [u64; 3] = ::glam::U64Vec3::to_array(&_self).into(); - output + let output: [u64; 3] = ::glam::U64Vec3::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -33624,11 +32322,10 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::U64Vec3::truncate( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::U64Vec3::truncate( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -33641,12 +32338,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, x: u64| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec3::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -33659,12 +32355,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, y: u64| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec3::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -33677,12 +32372,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, z: u64| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::with_z( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec3::with_z( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -33695,12 +32389,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec3::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -33713,12 +32406,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::I64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::wrapping_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec3::wrapping_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -33731,12 +32423,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec3::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -33749,12 +32440,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec3::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -33767,12 +32457,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { |_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec3::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -33782,7 +32471,11 @@ pub(crate) fn register_u_64_vec_3_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::U64Vec3, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::U64Vec3, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -33793,11 +32486,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Ref<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Add< + let output: ::glam::U64Vec4 = <::glam::U64Vec4 as ::core::ops::Add< &::glam::U64Vec4, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -33810,11 +32502,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Add< + let output: ::glam::U64Vec4 = <::glam::U64Vec4 as ::core::ops::Add< ::glam::U64Vec4, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -33827,11 +32518,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: u64| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Add< + let output: ::glam::U64Vec4 = <::glam::U64Vec4 as ::core::ops::Add< u64, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -33844,11 +32534,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U64Vec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::U64Vec4::as_dvec4( - &_self, - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::U64Vec4::as_dvec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -33861,11 +32550,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U64Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::U64Vec4::as_i16vec4( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::U64Vec4::as_i16vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -33878,11 +32566,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U64Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::U64Vec4::as_i64vec4( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::U64Vec4::as_i64vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -33895,11 +32582,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U64Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::U64Vec4::as_i8vec4( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::U64Vec4::as_i8vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -33912,11 +32598,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U64Vec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::U64Vec4::as_ivec4( - &_self, - ) - .into(); - output + let output: ::glam::IVec4 = ::glam::U64Vec4::as_ivec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -33929,11 +32614,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U64Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::U64Vec4::as_u16vec4( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::U64Vec4::as_u16vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -33946,11 +32630,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U64Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::U64Vec4::as_u8vec4( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::U64Vec4::as_u8vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -33963,11 +32646,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U64Vec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::U64Vec4::as_uvec4( - &_self, - ) - .into(); - output + let output: ::glam::UVec4 = ::glam::U64Vec4::as_uvec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -33980,9 +32662,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U64Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::U64Vec4::as_vec4(&_self) - .into(); - output + let output: ::glam::Vec4 = ::glam::U64Vec4::as_vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -33996,10 +32679,9 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { let output: () = { { let output: () = <::glam::U64Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -34013,11 +32695,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec4::chebyshev_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -34031,11 +32712,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { let output: ::core::option::Option = { { let output: ::core::option::Option = ::glam::U64Vec4::checked_manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -34052,13 +32732,12 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U64Vec4::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -34071,11 +32750,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec4 = <::glam::U64Vec4 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -34088,12 +32766,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::U64Vec4::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::U64Vec4::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -34106,12 +32783,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::U64Vec4::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::U64Vec4::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -34124,12 +32800,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::U64Vec4::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::U64Vec4::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -34142,12 +32817,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::U64Vec4::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::U64Vec4::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -34160,12 +32834,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::U64Vec4::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::U64Vec4::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -34178,12 +32851,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::U64Vec4::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::U64Vec4::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -34196,11 +32868,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Ref<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Div< + let output: ::glam::U64Vec4 = <::glam::U64Vec4 as ::core::ops::Div< &::glam::U64Vec4, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -34213,11 +32884,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Div< + let output: ::glam::U64Vec4 = <::glam::U64Vec4 as ::core::ops::Div< ::glam::U64Vec4, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -34230,11 +32900,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: u64| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Div< + let output: ::glam::U64Vec4 = <::glam::U64Vec4 as ::core::ops::Div< u64, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -34248,11 +32917,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec4::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -34265,12 +32933,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U64Vec4::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -34284,10 +32951,9 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec4::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -34301,10 +32967,9 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec4::element_sum( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -34319,9 +32984,8 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { { let output: bool = <::glam::U64Vec4 as ::core::cmp::PartialEq< ::glam::U64Vec4, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -34334,9 +32998,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |a: [u64; 4]| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::from_array(a) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U64Vec4::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -34350,10 +33015,9 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec4::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -34367,11 +33031,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec4::manhattan_distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -34384,12 +33047,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U64Vec4::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -34403,10 +33065,9 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec4::max_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -34420,10 +33081,9 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::U64Vec4::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -34436,12 +33096,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U64Vec4::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -34455,10 +33114,9 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { let output: u64 = { { let output: u64 = ::glam::U64Vec4::min_element( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -34472,10 +33130,9 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::U64Vec4::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -34488,11 +33145,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Ref<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Mul< + let output: ::glam::U64Vec4 = <::glam::U64Vec4 as ::core::ops::Mul< &::glam::U64Vec4, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -34505,11 +33161,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Mul< + let output: ::glam::U64Vec4 = <::glam::U64Vec4 as ::core::ops::Mul< ::glam::U64Vec4, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -34522,11 +33177,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: u64| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Mul< + let output: ::glam::U64Vec4 = <::glam::U64Vec4 as ::core::ops::Mul< u64, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -34539,14 +33193,13 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |x: u64, y: u64, z: u64, w: u64| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::new( - x, - y, - z, - w, - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U64Vec4::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -34559,11 +33212,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Ref<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Rem< + let output: ::glam::U64Vec4 = <::glam::U64Vec4 as ::core::ops::Rem< &::glam::U64Vec4, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -34576,11 +33228,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Rem< + let output: ::glam::U64Vec4 = <::glam::U64Vec4 as ::core::ops::Rem< ::glam::U64Vec4, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -34593,11 +33244,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: u64| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Rem< + let output: ::glam::U64Vec4 = <::glam::U64Vec4 as ::core::ops::Rem< u64, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -34610,12 +33260,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::saturating_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U64Vec4::saturating_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -34628,12 +33277,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::saturating_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U64Vec4::saturating_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -34646,12 +33294,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U64Vec4::saturating_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -34664,12 +33311,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U64Vec4::saturating_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -34682,12 +33328,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U64Vec4::saturating_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -34704,13 +33349,12 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U64Vec4::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -34723,9 +33367,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |v: u64| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::splat(v) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U64Vec4::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -34738,11 +33383,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Ref<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Sub< + let output: ::glam::U64Vec4 = <::glam::U64Vec4 as ::core::ops::Sub< &::glam::U64Vec4, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -34755,11 +33399,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Sub< + let output: ::glam::U64Vec4 = <::glam::U64Vec4 as ::core::ops::Sub< ::glam::U64Vec4, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -34772,11 +33415,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: u64| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Sub< + let output: ::glam::U64Vec4 = <::glam::U64Vec4 as ::core::ops::Sub< u64, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -34789,8 +33431,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Ref<::glam::U64Vec4>| { let output: [u64; 4] = { { - let output: [u64; 4] = ::glam::U64Vec4::to_array(&_self).into(); - output + let output: [u64; 4] = ::glam::U64Vec4::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -34803,11 +33447,10 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::U64Vec4::truncate( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::U64Vec4::truncate( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -34820,12 +33463,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, w: u64| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::with_w( - _self.into_inner(), - w, - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U64Vec4::with_w( + safe_transmute(_self), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -34838,12 +33480,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, x: u64| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U64Vec4::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -34856,12 +33497,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, y: u64| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U64Vec4::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -34874,12 +33514,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, z: u64| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::with_z( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U64Vec4::with_z( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -34892,12 +33531,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U64Vec4::wrapping_add( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -34910,12 +33548,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::I64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::wrapping_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U64Vec4::wrapping_add_signed( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -34928,12 +33565,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U64Vec4::wrapping_div( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -34946,12 +33582,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U64Vec4::wrapping_mul( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -34964,12 +33599,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { |_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::U64Vec4::wrapping_sub( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -34979,7 +33613,11 @@ pub(crate) fn register_u_64_vec_4_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::U64Vec4, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::U64Vec4, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_vec_2_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -34990,11 +33628,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::abs( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35008,12 +33645,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::Vec2::abs_diff_eq( - _self.into_inner(), - rhs.into_inner(), - max_abs_diff, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_abs_diff), + ); + safe_transmute(output) } }; output @@ -35026,11 +33662,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Ref<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Add< + let output: ::glam::Vec2 = <::glam::Vec2 as ::core::ops::Add< &::glam::Vec2, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -35043,11 +33678,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Add< + let output: ::glam::Vec2 = <::glam::Vec2 as ::core::ops::Add< ::glam::Vec2, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -35060,11 +33694,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Add< + let output: ::glam::Vec2 = <::glam::Vec2 as ::core::ops::Add< f32, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -35078,11 +33711,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec2::angle_between( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -35096,11 +33728,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec2::angle_to( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -35113,9 +33744,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Ref<::glam::Vec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::Vec2::as_dvec2(&_self) - .into(); - output + let output: ::glam::DVec2 = ::glam::Vec2::as_dvec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35128,11 +33760,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Ref<::glam::Vec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::Vec2::as_i16vec2( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::Vec2::as_i16vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35145,11 +33776,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Ref<::glam::Vec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::Vec2::as_i64vec2( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::Vec2::as_i64vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35162,9 +33792,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Ref<::glam::Vec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::Vec2::as_i8vec2(&_self) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::Vec2::as_i8vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35177,9 +33808,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Ref<::glam::Vec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::Vec2::as_ivec2(&_self) - .into(); - output + let output: ::glam::IVec2 = ::glam::Vec2::as_ivec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35192,11 +33824,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Ref<::glam::Vec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::Vec2::as_u16vec2( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::Vec2::as_u16vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35209,11 +33840,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Ref<::glam::Vec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::Vec2::as_u64vec2( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::Vec2::as_u64vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35226,9 +33856,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Ref<::glam::Vec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::Vec2::as_u8vec2(&_self) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::Vec2::as_u8vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35241,9 +33872,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Ref<::glam::Vec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::Vec2::as_uvec2(&_self) - .into(); - output + let output: ::glam::UVec2 = ::glam::Vec2::as_uvec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35256,11 +33888,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::ceil( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::ceil( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35273,13 +33904,12 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, min: Val<::glam::Vec2>, max: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -35292,13 +33922,12 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, min: f32, max: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::clamp_length( - _self.into_inner(), - min, - max, - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::clamp_length( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -35311,12 +33940,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, max: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::clamp_length_max( - _self.into_inner(), - max, - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::clamp_length_max( + safe_transmute(_self), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -35329,12 +33957,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, min: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::clamp_length_min( - _self.into_inner(), - min, - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::clamp_length_min( + safe_transmute(_self), + safe_transmute(min), + ); + safe_transmute(output) } }; output @@ -35347,11 +33974,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Ref<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::Vec2 = <::glam::Vec2 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35364,12 +33990,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::Vec2::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::Vec2::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -35382,12 +34007,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::Vec2::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::Vec2::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -35400,12 +34024,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::Vec2::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::Vec2::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -35418,12 +34041,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::Vec2::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::Vec2::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -35436,12 +34058,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::Vec2::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::Vec2::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -35454,12 +34075,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::Vec2::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::Vec2::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -35472,12 +34092,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::copysign( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::copysign( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -35491,11 +34110,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec2::distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -35509,11 +34127,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec2::distance_squared( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -35526,11 +34143,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Ref<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Div< + let output: ::glam::Vec2 = <::glam::Vec2 as ::core::ops::Div< &::glam::Vec2, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -35543,11 +34159,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Div< + let output: ::glam::Vec2 = <::glam::Vec2 as ::core::ops::Div< ::glam::Vec2, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -35560,11 +34175,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Div< + let output: ::glam::Vec2 = <::glam::Vec2 as ::core::ops::Div< f32, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -35577,12 +34191,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::div_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::div_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -35596,11 +34209,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec2::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -35613,12 +34225,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -35632,10 +34243,9 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec2::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35648,9 +34258,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: f32 = { { - let output: f32 = ::glam::Vec2::element_sum(_self.into_inner()) - .into(); - output + let output: f32 = ::glam::Vec2::element_sum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35665,9 +34276,8 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { { let output: bool = <::glam::Vec2 as ::core::cmp::PartialEq< ::glam::Vec2, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -35680,11 +34290,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::exp( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::exp( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35697,12 +34306,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, z: f32| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec2::extend( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec2::extend( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -35715,11 +34323,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::floor( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::floor( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35732,11 +34339,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::fract( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::fract( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35749,11 +34355,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::fract_gl( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::fract_gl( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35766,9 +34371,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |angle: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::from_angle(angle) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::from_angle( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -35781,9 +34387,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |a: [f32; 2]| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::from_array(a) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -35796,9 +34403,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: bool = { { - let output: bool = ::glam::Vec2::is_finite(_self.into_inner()) - .into(); - output + let output: bool = ::glam::Vec2::is_finite( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35811,11 +34419,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::Vec2::is_finite_mask( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::Vec2::is_finite_mask( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35828,9 +34435,8 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: bool = { { - let output: bool = ::glam::Vec2::is_nan(_self.into_inner()) - .into(); - output + let output: bool = ::glam::Vec2::is_nan(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -35843,11 +34449,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::Vec2::is_nan_mask( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::Vec2::is_nan_mask( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35861,10 +34466,9 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::Vec2::is_negative_bitmask( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35878,10 +34482,9 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::Vec2::is_normalized( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35894,9 +34497,8 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: f32 = { { - let output: f32 = ::glam::Vec2::length(_self.into_inner()) - .into(); - output + let output: f32 = ::glam::Vec2::length(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -35909,9 +34511,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: f32 = { { - let output: f32 = ::glam::Vec2::length_recip(_self.into_inner()) - .into(); - output + let output: f32 = ::glam::Vec2::length_recip( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35925,10 +34528,9 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec2::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35941,13 +34543,12 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>, s: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::lerp( - _self.into_inner(), - rhs.into_inner(), - s, - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::lerp( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(s), + ); + safe_transmute(output) } }; output @@ -35960,12 +34561,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -35978,9 +34578,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: f32 = { { - let output: f32 = ::glam::Vec2::max_element(_self.into_inner()) - .into(); - output + let output: f32 = ::glam::Vec2::max_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -35994,10 +34595,9 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::Vec2::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -36010,12 +34610,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::midpoint( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::midpoint( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -36028,12 +34627,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -36046,9 +34644,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: f32 = { { - let output: f32 = ::glam::Vec2::min_element(_self.into_inner()) - .into(); - output + let output: f32 = ::glam::Vec2::min_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -36062,10 +34661,9 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::Vec2::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -36078,13 +34676,12 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Ref<::glam::Vec2>, rhs: Val<::glam::Vec2>, d: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::move_towards( - &_self, - rhs.into_inner(), - d, - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::move_towards( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(d), + ); + safe_transmute(output) } }; output @@ -36097,11 +34694,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Ref<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Mul< + let output: ::glam::Vec2 = <::glam::Vec2 as ::core::ops::Mul< &::glam::Vec2, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -36114,11 +34710,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Mul< + let output: ::glam::Vec2 = <::glam::Vec2 as ::core::ops::Mul< ::glam::Vec2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -36131,11 +34726,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Mul< + let output: ::glam::Vec2 = <::glam::Vec2 as ::core::ops::Mul< f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -36148,13 +34742,12 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, a: Val<::glam::Vec2>, b: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::mul_add( - _self.into_inner(), - a.into_inner(), - b.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::mul_add( + safe_transmute(_self), + safe_transmute(a), + safe_transmute(b), + ); + safe_transmute(output) } }; output @@ -36167,11 +34760,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = <::glam::Vec2 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -36184,8 +34776,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |x: f32, y: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::new(x, y).into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::new( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -36198,11 +34793,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::normalize( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::normalize( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -36215,12 +34809,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, fallback: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::normalize_or( - _self.into_inner(), - fallback.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::normalize_or( + safe_transmute(_self), + safe_transmute(fallback), + ); + safe_transmute(output) } }; output @@ -36233,11 +34826,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::normalize_or_zero( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::normalize_or_zero( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -36250,11 +34842,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::perp( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::perp( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -36268,11 +34859,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec2::perp_dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -36285,12 +34875,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, n: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::powf( - _self.into_inner(), - n, - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::powf( + safe_transmute(_self), + safe_transmute(n), + ); + safe_transmute(output) } }; output @@ -36303,12 +34892,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::project_onto( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::project_onto( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -36321,12 +34909,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::project_onto_normalized( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::project_onto_normalized( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -36339,11 +34926,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::recip( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::recip( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -36356,12 +34942,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, normal: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::reflect( - _self.into_inner(), - normal.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::reflect( + safe_transmute(_self), + safe_transmute(normal), + ); + safe_transmute(output) } }; output @@ -36374,13 +34959,12 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, normal: Val<::glam::Vec2>, eta: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::refract( - _self.into_inner(), - normal.into_inner(), - eta, - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::refract( + safe_transmute(_self), + safe_transmute(normal), + safe_transmute(eta), + ); + safe_transmute(output) } }; output @@ -36393,12 +34977,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::reject_from( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::reject_from( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -36411,12 +34994,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::reject_from_normalized( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::reject_from_normalized( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -36429,11 +35011,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Ref<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Rem< + let output: ::glam::Vec2 = <::glam::Vec2 as ::core::ops::Rem< &::glam::Vec2, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -36446,11 +35027,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Rem< + let output: ::glam::Vec2 = <::glam::Vec2 as ::core::ops::Rem< ::glam::Vec2, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -36463,11 +35043,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Rem< + let output: ::glam::Vec2 = <::glam::Vec2 as ::core::ops::Rem< f32, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -36480,12 +35059,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::rem_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::rem_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -36498,12 +35076,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::rotate( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::rotate( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -36516,13 +35093,12 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Ref<::glam::Vec2>, rhs: Val<::glam::Vec2>, max_angle: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::rotate_towards( - &_self, - rhs.into_inner(), - max_angle, - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::rotate_towards( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_angle), + ); + safe_transmute(output) } }; output @@ -36535,11 +35111,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::round( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::round( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -36556,13 +35131,12 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -36575,11 +35149,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::signum( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::signum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -36592,8 +35165,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |v: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::splat(v).into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -36606,11 +35181,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Ref<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Sub< + let output: ::glam::Vec2 = <::glam::Vec2 as ::core::ops::Sub< &::glam::Vec2, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -36623,11 +35197,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Sub< + let output: ::glam::Vec2 = <::glam::Vec2 as ::core::ops::Sub< ::glam::Vec2, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -36640,11 +35213,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, rhs: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Sub< + let output: ::glam::Vec2 = <::glam::Vec2 as ::core::ops::Sub< f32, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -36657,9 +35229,8 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: f32 = { { - let output: f32 = ::glam::Vec2::to_angle(_self.into_inner()) - .into(); - output + let output: f32 = ::glam::Vec2::to_angle(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -36672,8 +35243,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Ref<::glam::Vec2>| { let output: [f32; 2] = { { - let output: [f32; 2] = ::glam::Vec2::to_array(&_self).into(); - output + let output: [f32; 2] = ::glam::Vec2::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -36686,11 +35259,10 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::trunc( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::trunc( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -36703,12 +35275,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, x: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -36721,12 +35292,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { |_self: Val<::glam::Vec2>, y: f32| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec2::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec2::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -36736,7 +35306,11 @@ pub(crate) fn register_vec_2_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::Vec2, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::Vec2, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_vec_3_a_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -36747,11 +35321,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::abs( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -36765,12 +35338,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::Vec3A::abs_diff_eq( - _self.into_inner(), - rhs.into_inner(), - max_abs_diff, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_abs_diff), + ); + safe_transmute(output) } }; output @@ -36783,11 +35355,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Add< + let output: ::glam::Vec3A = <::glam::Vec3A as ::core::ops::Add< &::glam::Vec3A, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -36800,11 +35371,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Add< + let output: ::glam::Vec3A = <::glam::Vec3A as ::core::ops::Add< ::glam::Vec3A, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -36817,11 +35387,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Add< + let output: ::glam::Vec3A = <::glam::Vec3A as ::core::ops::Add< f32, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -36835,11 +35404,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec3A::angle_between( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -36852,11 +35420,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::any_orthogonal_vector( - &_self, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::any_orthogonal_vector( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -36869,11 +35436,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::any_orthonormal_vector( - &_self, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::any_orthonormal_vector( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -36886,9 +35452,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::Vec3A>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::Vec3A::as_dvec3(&_self) - .into(); - output + let output: ::glam::DVec3 = ::glam::Vec3A::as_dvec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -36901,11 +35468,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::Vec3A>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::Vec3A::as_i16vec3( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::Vec3A::as_i16vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -36918,11 +35484,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::Vec3A>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::Vec3A::as_i64vec3( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::Vec3A::as_i64vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -36935,11 +35500,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::Vec3A>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::Vec3A::as_i8vec3( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::Vec3A::as_i8vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -36952,9 +35516,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::Vec3A>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::Vec3A::as_ivec3(&_self) - .into(); - output + let output: ::glam::IVec3 = ::glam::Vec3A::as_ivec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -36967,11 +35532,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::Vec3A>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::Vec3A::as_u16vec3( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::Vec3A::as_u16vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -36984,11 +35548,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::Vec3A>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::Vec3A::as_u64vec3( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::Vec3A::as_u64vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -37001,11 +35564,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::Vec3A>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::Vec3A::as_u8vec3( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::Vec3A::as_u8vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -37018,9 +35580,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::Vec3A>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::Vec3A::as_uvec3(&_self) - .into(); - output + let output: ::glam::UVec3 = ::glam::Vec3A::as_uvec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -37033,11 +35596,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::ceil( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::ceil( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -37054,13 +35616,12 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -37073,13 +35634,12 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, min: f32, max: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::clamp_length( - _self.into_inner(), - min, - max, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::clamp_length( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -37092,12 +35652,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, max: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::clamp_length_max( - _self.into_inner(), - max, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::clamp_length_max( + safe_transmute(_self), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -37110,12 +35669,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, min: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::clamp_length_min( - _self.into_inner(), - min, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::clamp_length_min( + safe_transmute(_self), + safe_transmute(min), + ); + safe_transmute(output) } }; output @@ -37128,11 +35686,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::Vec3A = <::glam::Vec3A as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -37145,12 +35702,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::BVec3A> = { { - let output: Val<::glam::BVec3A> = ::glam::Vec3A::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3A = ::glam::Vec3A::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -37163,12 +35719,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::BVec3A> = { { - let output: Val<::glam::BVec3A> = ::glam::Vec3A::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3A = ::glam::Vec3A::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -37181,12 +35736,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::BVec3A> = { { - let output: Val<::glam::BVec3A> = ::glam::Vec3A::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3A = ::glam::Vec3A::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -37199,12 +35753,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::BVec3A> = { { - let output: Val<::glam::BVec3A> = ::glam::Vec3A::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3A = ::glam::Vec3A::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -37217,12 +35770,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::BVec3A> = { { - let output: Val<::glam::BVec3A> = ::glam::Vec3A::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3A = ::glam::Vec3A::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -37235,12 +35787,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::BVec3A> = { { - let output: Val<::glam::BVec3A> = ::glam::Vec3A::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3A = ::glam::Vec3A::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -37253,12 +35804,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::copysign( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::copysign( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -37271,12 +35821,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::cross( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::cross( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -37290,11 +35839,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec3A::distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -37308,11 +35856,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec3A::distance_squared( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -37325,11 +35872,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Div< + let output: ::glam::Vec3A = <::glam::Vec3A as ::core::ops::Div< &::glam::Vec3A, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -37342,11 +35888,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Div< + let output: ::glam::Vec3A = <::glam::Vec3A as ::core::ops::Div< ::glam::Vec3A, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -37359,11 +35904,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Div< + let output: ::glam::Vec3A = <::glam::Vec3A as ::core::ops::Div< f32, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -37376,12 +35920,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::div_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::div_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -37395,11 +35938,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec3A::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -37412,12 +35954,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -37431,10 +35972,9 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec3A::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -37447,9 +35987,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: f32 = { { - let output: f32 = ::glam::Vec3A::element_sum(_self.into_inner()) - .into(); - output + let output: f32 = ::glam::Vec3A::element_sum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -37464,9 +36005,8 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { { let output: bool = <::glam::Vec3A as ::core::cmp::PartialEq< ::glam::Vec3A, - >>::eq(&_self, &rhs) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -37479,11 +36019,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::exp( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::exp( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -37496,12 +36035,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, w: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec3A::extend( - _self.into_inner(), - w, - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec3A::extend( + safe_transmute(_self), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -37514,11 +36052,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::floor( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::floor( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -37531,11 +36068,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::fract( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::fract( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -37548,11 +36084,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::fract_gl( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::fract_gl( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -37565,9 +36100,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |a: [f32; 3]| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::from_array(a) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -37580,11 +36116,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |v: Val<::glam::Vec4>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::from_vec4( - v.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::from_vec4( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -37597,9 +36132,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: bool = { { - let output: bool = ::glam::Vec3A::is_finite(_self.into_inner()) - .into(); - output + let output: bool = ::glam::Vec3A::is_finite( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -37612,11 +36148,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: Val<::glam::BVec3A> = { { - let output: Val<::glam::BVec3A> = ::glam::Vec3A::is_finite_mask( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3A = ::glam::Vec3A::is_finite_mask( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -37629,9 +36164,8 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: bool = { { - let output: bool = ::glam::Vec3A::is_nan(_self.into_inner()) - .into(); - output + let output: bool = ::glam::Vec3A::is_nan(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -37644,11 +36178,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: Val<::glam::BVec3A> = { { - let output: Val<::glam::BVec3A> = ::glam::Vec3A::is_nan_mask( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3A = ::glam::Vec3A::is_nan_mask( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -37662,10 +36195,9 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::Vec3A::is_negative_bitmask( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -37679,10 +36211,9 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::Vec3A::is_normalized( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -37695,9 +36226,8 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: f32 = { { - let output: f32 = ::glam::Vec3A::length(_self.into_inner()) - .into(); - output + let output: f32 = ::glam::Vec3A::length(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -37710,9 +36240,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: f32 = { { - let output: f32 = ::glam::Vec3A::length_recip(_self.into_inner()) - .into(); - output + let output: f32 = ::glam::Vec3A::length_recip( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -37726,10 +36257,9 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec3A::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -37742,13 +36272,12 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>, s: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::lerp( - _self.into_inner(), - rhs.into_inner(), - s, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::lerp( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(s), + ); + safe_transmute(output) } }; output @@ -37761,12 +36290,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -37779,9 +36307,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: f32 = { { - let output: f32 = ::glam::Vec3A::max_element(_self.into_inner()) - .into(); - output + let output: f32 = ::glam::Vec3A::max_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -37795,10 +36324,9 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::Vec3A::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -37811,12 +36339,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::midpoint( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::midpoint( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -37829,12 +36356,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -37847,9 +36373,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: f32 = { { - let output: f32 = ::glam::Vec3A::min_element(_self.into_inner()) - .into(); - output + let output: f32 = ::glam::Vec3A::min_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -37863,10 +36390,9 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::Vec3A::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -37879,13 +36405,12 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::Vec3A>, rhs: Val<::glam::Vec3A>, d: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::move_towards( - &_self, - rhs.into_inner(), - d, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::move_towards( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(d), + ); + safe_transmute(output) } }; output @@ -37898,11 +36423,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Mul< + let output: ::glam::Vec3A = <::glam::Vec3A as ::core::ops::Mul< &::glam::Vec3A, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -37915,11 +36439,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Mul< + let output: ::glam::Vec3A = <::glam::Vec3A as ::core::ops::Mul< ::glam::Vec3A, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -37932,11 +36455,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Mul< + let output: ::glam::Vec3A = <::glam::Vec3A as ::core::ops::Mul< f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -37949,13 +36471,12 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, a: Val<::glam::Vec3A>, b: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::mul_add( - _self.into_inner(), - a.into_inner(), - b.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::mul_add( + safe_transmute(_self), + safe_transmute(a), + safe_transmute(b), + ); + safe_transmute(output) } }; output @@ -37968,11 +36489,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = <::glam::Vec3A as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -37985,9 +36505,12 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |x: f32, y: f32, z: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::new(x, y, z) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -38000,11 +36523,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::normalize( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::normalize( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -38017,12 +36539,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, fallback: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::normalize_or( - _self.into_inner(), - fallback.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::normalize_or( + safe_transmute(_self), + safe_transmute(fallback), + ); + safe_transmute(output) } }; output @@ -38035,11 +36556,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::normalize_or_zero( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::normalize_or_zero( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -38052,12 +36572,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, n: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::powf( - _self.into_inner(), - n, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::powf( + safe_transmute(_self), + safe_transmute(n), + ); + safe_transmute(output) } }; output @@ -38070,12 +36589,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::project_onto( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::project_onto( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -38088,12 +36606,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::project_onto_normalized( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::project_onto_normalized( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -38106,11 +36623,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::recip( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::recip( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -38123,12 +36639,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, normal: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::reflect( - _self.into_inner(), - normal.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::reflect( + safe_transmute(_self), + safe_transmute(normal), + ); + safe_transmute(output) } }; output @@ -38141,13 +36656,12 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, normal: Val<::glam::Vec3A>, eta: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::refract( - _self.into_inner(), - normal.into_inner(), - eta, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::refract( + safe_transmute(_self), + safe_transmute(normal), + safe_transmute(eta), + ); + safe_transmute(output) } }; output @@ -38160,12 +36674,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::reject_from( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::reject_from( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -38178,12 +36691,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::reject_from_normalized( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::reject_from_normalized( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -38196,11 +36708,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Rem< + let output: ::glam::Vec3A = <::glam::Vec3A as ::core::ops::Rem< &::glam::Vec3A, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -38213,11 +36724,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Rem< + let output: ::glam::Vec3A = <::glam::Vec3A as ::core::ops::Rem< ::glam::Vec3A, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -38230,11 +36740,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Rem< + let output: ::glam::Vec3A = <::glam::Vec3A as ::core::ops::Rem< f32, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -38247,12 +36756,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::rem_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::rem_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -38265,13 +36773,12 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, axis: Val<::glam::Vec3A>, angle: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::rotate_axis( - _self.into_inner(), - axis.into_inner(), - angle, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::rotate_axis( + safe_transmute(_self), + safe_transmute(axis), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -38284,13 +36791,12 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>, max_angle: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::rotate_towards( - _self.into_inner(), - rhs.into_inner(), - max_angle, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::rotate_towards( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_angle), + ); + safe_transmute(output) } }; output @@ -38303,12 +36809,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, angle: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::rotate_x( - _self.into_inner(), - angle, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::rotate_x( + safe_transmute(_self), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -38321,12 +36826,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, angle: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::rotate_y( - _self.into_inner(), - angle, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::rotate_y( + safe_transmute(_self), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -38339,12 +36843,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, angle: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::rotate_z( - _self.into_inner(), - angle, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::rotate_z( + safe_transmute(_self), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -38357,11 +36860,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::round( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::round( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -38378,13 +36880,12 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -38397,11 +36898,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::signum( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::signum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -38414,13 +36914,12 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>, s: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::slerp( - _self.into_inner(), - rhs.into_inner(), - s, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::slerp( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(s), + ); + safe_transmute(output) } }; output @@ -38433,8 +36932,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |v: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::splat(v).into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -38447,11 +36948,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Sub< + let output: ::glam::Vec3A = <::glam::Vec3A as ::core::ops::Sub< &::glam::Vec3A, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -38464,11 +36964,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Sub< + let output: ::glam::Vec3A = <::glam::Vec3A as ::core::ops::Sub< ::glam::Vec3A, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -38481,11 +36980,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, rhs: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Sub< + let output: ::glam::Vec3A = <::glam::Vec3A as ::core::ops::Sub< f32, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -38498,8 +36996,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::Vec3A>| { let output: [f32; 3] = { { - let output: [f32; 3] = ::glam::Vec3A::to_array(&_self).into(); - output + let output: [f32; 3] = ::glam::Vec3A::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -38512,11 +37012,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec3A::to_vec3( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec3A::to_vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -38529,11 +37028,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::trunc( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::trunc( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -38546,11 +37044,10 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Vec3A::truncate( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Vec3A::truncate( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -38563,12 +37060,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, x: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -38581,12 +37077,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, y: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -38599,12 +37094,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::Vec3A>, z: f32| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Vec3A::with_z( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Vec3A::with_z( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -38614,7 +37108,11 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::Vec3A, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::Vec3A, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_vec_4_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -38625,11 +37123,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::abs( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -38643,12 +37140,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::Vec4::abs_diff_eq( - _self.into_inner(), - rhs.into_inner(), - max_abs_diff, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_abs_diff), + ); + safe_transmute(output) } }; output @@ -38661,11 +37157,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Ref<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Add< + let output: ::glam::Vec4 = <::glam::Vec4 as ::core::ops::Add< &::glam::Vec4, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -38678,11 +37173,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Add< + let output: ::glam::Vec4 = <::glam::Vec4 as ::core::ops::Add< ::glam::Vec4, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -38695,11 +37189,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Add< + let output: ::glam::Vec4 = <::glam::Vec4 as ::core::ops::Add< f32, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -38712,9 +37205,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Ref<::glam::Vec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::Vec4::as_dvec4(&_self) - .into(); - output + let output: ::glam::DVec4 = ::glam::Vec4::as_dvec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -38727,11 +37221,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Ref<::glam::Vec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::Vec4::as_i16vec4( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::Vec4::as_i16vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -38744,11 +37237,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Ref<::glam::Vec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::Vec4::as_i64vec4( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::Vec4::as_i64vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -38761,9 +37253,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Ref<::glam::Vec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::Vec4::as_i8vec4(&_self) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::Vec4::as_i8vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -38776,9 +37269,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Ref<::glam::Vec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::Vec4::as_ivec4(&_self) - .into(); - output + let output: ::glam::IVec4 = ::glam::Vec4::as_ivec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -38791,11 +37285,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Ref<::glam::Vec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::Vec4::as_u16vec4( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::Vec4::as_u16vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -38808,11 +37301,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Ref<::glam::Vec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::Vec4::as_u64vec4( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::Vec4::as_u64vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -38825,9 +37317,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Ref<::glam::Vec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::Vec4::as_u8vec4(&_self) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::Vec4::as_u8vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -38840,9 +37333,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Ref<::glam::Vec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::Vec4::as_uvec4(&_self) - .into(); - output + let output: ::glam::UVec4 = ::glam::Vec4::as_uvec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -38855,11 +37349,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::ceil( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::ceil( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -38872,13 +37365,12 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, min: Val<::glam::Vec4>, max: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -38891,13 +37383,12 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, min: f32, max: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::clamp_length( - _self.into_inner(), - min, - max, - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::clamp_length( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -38910,12 +37401,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, max: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::clamp_length_max( - _self.into_inner(), - max, - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::clamp_length_max( + safe_transmute(_self), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -38928,12 +37418,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, min: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::clamp_length_min( - _self.into_inner(), - min, - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::clamp_length_min( + safe_transmute(_self), + safe_transmute(min), + ); + safe_transmute(output) } }; output @@ -38946,11 +37435,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Ref<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::Vec4 = <::glam::Vec4 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -38963,12 +37451,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::BVec4A> = { { - let output: Val<::glam::BVec4A> = ::glam::Vec4::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4A = ::glam::Vec4::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -38981,12 +37468,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::BVec4A> = { { - let output: Val<::glam::BVec4A> = ::glam::Vec4::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4A = ::glam::Vec4::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -38999,12 +37485,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::BVec4A> = { { - let output: Val<::glam::BVec4A> = ::glam::Vec4::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4A = ::glam::Vec4::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -39017,12 +37502,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::BVec4A> = { { - let output: Val<::glam::BVec4A> = ::glam::Vec4::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4A = ::glam::Vec4::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -39035,12 +37519,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::BVec4A> = { { - let output: Val<::glam::BVec4A> = ::glam::Vec4::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4A = ::glam::Vec4::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -39053,12 +37536,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::BVec4A> = { { - let output: Val<::glam::BVec4A> = ::glam::Vec4::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4A = ::glam::Vec4::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -39071,12 +37553,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::copysign( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::copysign( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -39090,11 +37571,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec4::distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -39108,11 +37588,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec4::distance_squared( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -39125,11 +37604,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Ref<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Div< + let output: ::glam::Vec4 = <::glam::Vec4 as ::core::ops::Div< &::glam::Vec4, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -39142,11 +37620,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Div< + let output: ::glam::Vec4 = <::glam::Vec4 as ::core::ops::Div< ::glam::Vec4, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -39159,11 +37636,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Div< + let output: ::glam::Vec4 = <::glam::Vec4 as ::core::ops::Div< f32, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -39176,12 +37652,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::div_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::div_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -39195,11 +37670,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec4::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -39212,12 +37686,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -39231,10 +37704,9 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec4::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -39247,9 +37719,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: f32 = { { - let output: f32 = ::glam::Vec4::element_sum(_self.into_inner()) - .into(); - output + let output: f32 = ::glam::Vec4::element_sum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -39264,9 +37737,8 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { { let output: bool = <::glam::Vec4 as ::core::cmp::PartialEq< ::glam::Vec4, - >>::eq(&_self, &rhs) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -39279,11 +37751,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::exp( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::exp( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -39296,11 +37767,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::floor( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::floor( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -39313,11 +37783,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::fract( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::fract( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -39330,11 +37799,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::fract_gl( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::fract_gl( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -39347,9 +37815,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |a: [f32; 4]| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::from_array(a) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -39362,9 +37831,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: bool = { { - let output: bool = ::glam::Vec4::is_finite(_self.into_inner()) - .into(); - output + let output: bool = ::glam::Vec4::is_finite( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -39377,11 +37847,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: Val<::glam::BVec4A> = { { - let output: Val<::glam::BVec4A> = ::glam::Vec4::is_finite_mask( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4A = ::glam::Vec4::is_finite_mask( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -39394,9 +37863,8 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: bool = { { - let output: bool = ::glam::Vec4::is_nan(_self.into_inner()) - .into(); - output + let output: bool = ::glam::Vec4::is_nan(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -39409,11 +37877,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: Val<::glam::BVec4A> = { { - let output: Val<::glam::BVec4A> = ::glam::Vec4::is_nan_mask( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4A = ::glam::Vec4::is_nan_mask( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -39427,10 +37894,9 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::Vec4::is_negative_bitmask( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -39444,10 +37910,9 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::Vec4::is_normalized( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -39460,9 +37925,8 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: f32 = { { - let output: f32 = ::glam::Vec4::length(_self.into_inner()) - .into(); - output + let output: f32 = ::glam::Vec4::length(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -39475,9 +37939,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: f32 = { { - let output: f32 = ::glam::Vec4::length_recip(_self.into_inner()) - .into(); - output + let output: f32 = ::glam::Vec4::length_recip( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -39491,10 +37956,9 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::glam::Vec4::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -39507,13 +37971,12 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>, s: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::lerp( - _self.into_inner(), - rhs.into_inner(), - s, - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::lerp( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(s), + ); + safe_transmute(output) } }; output @@ -39526,12 +37989,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -39544,9 +38006,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: f32 = { { - let output: f32 = ::glam::Vec4::max_element(_self.into_inner()) - .into(); - output + let output: f32 = ::glam::Vec4::max_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -39560,10 +38023,9 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::Vec4::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -39576,12 +38038,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::midpoint( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::midpoint( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -39594,12 +38055,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -39612,9 +38072,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: f32 = { { - let output: f32 = ::glam::Vec4::min_element(_self.into_inner()) - .into(); - output + let output: f32 = ::glam::Vec4::min_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -39628,10 +38089,9 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::Vec4::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -39644,13 +38104,12 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Ref<::glam::Vec4>, rhs: Val<::glam::Vec4>, d: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::move_towards( - &_self, - rhs.into_inner(), - d, - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::move_towards( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(d), + ); + safe_transmute(output) } }; output @@ -39663,11 +38122,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Ref<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Mul< + let output: ::glam::Vec4 = <::glam::Vec4 as ::core::ops::Mul< &::glam::Vec4, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -39680,11 +38138,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Mul< + let output: ::glam::Vec4 = <::glam::Vec4 as ::core::ops::Mul< ::glam::Vec4, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -39697,11 +38154,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Mul< + let output: ::glam::Vec4 = <::glam::Vec4 as ::core::ops::Mul< f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -39714,13 +38170,12 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, a: Val<::glam::Vec4>, b: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::mul_add( - _self.into_inner(), - a.into_inner(), - b.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::mul_add( + safe_transmute(_self), + safe_transmute(a), + safe_transmute(b), + ); + safe_transmute(output) } }; output @@ -39733,11 +38188,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = <::glam::Vec4 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -39750,9 +38204,13 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |x: f32, y: f32, z: f32, w: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::new(x, y, z, w) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -39765,11 +38223,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::normalize( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::normalize( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -39782,12 +38239,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, fallback: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::normalize_or( - _self.into_inner(), - fallback.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::normalize_or( + safe_transmute(_self), + safe_transmute(fallback), + ); + safe_transmute(output) } }; output @@ -39800,11 +38256,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::normalize_or_zero( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::normalize_or_zero( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -39817,12 +38272,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, n: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::powf( - _self.into_inner(), - n, - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::powf( + safe_transmute(_self), + safe_transmute(n), + ); + safe_transmute(output) } }; output @@ -39835,12 +38289,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::project_onto( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::project_onto( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -39853,12 +38306,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::project_onto_normalized( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::project_onto_normalized( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -39871,11 +38323,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::recip( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::recip( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -39888,12 +38339,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, normal: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::reflect( - _self.into_inner(), - normal.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::reflect( + safe_transmute(_self), + safe_transmute(normal), + ); + safe_transmute(output) } }; output @@ -39906,13 +38356,12 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, normal: Val<::glam::Vec4>, eta: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::refract( - _self.into_inner(), - normal.into_inner(), - eta, - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::refract( + safe_transmute(_self), + safe_transmute(normal), + safe_transmute(eta), + ); + safe_transmute(output) } }; output @@ -39925,12 +38374,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::reject_from( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::reject_from( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -39943,12 +38391,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::reject_from_normalized( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::reject_from_normalized( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -39961,11 +38408,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Ref<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Rem< + let output: ::glam::Vec4 = <::glam::Vec4 as ::core::ops::Rem< &::glam::Vec4, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -39978,11 +38424,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Rem< + let output: ::glam::Vec4 = <::glam::Vec4 as ::core::ops::Rem< ::glam::Vec4, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -39995,11 +38440,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Rem< + let output: ::glam::Vec4 = <::glam::Vec4 as ::core::ops::Rem< f32, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -40012,12 +38456,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::rem_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::rem_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -40030,11 +38473,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::round( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::round( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -40051,13 +38493,12 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -40070,11 +38511,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::signum( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::signum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -40087,8 +38527,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |v: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::splat(v).into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -40101,11 +38543,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Ref<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Sub< + let output: ::glam::Vec4 = <::glam::Vec4 as ::core::ops::Sub< &::glam::Vec4, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -40118,11 +38559,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Sub< + let output: ::glam::Vec4 = <::glam::Vec4 as ::core::ops::Sub< ::glam::Vec4, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -40135,11 +38575,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, rhs: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Sub< + let output: ::glam::Vec4 = <::glam::Vec4 as ::core::ops::Sub< f32, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -40152,8 +38591,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Ref<::glam::Vec4>| { let output: [f32; 4] = { { - let output: [f32; 4] = ::glam::Vec4::to_array(&_self).into(); - output + let output: [f32; 4] = ::glam::Vec4::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -40166,11 +38607,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::trunc( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::trunc( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -40183,11 +38623,10 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Vec4::truncate( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Vec4::truncate( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -40200,12 +38639,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, w: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::with_w( - _self.into_inner(), - w, - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::with_w( + safe_transmute(_self), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -40218,12 +38656,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, x: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -40236,12 +38673,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, y: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -40254,12 +38690,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { |_self: Val<::glam::Vec4>, z: f32| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Vec4::with_z( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Vec4::with_z( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -40269,7 +38704,11 @@ pub(crate) fn register_vec_4_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::Vec4, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::Vec4, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_b_vec_2_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -40280,8 +38719,8 @@ pub(crate) fn register_b_vec_2_functions(world: &mut World) { |_self: Val<::glam::BVec2>| { let output: bool = { { - let output: bool = ::glam::BVec2::all(_self.into_inner()).into(); - output + let output: bool = ::glam::BVec2::all(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -40294,8 +38733,8 @@ pub(crate) fn register_b_vec_2_functions(world: &mut World) { |_self: Val<::glam::BVec2>| { let output: bool = { { - let output: bool = ::glam::BVec2::any(_self.into_inner()).into(); - output + let output: bool = ::glam::BVec2::any(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -40309,10 +38748,9 @@ pub(crate) fn register_b_vec_2_functions(world: &mut World) { let output: () = { { let output: () = <::glam::BVec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -40325,9 +38763,8 @@ pub(crate) fn register_b_vec_2_functions(world: &mut World) { |_self: Val<::glam::BVec2>| { let output: u32 = { { - let output: u32 = ::glam::BVec2::bitmask(_self.into_inner()) - .into(); - output + let output: u32 = ::glam::BVec2::bitmask(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -40340,11 +38777,10 @@ pub(crate) fn register_b_vec_2_functions(world: &mut World) { |_self: Ref<::glam::BVec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = <::glam::BVec2 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::BVec2 = <::glam::BVec2 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -40359,9 +38795,8 @@ pub(crate) fn register_b_vec_2_functions(world: &mut World) { { let output: bool = <::glam::BVec2 as ::core::cmp::PartialEq< ::glam::BVec2, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -40374,9 +38809,10 @@ pub(crate) fn register_b_vec_2_functions(world: &mut World) { |a: [bool; 2]| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::BVec2::from_array(a) - .into(); - output + let output: ::glam::BVec2 = ::glam::BVec2::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -40389,8 +38825,11 @@ pub(crate) fn register_b_vec_2_functions(world: &mut World) { |x: bool, y: bool| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::BVec2::new(x, y).into(); - output + let output: ::glam::BVec2 = ::glam::BVec2::new( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -40403,9 +38842,12 @@ pub(crate) fn register_b_vec_2_functions(world: &mut World) { |mut _self: Mut<::glam::BVec2>, index: usize, value: bool| { let output: () = { { - let output: () = ::glam::BVec2::set(&mut _self, index, value) - .into(); - output + let output: () = ::glam::BVec2::set( + safe_transmute(_self), + safe_transmute(index), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -40418,8 +38860,10 @@ pub(crate) fn register_b_vec_2_functions(world: &mut World) { |v: bool| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::BVec2::splat(v).into(); - output + let output: ::glam::BVec2 = ::glam::BVec2::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -40432,8 +38876,11 @@ pub(crate) fn register_b_vec_2_functions(world: &mut World) { |_self: Ref<::glam::BVec2>, index: usize| { let output: bool = { { - let output: bool = ::glam::BVec2::test(&_self, index).into(); - output + let output: bool = ::glam::BVec2::test( + safe_transmute(_self), + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -40443,7 +38890,11 @@ pub(crate) fn register_b_vec_2_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::BVec2, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::BVec2, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_b_vec_3_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -40454,8 +38905,8 @@ pub(crate) fn register_b_vec_3_functions(world: &mut World) { |_self: Val<::glam::BVec3>| { let output: bool = { { - let output: bool = ::glam::BVec3::all(_self.into_inner()).into(); - output + let output: bool = ::glam::BVec3::all(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -40468,8 +38919,8 @@ pub(crate) fn register_b_vec_3_functions(world: &mut World) { |_self: Val<::glam::BVec3>| { let output: bool = { { - let output: bool = ::glam::BVec3::any(_self.into_inner()).into(); - output + let output: bool = ::glam::BVec3::any(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -40483,10 +38934,9 @@ pub(crate) fn register_b_vec_3_functions(world: &mut World) { let output: () = { { let output: () = <::glam::BVec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -40499,9 +38949,8 @@ pub(crate) fn register_b_vec_3_functions(world: &mut World) { |_self: Val<::glam::BVec3>| { let output: u32 = { { - let output: u32 = ::glam::BVec3::bitmask(_self.into_inner()) - .into(); - output + let output: u32 = ::glam::BVec3::bitmask(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -40514,11 +38963,10 @@ pub(crate) fn register_b_vec_3_functions(world: &mut World) { |_self: Ref<::glam::BVec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = <::glam::BVec3 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::BVec3 = <::glam::BVec3 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -40533,9 +38981,8 @@ pub(crate) fn register_b_vec_3_functions(world: &mut World) { { let output: bool = <::glam::BVec3 as ::core::cmp::PartialEq< ::glam::BVec3, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -40548,9 +38995,10 @@ pub(crate) fn register_b_vec_3_functions(world: &mut World) { |a: [bool; 3]| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::BVec3::from_array(a) - .into(); - output + let output: ::glam::BVec3 = ::glam::BVec3::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -40563,9 +39011,12 @@ pub(crate) fn register_b_vec_3_functions(world: &mut World) { |x: bool, y: bool, z: bool| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::BVec3::new(x, y, z) - .into(); - output + let output: ::glam::BVec3 = ::glam::BVec3::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -40578,9 +39029,12 @@ pub(crate) fn register_b_vec_3_functions(world: &mut World) { |mut _self: Mut<::glam::BVec3>, index: usize, value: bool| { let output: () = { { - let output: () = ::glam::BVec3::set(&mut _self, index, value) - .into(); - output + let output: () = ::glam::BVec3::set( + safe_transmute(_self), + safe_transmute(index), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -40593,8 +39047,10 @@ pub(crate) fn register_b_vec_3_functions(world: &mut World) { |v: bool| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::BVec3::splat(v).into(); - output + let output: ::glam::BVec3 = ::glam::BVec3::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -40607,8 +39063,11 @@ pub(crate) fn register_b_vec_3_functions(world: &mut World) { |_self: Ref<::glam::BVec3>, index: usize| { let output: bool = { { - let output: bool = ::glam::BVec3::test(&_self, index).into(); - output + let output: bool = ::glam::BVec3::test( + safe_transmute(_self), + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -40618,7 +39077,11 @@ pub(crate) fn register_b_vec_3_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::BVec3, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::BVec3, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_b_vec_4_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -40629,8 +39092,8 @@ pub(crate) fn register_b_vec_4_functions(world: &mut World) { |_self: Val<::glam::BVec4>| { let output: bool = { { - let output: bool = ::glam::BVec4::all(_self.into_inner()).into(); - output + let output: bool = ::glam::BVec4::all(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -40643,8 +39106,8 @@ pub(crate) fn register_b_vec_4_functions(world: &mut World) { |_self: Val<::glam::BVec4>| { let output: bool = { { - let output: bool = ::glam::BVec4::any(_self.into_inner()).into(); - output + let output: bool = ::glam::BVec4::any(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -40658,10 +39121,9 @@ pub(crate) fn register_b_vec_4_functions(world: &mut World) { let output: () = { { let output: () = <::glam::BVec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -40674,9 +39136,8 @@ pub(crate) fn register_b_vec_4_functions(world: &mut World) { |_self: Val<::glam::BVec4>| { let output: u32 = { { - let output: u32 = ::glam::BVec4::bitmask(_self.into_inner()) - .into(); - output + let output: u32 = ::glam::BVec4::bitmask(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -40689,11 +39150,10 @@ pub(crate) fn register_b_vec_4_functions(world: &mut World) { |_self: Ref<::glam::BVec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = <::glam::BVec4 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::BVec4 = <::glam::BVec4 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -40708,9 +39168,8 @@ pub(crate) fn register_b_vec_4_functions(world: &mut World) { { let output: bool = <::glam::BVec4 as ::core::cmp::PartialEq< ::glam::BVec4, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -40723,9 +39182,10 @@ pub(crate) fn register_b_vec_4_functions(world: &mut World) { |a: [bool; 4]| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::BVec4::from_array(a) - .into(); - output + let output: ::glam::BVec4 = ::glam::BVec4::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -40738,9 +39198,13 @@ pub(crate) fn register_b_vec_4_functions(world: &mut World) { |x: bool, y: bool, z: bool, w: bool| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::BVec4::new(x, y, z, w) - .into(); - output + let output: ::glam::BVec4 = ::glam::BVec4::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -40753,9 +39217,12 @@ pub(crate) fn register_b_vec_4_functions(world: &mut World) { |mut _self: Mut<::glam::BVec4>, index: usize, value: bool| { let output: () = { { - let output: () = ::glam::BVec4::set(&mut _self, index, value) - .into(); - output + let output: () = ::glam::BVec4::set( + safe_transmute(_self), + safe_transmute(index), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -40768,8 +39235,10 @@ pub(crate) fn register_b_vec_4_functions(world: &mut World) { |v: bool| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::BVec4::splat(v).into(); - output + let output: ::glam::BVec4 = ::glam::BVec4::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -40782,8 +39251,11 @@ pub(crate) fn register_b_vec_4_functions(world: &mut World) { |_self: Ref<::glam::BVec4>, index: usize| { let output: bool = { { - let output: bool = ::glam::BVec4::test(&_self, index).into(); - output + let output: bool = ::glam::BVec4::test( + safe_transmute(_self), + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -40793,7 +39265,11 @@ pub(crate) fn register_b_vec_4_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::BVec4, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::BVec4, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_d_vec_2_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -40804,11 +39280,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::abs( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -40822,12 +39297,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::DVec2::abs_diff_eq( - _self.into_inner(), - rhs.into_inner(), - max_abs_diff, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_abs_diff), + ); + safe_transmute(output) } }; output @@ -40840,11 +39314,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Ref<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Add< + let output: ::glam::DVec2 = <::glam::DVec2 as ::core::ops::Add< &::glam::DVec2, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -40857,11 +39330,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Add< + let output: ::glam::DVec2 = <::glam::DVec2 as ::core::ops::Add< ::glam::DVec2, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -40874,11 +39346,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Add< + let output: ::glam::DVec2 = <::glam::DVec2 as ::core::ops::Add< f64, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -40892,11 +39363,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::glam::DVec2::angle_between( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -40910,11 +39380,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::glam::DVec2::angle_to( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -40927,11 +39396,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Ref<::glam::DVec2>| { let output: Val<::glam::I16Vec2> = { { - let output: Val<::glam::I16Vec2> = ::glam::DVec2::as_i16vec2( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec2 = ::glam::DVec2::as_i16vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -40944,11 +39412,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Ref<::glam::DVec2>| { let output: Val<::glam::I64Vec2> = { { - let output: Val<::glam::I64Vec2> = ::glam::DVec2::as_i64vec2( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec2 = ::glam::DVec2::as_i64vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -40961,11 +39428,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Ref<::glam::DVec2>| { let output: Val<::glam::I8Vec2> = { { - let output: Val<::glam::I8Vec2> = ::glam::DVec2::as_i8vec2( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec2 = ::glam::DVec2::as_i8vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -40978,9 +39444,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Ref<::glam::DVec2>| { let output: Val<::glam::IVec2> = { { - let output: Val<::glam::IVec2> = ::glam::DVec2::as_ivec2(&_self) - .into(); - output + let output: ::glam::IVec2 = ::glam::DVec2::as_ivec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -40993,11 +39460,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Ref<::glam::DVec2>| { let output: Val<::glam::U16Vec2> = { { - let output: Val<::glam::U16Vec2> = ::glam::DVec2::as_u16vec2( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec2 = ::glam::DVec2::as_u16vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41010,11 +39476,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Ref<::glam::DVec2>| { let output: Val<::glam::U64Vec2> = { { - let output: Val<::glam::U64Vec2> = ::glam::DVec2::as_u64vec2( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec2 = ::glam::DVec2::as_u64vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41027,11 +39492,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Ref<::glam::DVec2>| { let output: Val<::glam::U8Vec2> = { { - let output: Val<::glam::U8Vec2> = ::glam::DVec2::as_u8vec2( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec2 = ::glam::DVec2::as_u8vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41044,9 +39508,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Ref<::glam::DVec2>| { let output: Val<::glam::UVec2> = { { - let output: Val<::glam::UVec2> = ::glam::DVec2::as_uvec2(&_self) - .into(); - output + let output: ::glam::UVec2 = ::glam::DVec2::as_uvec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41059,9 +39524,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Ref<::glam::DVec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::DVec2::as_vec2(&_self) - .into(); - output + let output: ::glam::Vec2 = ::glam::DVec2::as_vec2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41074,11 +39540,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::ceil( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::ceil( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41095,13 +39560,12 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -41114,13 +39578,12 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, min: f64, max: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::clamp_length( - _self.into_inner(), - min, - max, - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::clamp_length( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -41133,12 +39596,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, max: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::clamp_length_max( - _self.into_inner(), - max, - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::clamp_length_max( + safe_transmute(_self), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -41151,12 +39613,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, min: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::clamp_length_min( - _self.into_inner(), - min, - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::clamp_length_min( + safe_transmute(_self), + safe_transmute(min), + ); + safe_transmute(output) } }; output @@ -41169,11 +39630,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Ref<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::DVec2 = <::glam::DVec2 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41186,12 +39646,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::DVec2::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::DVec2::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -41204,12 +39663,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::DVec2::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::DVec2::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -41222,12 +39680,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::DVec2::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::DVec2::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -41240,12 +39697,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::DVec2::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::DVec2::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -41258,12 +39714,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::DVec2::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::DVec2::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -41276,12 +39731,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::DVec2::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::DVec2::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -41294,12 +39748,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::copysign( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::copysign( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -41313,11 +39766,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::glam::DVec2::distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -41331,11 +39783,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::glam::DVec2::distance_squared( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -41348,11 +39799,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Ref<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Div< + let output: ::glam::DVec2 = <::glam::DVec2 as ::core::ops::Div< &::glam::DVec2, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -41365,11 +39815,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Div< + let output: ::glam::DVec2 = <::glam::DVec2 as ::core::ops::Div< ::glam::DVec2, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -41382,11 +39831,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Div< + let output: ::glam::DVec2 = <::glam::DVec2 as ::core::ops::Div< f64, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -41399,12 +39847,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::div_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::div_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -41418,11 +39865,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::glam::DVec2::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -41435,12 +39881,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -41454,10 +39899,9 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::glam::DVec2::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41470,9 +39914,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: f64 = { { - let output: f64 = ::glam::DVec2::element_sum(_self.into_inner()) - .into(); - output + let output: f64 = ::glam::DVec2::element_sum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41487,9 +39932,8 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { { let output: bool = <::glam::DVec2 as ::core::cmp::PartialEq< ::glam::DVec2, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -41502,11 +39946,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::exp( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::exp( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41519,12 +39962,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, z: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec2::extend( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec2::extend( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -41537,11 +39979,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::floor( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::floor( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41554,11 +39995,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::fract( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::fract( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41571,11 +40011,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::fract_gl( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::fract_gl( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41588,9 +40027,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |angle: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::from_angle(angle) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::from_angle( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -41603,9 +40043,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |a: [f64; 2]| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::from_array(a) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -41618,9 +40059,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: bool = { { - let output: bool = ::glam::DVec2::is_finite(_self.into_inner()) - .into(); - output + let output: bool = ::glam::DVec2::is_finite( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41633,11 +40075,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::DVec2::is_finite_mask( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::DVec2::is_finite_mask( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41650,9 +40091,8 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: bool = { { - let output: bool = ::glam::DVec2::is_nan(_self.into_inner()) - .into(); - output + let output: bool = ::glam::DVec2::is_nan(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -41665,11 +40105,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: Val<::glam::BVec2> = { { - let output: Val<::glam::BVec2> = ::glam::DVec2::is_nan_mask( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::BVec2 = ::glam::DVec2::is_nan_mask( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41683,10 +40122,9 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::DVec2::is_negative_bitmask( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41700,10 +40138,9 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::DVec2::is_normalized( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41716,9 +40153,8 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: f64 = { { - let output: f64 = ::glam::DVec2::length(_self.into_inner()) - .into(); - output + let output: f64 = ::glam::DVec2::length(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -41731,9 +40167,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: f64 = { { - let output: f64 = ::glam::DVec2::length_recip(_self.into_inner()) - .into(); - output + let output: f64 = ::glam::DVec2::length_recip( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41747,10 +40184,9 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::glam::DVec2::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41763,13 +40199,12 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>, s: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::lerp( - _self.into_inner(), - rhs.into_inner(), - s, - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::lerp( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(s), + ); + safe_transmute(output) } }; output @@ -41782,12 +40217,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -41800,9 +40234,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: f64 = { { - let output: f64 = ::glam::DVec2::max_element(_self.into_inner()) - .into(); - output + let output: f64 = ::glam::DVec2::max_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41816,10 +40251,9 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::DVec2::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41832,12 +40266,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::midpoint( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::midpoint( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -41850,12 +40283,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -41868,9 +40300,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: f64 = { { - let output: f64 = ::glam::DVec2::min_element(_self.into_inner()) - .into(); - output + let output: f64 = ::glam::DVec2::min_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41884,10 +40317,9 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::DVec2::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41900,13 +40332,12 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Ref<::glam::DVec2>, rhs: Val<::glam::DVec2>, d: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::move_towards( - &_self, - rhs.into_inner(), - d, - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::move_towards( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(d), + ); + safe_transmute(output) } }; output @@ -41919,11 +40350,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Ref<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Mul< + let output: ::glam::DVec2 = <::glam::DVec2 as ::core::ops::Mul< &::glam::DVec2, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -41936,11 +40366,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Mul< + let output: ::glam::DVec2 = <::glam::DVec2 as ::core::ops::Mul< ::glam::DVec2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -41953,11 +40382,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Mul< + let output: ::glam::DVec2 = <::glam::DVec2 as ::core::ops::Mul< f64, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -41970,13 +40398,12 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, a: Val<::glam::DVec2>, b: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::mul_add( - _self.into_inner(), - a.into_inner(), - b.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::mul_add( + safe_transmute(_self), + safe_transmute(a), + safe_transmute(b), + ); + safe_transmute(output) } }; output @@ -41989,11 +40416,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = <::glam::DVec2 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42006,8 +40432,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |x: f64, y: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::new(x, y).into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::new( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -42020,11 +40449,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::normalize( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::normalize( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42037,12 +40465,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, fallback: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::normalize_or( - _self.into_inner(), - fallback.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::normalize_or( + safe_transmute(_self), + safe_transmute(fallback), + ); + safe_transmute(output) } }; output @@ -42055,11 +40482,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::normalize_or_zero( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::normalize_or_zero( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42072,11 +40498,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::perp( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::perp( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42090,11 +40515,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::glam::DVec2::perp_dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -42107,12 +40531,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, n: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::powf( - _self.into_inner(), - n, - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::powf( + safe_transmute(_self), + safe_transmute(n), + ); + safe_transmute(output) } }; output @@ -42125,12 +40548,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::project_onto( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::project_onto( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -42143,12 +40565,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::project_onto_normalized( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::project_onto_normalized( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -42161,11 +40582,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::recip( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::recip( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42178,12 +40598,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, normal: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::reflect( - _self.into_inner(), - normal.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::reflect( + safe_transmute(_self), + safe_transmute(normal), + ); + safe_transmute(output) } }; output @@ -42196,13 +40615,12 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, normal: Val<::glam::DVec2>, eta: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::refract( - _self.into_inner(), - normal.into_inner(), - eta, - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::refract( + safe_transmute(_self), + safe_transmute(normal), + safe_transmute(eta), + ); + safe_transmute(output) } }; output @@ -42215,12 +40633,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::reject_from( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::reject_from( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -42233,12 +40650,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::reject_from_normalized( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::reject_from_normalized( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -42251,11 +40667,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Ref<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Rem< + let output: ::glam::DVec2 = <::glam::DVec2 as ::core::ops::Rem< &::glam::DVec2, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -42268,11 +40683,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Rem< + let output: ::glam::DVec2 = <::glam::DVec2 as ::core::ops::Rem< ::glam::DVec2, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -42285,11 +40699,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Rem< + let output: ::glam::DVec2 = <::glam::DVec2 as ::core::ops::Rem< f64, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -42302,12 +40715,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::rem_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::rem_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -42320,12 +40732,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::rotate( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::rotate( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -42338,13 +40749,12 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Ref<::glam::DVec2>, rhs: Val<::glam::DVec2>, max_angle: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::rotate_towards( - &_self, - rhs.into_inner(), - max_angle, - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::rotate_towards( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_angle), + ); + safe_transmute(output) } }; output @@ -42357,11 +40767,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::round( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::round( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42378,13 +40787,12 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -42397,11 +40805,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::signum( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::signum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42414,8 +40821,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |v: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::splat(v).into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -42428,11 +40837,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Ref<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Sub< + let output: ::glam::DVec2 = <::glam::DVec2 as ::core::ops::Sub< &::glam::DVec2, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -42445,11 +40853,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Sub< + let output: ::glam::DVec2 = <::glam::DVec2 as ::core::ops::Sub< ::glam::DVec2, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -42462,11 +40869,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, rhs: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Sub< + let output: ::glam::DVec2 = <::glam::DVec2 as ::core::ops::Sub< f64, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -42479,9 +40885,8 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: f64 = { { - let output: f64 = ::glam::DVec2::to_angle(_self.into_inner()) - .into(); - output + let output: f64 = ::glam::DVec2::to_angle(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -42494,8 +40899,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Ref<::glam::DVec2>| { let output: [f64; 2] = { { - let output: [f64; 2] = ::glam::DVec2::to_array(&_self).into(); - output + let output: [f64; 2] = ::glam::DVec2::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42508,11 +40915,10 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::trunc( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::trunc( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42525,12 +40931,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, x: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -42543,12 +40948,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { |_self: Val<::glam::DVec2>, y: f64| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec2::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec2::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -42558,7 +40962,11 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::DVec2, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::DVec2, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_d_vec_3_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -42569,11 +40977,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::abs( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42587,12 +40994,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::DVec3::abs_diff_eq( - _self.into_inner(), - rhs.into_inner(), - max_abs_diff, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_abs_diff), + ); + safe_transmute(output) } }; output @@ -42605,11 +41011,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Add< + let output: ::glam::DVec3 = <::glam::DVec3 as ::core::ops::Add< &::glam::DVec3, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -42622,11 +41027,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Add< + let output: ::glam::DVec3 = <::glam::DVec3 as ::core::ops::Add< ::glam::DVec3, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -42639,11 +41043,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Add< + let output: ::glam::DVec3 = <::glam::DVec3 as ::core::ops::Add< f64, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -42657,11 +41060,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::glam::DVec3::angle_between( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -42674,11 +41076,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::any_orthogonal_vector( - &_self, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::any_orthogonal_vector( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42691,11 +41092,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::any_orthonormal_vector( - &_self, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::any_orthonormal_vector( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42708,11 +41108,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Ref<::glam::DVec3>| { let output: Val<::glam::I16Vec3> = { { - let output: Val<::glam::I16Vec3> = ::glam::DVec3::as_i16vec3( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec3 = ::glam::DVec3::as_i16vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42725,11 +41124,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Ref<::glam::DVec3>| { let output: Val<::glam::I64Vec3> = { { - let output: Val<::glam::I64Vec3> = ::glam::DVec3::as_i64vec3( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec3 = ::glam::DVec3::as_i64vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42742,11 +41140,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Ref<::glam::DVec3>| { let output: Val<::glam::I8Vec3> = { { - let output: Val<::glam::I8Vec3> = ::glam::DVec3::as_i8vec3( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec3 = ::glam::DVec3::as_i8vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42759,9 +41156,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Ref<::glam::DVec3>| { let output: Val<::glam::IVec3> = { { - let output: Val<::glam::IVec3> = ::glam::DVec3::as_ivec3(&_self) - .into(); - output + let output: ::glam::IVec3 = ::glam::DVec3::as_ivec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42774,11 +41172,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Ref<::glam::DVec3>| { let output: Val<::glam::U16Vec3> = { { - let output: Val<::glam::U16Vec3> = ::glam::DVec3::as_u16vec3( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec3 = ::glam::DVec3::as_u16vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42791,11 +41188,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Ref<::glam::DVec3>| { let output: Val<::glam::U64Vec3> = { { - let output: Val<::glam::U64Vec3> = ::glam::DVec3::as_u64vec3( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec3 = ::glam::DVec3::as_u64vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42808,11 +41204,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Ref<::glam::DVec3>| { let output: Val<::glam::U8Vec3> = { { - let output: Val<::glam::U8Vec3> = ::glam::DVec3::as_u8vec3( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec3 = ::glam::DVec3::as_u8vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42825,9 +41220,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Ref<::glam::DVec3>| { let output: Val<::glam::UVec3> = { { - let output: Val<::glam::UVec3> = ::glam::DVec3::as_uvec3(&_self) - .into(); - output + let output: ::glam::UVec3 = ::glam::DVec3::as_uvec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42840,9 +41236,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Ref<::glam::DVec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::DVec3::as_vec3(&_self) - .into(); - output + let output: ::glam::Vec3 = ::glam::DVec3::as_vec3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42855,9 +41252,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Ref<::glam::DVec3>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::DVec3::as_vec3a(&_self) - .into(); - output + let output: ::glam::Vec3A = ::glam::DVec3::as_vec3a( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42870,11 +41268,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::ceil( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::ceil( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42891,13 +41288,12 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -42910,13 +41306,12 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, min: f64, max: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::clamp_length( - _self.into_inner(), - min, - max, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::clamp_length( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -42929,12 +41324,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, max: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::clamp_length_max( - _self.into_inner(), - max, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::clamp_length_max( + safe_transmute(_self), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -42947,12 +41341,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, min: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::clamp_length_min( - _self.into_inner(), - min, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::clamp_length_min( + safe_transmute(_self), + safe_transmute(min), + ); + safe_transmute(output) } }; output @@ -42965,11 +41358,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::DVec3 = <::glam::DVec3 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -42982,12 +41374,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::DVec3::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::DVec3::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -43000,12 +41391,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::DVec3::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::DVec3::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -43018,12 +41408,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::DVec3::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::DVec3::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -43036,12 +41425,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::DVec3::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::DVec3::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -43054,12 +41442,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::DVec3::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::DVec3::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -43072,12 +41459,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::DVec3::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::DVec3::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -43090,12 +41476,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::copysign( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::copysign( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -43108,12 +41493,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::cross( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::cross( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -43127,11 +41511,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::glam::DVec3::distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -43145,11 +41528,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::glam::DVec3::distance_squared( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -43162,11 +41544,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Div< + let output: ::glam::DVec3 = <::glam::DVec3 as ::core::ops::Div< &::glam::DVec3, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -43179,11 +41560,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Div< + let output: ::glam::DVec3 = <::glam::DVec3 as ::core::ops::Div< ::glam::DVec3, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -43196,11 +41576,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Div< + let output: ::glam::DVec3 = <::glam::DVec3 as ::core::ops::Div< f64, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -43213,12 +41592,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::div_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::div_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -43232,11 +41610,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::glam::DVec3::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -43249,12 +41626,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -43268,10 +41644,9 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::glam::DVec3::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -43284,9 +41659,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: f64 = { { - let output: f64 = ::glam::DVec3::element_sum(_self.into_inner()) - .into(); - output + let output: f64 = ::glam::DVec3::element_sum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -43301,9 +41677,8 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { { let output: bool = <::glam::DVec3 as ::core::cmp::PartialEq< ::glam::DVec3, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -43316,11 +41691,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::exp( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::exp( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -43333,12 +41707,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, w: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec3::extend( - _self.into_inner(), - w, - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec3::extend( + safe_transmute(_self), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -43351,11 +41724,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::floor( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::floor( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -43368,11 +41740,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::fract( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::fract( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -43385,11 +41756,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::fract_gl( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::fract_gl( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -43402,9 +41772,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |a: [f64; 3]| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::from_array(a) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -43417,9 +41788,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: bool = { { - let output: bool = ::glam::DVec3::is_finite(_self.into_inner()) - .into(); - output + let output: bool = ::glam::DVec3::is_finite( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -43432,11 +41804,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::DVec3::is_finite_mask( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::DVec3::is_finite_mask( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -43449,9 +41820,8 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: bool = { { - let output: bool = ::glam::DVec3::is_nan(_self.into_inner()) - .into(); - output + let output: bool = ::glam::DVec3::is_nan(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -43464,11 +41834,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: Val<::glam::BVec3> = { { - let output: Val<::glam::BVec3> = ::glam::DVec3::is_nan_mask( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::BVec3 = ::glam::DVec3::is_nan_mask( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -43482,10 +41851,9 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::DVec3::is_negative_bitmask( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -43499,10 +41867,9 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::DVec3::is_normalized( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -43515,9 +41882,8 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: f64 = { { - let output: f64 = ::glam::DVec3::length(_self.into_inner()) - .into(); - output + let output: f64 = ::glam::DVec3::length(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -43530,9 +41896,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: f64 = { { - let output: f64 = ::glam::DVec3::length_recip(_self.into_inner()) - .into(); - output + let output: f64 = ::glam::DVec3::length_recip( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -43546,10 +41913,9 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::glam::DVec3::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -43562,13 +41928,12 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>, s: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::lerp( - _self.into_inner(), - rhs.into_inner(), - s, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::lerp( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(s), + ); + safe_transmute(output) } }; output @@ -43581,12 +41946,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -43599,9 +41963,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: f64 = { { - let output: f64 = ::glam::DVec3::max_element(_self.into_inner()) - .into(); - output + let output: f64 = ::glam::DVec3::max_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -43615,10 +41980,9 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::DVec3::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -43631,12 +41995,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::midpoint( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::midpoint( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -43649,12 +42012,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -43667,9 +42029,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: f64 = { { - let output: f64 = ::glam::DVec3::min_element(_self.into_inner()) - .into(); - output + let output: f64 = ::glam::DVec3::min_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -43683,10 +42046,9 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::DVec3::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -43699,13 +42061,12 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Ref<::glam::DVec3>, rhs: Val<::glam::DVec3>, d: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::move_towards( - &_self, - rhs.into_inner(), - d, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::move_towards( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(d), + ); + safe_transmute(output) } }; output @@ -43718,11 +42079,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Mul< + let output: ::glam::DVec3 = <::glam::DVec3 as ::core::ops::Mul< &::glam::DVec3, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -43735,11 +42095,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Mul< + let output: ::glam::DVec3 = <::glam::DVec3 as ::core::ops::Mul< ::glam::DVec3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -43752,11 +42111,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Mul< + let output: ::glam::DVec3 = <::glam::DVec3 as ::core::ops::Mul< f64, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -43769,13 +42127,12 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, a: Val<::glam::DVec3>, b: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::mul_add( - _self.into_inner(), - a.into_inner(), - b.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::mul_add( + safe_transmute(_self), + safe_transmute(a), + safe_transmute(b), + ); + safe_transmute(output) } }; output @@ -43788,11 +42145,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = <::glam::DVec3 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -43805,9 +42161,12 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |x: f64, y: f64, z: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::new(x, y, z) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -43820,11 +42179,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::normalize( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::normalize( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -43837,12 +42195,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, fallback: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::normalize_or( - _self.into_inner(), - fallback.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::normalize_or( + safe_transmute(_self), + safe_transmute(fallback), + ); + safe_transmute(output) } }; output @@ -43855,11 +42212,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::normalize_or_zero( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::normalize_or_zero( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -43872,12 +42228,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, n: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::powf( - _self.into_inner(), - n, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::powf( + safe_transmute(_self), + safe_transmute(n), + ); + safe_transmute(output) } }; output @@ -43890,12 +42245,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::project_onto( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::project_onto( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -43908,12 +42262,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::project_onto_normalized( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::project_onto_normalized( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -43926,11 +42279,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::recip( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::recip( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -43943,12 +42295,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, normal: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::reflect( - _self.into_inner(), - normal.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::reflect( + safe_transmute(_self), + safe_transmute(normal), + ); + safe_transmute(output) } }; output @@ -43961,13 +42312,12 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, normal: Val<::glam::DVec3>, eta: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::refract( - _self.into_inner(), - normal.into_inner(), - eta, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::refract( + safe_transmute(_self), + safe_transmute(normal), + safe_transmute(eta), + ); + safe_transmute(output) } }; output @@ -43980,12 +42330,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::reject_from( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::reject_from( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -43998,12 +42347,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::reject_from_normalized( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::reject_from_normalized( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -44016,11 +42364,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Rem< + let output: ::glam::DVec3 = <::glam::DVec3 as ::core::ops::Rem< &::glam::DVec3, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -44033,11 +42380,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Rem< + let output: ::glam::DVec3 = <::glam::DVec3 as ::core::ops::Rem< ::glam::DVec3, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -44050,11 +42396,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Rem< + let output: ::glam::DVec3 = <::glam::DVec3 as ::core::ops::Rem< f64, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -44067,12 +42412,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::rem_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::rem_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -44085,13 +42429,12 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, axis: Val<::glam::DVec3>, angle: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::rotate_axis( - _self.into_inner(), - axis.into_inner(), - angle, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::rotate_axis( + safe_transmute(_self), + safe_transmute(axis), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -44104,13 +42447,12 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>, max_angle: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::rotate_towards( - _self.into_inner(), - rhs.into_inner(), - max_angle, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::rotate_towards( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_angle), + ); + safe_transmute(output) } }; output @@ -44123,12 +42465,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, angle: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::rotate_x( - _self.into_inner(), - angle, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::rotate_x( + safe_transmute(_self), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -44141,12 +42482,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, angle: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::rotate_y( - _self.into_inner(), - angle, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::rotate_y( + safe_transmute(_self), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -44159,12 +42499,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, angle: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::rotate_z( - _self.into_inner(), - angle, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::rotate_z( + safe_transmute(_self), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -44177,11 +42516,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::round( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::round( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -44198,13 +42536,12 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -44217,11 +42554,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::signum( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::signum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -44234,13 +42570,12 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>, s: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::slerp( - _self.into_inner(), - rhs.into_inner(), - s, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::slerp( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(s), + ); + safe_transmute(output) } }; output @@ -44253,8 +42588,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |v: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::splat(v).into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -44267,11 +42604,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Sub< + let output: ::glam::DVec3 = <::glam::DVec3 as ::core::ops::Sub< &::glam::DVec3, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -44284,11 +42620,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Sub< + let output: ::glam::DVec3 = <::glam::DVec3 as ::core::ops::Sub< ::glam::DVec3, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -44301,11 +42636,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, rhs: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Sub< + let output: ::glam::DVec3 = <::glam::DVec3 as ::core::ops::Sub< f64, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -44318,8 +42652,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Ref<::glam::DVec3>| { let output: [f64; 3] = { { - let output: [f64; 3] = ::glam::DVec3::to_array(&_self).into(); - output + let output: [f64; 3] = ::glam::DVec3::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -44332,11 +42668,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::trunc( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::trunc( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -44349,11 +42684,10 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DVec3::truncate( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DVec3::truncate( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -44366,12 +42700,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, x: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -44384,12 +42717,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, y: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -44402,12 +42734,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { |_self: Val<::glam::DVec3>, z: f64| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec3::with_z( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec3::with_z( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -44417,7 +42748,11 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::DVec3, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::DVec3, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_d_vec_4_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -44428,11 +42763,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::abs( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -44446,12 +42780,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::DVec4::abs_diff_eq( - _self.into_inner(), - rhs.into_inner(), - max_abs_diff, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_abs_diff), + ); + safe_transmute(output) } }; output @@ -44464,11 +42797,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Ref<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Add< + let output: ::glam::DVec4 = <::glam::DVec4 as ::core::ops::Add< &::glam::DVec4, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -44481,11 +42813,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Add< + let output: ::glam::DVec4 = <::glam::DVec4 as ::core::ops::Add< ::glam::DVec4, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -44498,11 +42829,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Add< + let output: ::glam::DVec4 = <::glam::DVec4 as ::core::ops::Add< f64, - >>::add(_self.into_inner(), rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -44515,11 +42845,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Ref<::glam::DVec4>| { let output: Val<::glam::I16Vec4> = { { - let output: Val<::glam::I16Vec4> = ::glam::DVec4::as_i16vec4( - &_self, - ) - .into(); - output + let output: ::glam::I16Vec4 = ::glam::DVec4::as_i16vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -44532,11 +42861,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Ref<::glam::DVec4>| { let output: Val<::glam::I64Vec4> = { { - let output: Val<::glam::I64Vec4> = ::glam::DVec4::as_i64vec4( - &_self, - ) - .into(); - output + let output: ::glam::I64Vec4 = ::glam::DVec4::as_i64vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -44549,11 +42877,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Ref<::glam::DVec4>| { let output: Val<::glam::I8Vec4> = { { - let output: Val<::glam::I8Vec4> = ::glam::DVec4::as_i8vec4( - &_self, - ) - .into(); - output + let output: ::glam::I8Vec4 = ::glam::DVec4::as_i8vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -44566,9 +42893,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Ref<::glam::DVec4>| { let output: Val<::glam::IVec4> = { { - let output: Val<::glam::IVec4> = ::glam::DVec4::as_ivec4(&_self) - .into(); - output + let output: ::glam::IVec4 = ::glam::DVec4::as_ivec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -44581,11 +42909,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Ref<::glam::DVec4>| { let output: Val<::glam::U16Vec4> = { { - let output: Val<::glam::U16Vec4> = ::glam::DVec4::as_u16vec4( - &_self, - ) - .into(); - output + let output: ::glam::U16Vec4 = ::glam::DVec4::as_u16vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -44598,11 +42925,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Ref<::glam::DVec4>| { let output: Val<::glam::U64Vec4> = { { - let output: Val<::glam::U64Vec4> = ::glam::DVec4::as_u64vec4( - &_self, - ) - .into(); - output + let output: ::glam::U64Vec4 = ::glam::DVec4::as_u64vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -44615,11 +42941,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Ref<::glam::DVec4>| { let output: Val<::glam::U8Vec4> = { { - let output: Val<::glam::U8Vec4> = ::glam::DVec4::as_u8vec4( - &_self, - ) - .into(); - output + let output: ::glam::U8Vec4 = ::glam::DVec4::as_u8vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -44632,9 +42957,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Ref<::glam::DVec4>| { let output: Val<::glam::UVec4> = { { - let output: Val<::glam::UVec4> = ::glam::DVec4::as_uvec4(&_self) - .into(); - output + let output: ::glam::UVec4 = ::glam::DVec4::as_uvec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -44647,9 +42973,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Ref<::glam::DVec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::DVec4::as_vec4(&_self) - .into(); - output + let output: ::glam::Vec4 = ::glam::DVec4::as_vec4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -44662,11 +42989,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::ceil( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::ceil( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -44683,13 +43009,12 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::clamp( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -44702,13 +43027,12 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, min: f64, max: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::clamp_length( - _self.into_inner(), - min, - max, - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::clamp_length( + safe_transmute(_self), + safe_transmute(min), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -44721,12 +43045,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, max: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::clamp_length_max( - _self.into_inner(), - max, - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::clamp_length_max( + safe_transmute(_self), + safe_transmute(max), + ); + safe_transmute(output) } }; output @@ -44739,12 +43062,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, min: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::clamp_length_min( - _self.into_inner(), - min, - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::clamp_length_min( + safe_transmute(_self), + safe_transmute(min), + ); + safe_transmute(output) } }; output @@ -44757,11 +43079,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Ref<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::DVec4 = <::glam::DVec4 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -44774,12 +43095,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::DVec4::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::DVec4::cmpeq( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -44792,12 +43112,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::DVec4::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::DVec4::cmpge( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -44810,12 +43129,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::DVec4::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::DVec4::cmpgt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -44828,12 +43146,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::DVec4::cmple( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::DVec4::cmple( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -44846,12 +43163,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::DVec4::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::DVec4::cmplt( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -44864,12 +43180,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::DVec4::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::DVec4::cmpne( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -44882,12 +43197,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::copysign( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::copysign( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -44901,11 +43215,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::glam::DVec4::distance( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -44919,11 +43232,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::glam::DVec4::distance_squared( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -44936,11 +43248,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Ref<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Div< + let output: ::glam::DVec4 = <::glam::DVec4 as ::core::ops::Div< &::glam::DVec4, - >>::div(_self.into_inner(), &rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -44953,11 +43264,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Div< + let output: ::glam::DVec4 = <::glam::DVec4 as ::core::ops::Div< ::glam::DVec4, - >>::div(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -44970,11 +43280,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Div< + let output: ::glam::DVec4 = <::glam::DVec4 as ::core::ops::Div< f64, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -44987,12 +43296,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::div_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::div_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -45006,11 +43314,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::glam::DVec4::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -45023,12 +43330,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::dot_into_vec( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -45042,10 +43348,9 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::glam::DVec4::element_product( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45058,9 +43363,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: f64 = { { - let output: f64 = ::glam::DVec4::element_sum(_self.into_inner()) - .into(); - output + let output: f64 = ::glam::DVec4::element_sum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45075,9 +43381,8 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { { let output: bool = <::glam::DVec4 as ::core::cmp::PartialEq< ::glam::DVec4, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -45090,11 +43395,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::exp( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::exp( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45107,11 +43411,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::floor( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::floor( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45124,11 +43427,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::fract( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::fract( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45141,11 +43443,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::fract_gl( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::fract_gl( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45158,9 +43459,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |a: [f64; 4]| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::from_array(a) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -45173,9 +43475,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: bool = { { - let output: bool = ::glam::DVec4::is_finite(_self.into_inner()) - .into(); - output + let output: bool = ::glam::DVec4::is_finite( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45188,11 +43491,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::DVec4::is_finite_mask( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::DVec4::is_finite_mask( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45205,9 +43507,8 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: bool = { { - let output: bool = ::glam::DVec4::is_nan(_self.into_inner()) - .into(); - output + let output: bool = ::glam::DVec4::is_nan(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -45220,11 +43521,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: Val<::glam::BVec4> = { { - let output: Val<::glam::BVec4> = ::glam::DVec4::is_nan_mask( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::BVec4 = ::glam::DVec4::is_nan_mask( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45238,10 +43538,9 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::glam::DVec4::is_negative_bitmask( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45255,10 +43554,9 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::DVec4::is_normalized( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45271,9 +43569,8 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: f64 = { { - let output: f64 = ::glam::DVec4::length(_self.into_inner()) - .into(); - output + let output: f64 = ::glam::DVec4::length(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -45286,9 +43583,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: f64 = { { - let output: f64 = ::glam::DVec4::length_recip(_self.into_inner()) - .into(); - output + let output: f64 = ::glam::DVec4::length_recip( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45302,10 +43600,9 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::glam::DVec4::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45318,13 +43615,12 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>, s: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::lerp( - _self.into_inner(), - rhs.into_inner(), - s, - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::lerp( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(s), + ); + safe_transmute(output) } }; output @@ -45337,12 +43633,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::max( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -45355,9 +43650,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: f64 = { { - let output: f64 = ::glam::DVec4::max_element(_self.into_inner()) - .into(); - output + let output: f64 = ::glam::DVec4::max_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45371,10 +43667,9 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::DVec4::max_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45387,12 +43682,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::midpoint( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::midpoint( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -45405,12 +43699,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::min( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::min( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -45423,9 +43716,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: f64 = { { - let output: f64 = ::glam::DVec4::min_element(_self.into_inner()) - .into(); - output + let output: f64 = ::glam::DVec4::min_element( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45439,10 +43733,9 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { let output: usize = { { let output: usize = ::glam::DVec4::min_position( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45455,13 +43748,12 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Ref<::glam::DVec4>, rhs: Val<::glam::DVec4>, d: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::move_towards( - &_self, - rhs.into_inner(), - d, - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::move_towards( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(d), + ); + safe_transmute(output) } }; output @@ -45474,11 +43766,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Ref<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Mul< + let output: ::glam::DVec4 = <::glam::DVec4 as ::core::ops::Mul< &::glam::DVec4, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -45491,11 +43782,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Mul< + let output: ::glam::DVec4 = <::glam::DVec4 as ::core::ops::Mul< ::glam::DVec4, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -45508,11 +43798,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Mul< + let output: ::glam::DVec4 = <::glam::DVec4 as ::core::ops::Mul< f64, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -45525,13 +43814,12 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, a: Val<::glam::DVec4>, b: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::mul_add( - _self.into_inner(), - a.into_inner(), - b.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::mul_add( + safe_transmute(_self), + safe_transmute(a), + safe_transmute(b), + ); + safe_transmute(output) } }; output @@ -45544,11 +43832,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = <::glam::DVec4 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45561,9 +43848,13 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |x: f64, y: f64, z: f64, w: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::new(x, y, z, w) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -45576,11 +43867,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::normalize( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::normalize( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45593,12 +43883,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, fallback: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::normalize_or( - _self.into_inner(), - fallback.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::normalize_or( + safe_transmute(_self), + safe_transmute(fallback), + ); + safe_transmute(output) } }; output @@ -45611,11 +43900,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::normalize_or_zero( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::normalize_or_zero( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45628,12 +43916,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, n: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::powf( - _self.into_inner(), - n, - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::powf( + safe_transmute(_self), + safe_transmute(n), + ); + safe_transmute(output) } }; output @@ -45646,12 +43933,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::project_onto( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::project_onto( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -45664,12 +43950,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::project_onto_normalized( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::project_onto_normalized( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -45682,11 +43967,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::recip( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::recip( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45699,12 +43983,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, normal: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::reflect( - _self.into_inner(), - normal.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::reflect( + safe_transmute(_self), + safe_transmute(normal), + ); + safe_transmute(output) } }; output @@ -45717,13 +44000,12 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, normal: Val<::glam::DVec4>, eta: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::refract( - _self.into_inner(), - normal.into_inner(), - eta, - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::refract( + safe_transmute(_self), + safe_transmute(normal), + safe_transmute(eta), + ); + safe_transmute(output) } }; output @@ -45736,12 +44018,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::reject_from( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::reject_from( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -45754,12 +44035,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::reject_from_normalized( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::reject_from_normalized( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -45772,11 +44052,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Ref<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Rem< + let output: ::glam::DVec4 = <::glam::DVec4 as ::core::ops::Rem< &::glam::DVec4, - >>::rem(_self.into_inner(), &rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -45789,11 +44068,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Rem< + let output: ::glam::DVec4 = <::glam::DVec4 as ::core::ops::Rem< ::glam::DVec4, - >>::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -45806,11 +44084,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Rem< + let output: ::glam::DVec4 = <::glam::DVec4 as ::core::ops::Rem< f64, - >>::rem(_self.into_inner(), rhs) - .into(); - output + >>::rem(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -45823,12 +44100,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::rem_euclid( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::rem_euclid( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -45841,11 +44117,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::round( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::round( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45862,13 +44137,12 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::select( + safe_transmute(mask), + safe_transmute(if_true), + safe_transmute(if_false), + ); + safe_transmute(output) } }; output @@ -45881,11 +44155,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::signum( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::signum( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45898,8 +44171,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |v: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::splat(v).into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -45912,11 +44187,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Ref<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Sub< + let output: ::glam::DVec4 = <::glam::DVec4 as ::core::ops::Sub< &::glam::DVec4, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -45929,11 +44203,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Sub< + let output: ::glam::DVec4 = <::glam::DVec4 as ::core::ops::Sub< ::glam::DVec4, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -45946,11 +44219,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, rhs: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Sub< + let output: ::glam::DVec4 = <::glam::DVec4 as ::core::ops::Sub< f64, - >>::sub(_self.into_inner(), rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -45963,8 +44235,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Ref<::glam::DVec4>| { let output: [f64; 4] = { { - let output: [f64; 4] = ::glam::DVec4::to_array(&_self).into(); - output + let output: [f64; 4] = ::glam::DVec4::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45977,11 +44251,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::trunc( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::trunc( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -45994,11 +44267,10 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DVec4::truncate( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DVec4::truncate( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -46011,12 +44283,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, w: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::with_w( - _self.into_inner(), - w, - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::with_w( + safe_transmute(_self), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -46029,12 +44300,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, x: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::with_x( - _self.into_inner(), - x, - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::with_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -46047,12 +44317,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, y: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::with_y( - _self.into_inner(), - y, - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::with_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -46065,12 +44334,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { |_self: Val<::glam::DVec4>, z: f64| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DVec4::with_z( - _self.into_inner(), - z, - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DVec4::with_z( + safe_transmute(_self), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -46080,7 +44348,11 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::DVec4, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::DVec4, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_mat_2_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -46091,8 +44363,10 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Ref<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = ::glam::Mat2::abs(&_self).into(); - output + let output: ::glam::Mat2 = ::glam::Mat2::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -46106,12 +44380,11 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::Mat2::abs_diff_eq( - &_self, - rhs.into_inner(), - max_abs_diff, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_abs_diff), + ); + safe_transmute(output) } }; output @@ -46124,11 +44397,10 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>, rhs: Ref<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Add< + let output: ::glam::Mat2 = <::glam::Mat2 as ::core::ops::Add< &::glam::Mat2, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -46141,11 +44413,10 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>, rhs: Val<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Add< + let output: ::glam::Mat2 = <::glam::Mat2 as ::core::ops::Add< ::glam::Mat2, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -46158,12 +44429,11 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Ref<::glam::Mat2>, rhs: Ref<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = ::glam::Mat2::add_mat2( - &_self, - &rhs, - ) - .into(); - output + let output: ::glam::Mat2 = ::glam::Mat2::add_mat2( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -46176,9 +44446,10 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Ref<::glam::Mat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = ::glam::Mat2::as_dmat2(&_self) - .into(); - output + let output: ::glam::DMat2 = ::glam::Mat2::as_dmat2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -46191,11 +44462,10 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Ref<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::Mat2 = <::glam::Mat2 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -46208,9 +44478,11 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Ref<::glam::Mat2>, index: usize| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Mat2::col(&_self, index) - .into(); - output + let output: ::glam::Vec2 = ::glam::Mat2::col( + safe_transmute(_self), + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -46223,8 +44495,10 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Ref<::glam::Mat2>| { let output: f32 = { { - let output: f32 = ::glam::Mat2::determinant(&_self).into(); - output + let output: f32 = ::glam::Mat2::determinant( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -46237,11 +44511,10 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>, rhs: f32| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Div< + let output: ::glam::Mat2 = <::glam::Mat2 as ::core::ops::Div< f32, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -46254,12 +44527,11 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Ref<::glam::Mat2>, rhs: f32| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = ::glam::Mat2::div_scalar( - &_self, - rhs, - ) - .into(); - output + let output: ::glam::Mat2 = ::glam::Mat2::div_scalar( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -46274,9 +44546,8 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { { let output: bool = <::glam::Mat2 as ::core::cmp::PartialEq< ::glam::Mat2, - >>::eq(&_self, &rhs) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -46289,9 +44560,10 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |angle: f32| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = ::glam::Mat2::from_angle(angle) - .into(); - output + let output: ::glam::Mat2 = ::glam::Mat2::from_angle( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -46304,12 +44576,11 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |x_axis: Val<::glam::Vec2>, y_axis: Val<::glam::Vec2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = ::glam::Mat2::from_cols( - x_axis.into_inner(), - y_axis.into_inner(), - ) - .into(); - output + let output: ::glam::Mat2 = ::glam::Mat2::from_cols( + safe_transmute(x_axis), + safe_transmute(y_axis), + ); + safe_transmute(output) } }; output @@ -46322,11 +44593,10 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |diagonal: Val<::glam::Vec2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = ::glam::Mat2::from_diagonal( - diagonal.into_inner(), - ) - .into(); - output + let output: ::glam::Mat2 = ::glam::Mat2::from_diagonal( + safe_transmute(diagonal), + ); + safe_transmute(output) } }; output @@ -46339,11 +44609,10 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |m: Val<::glam::Mat3>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = ::glam::Mat2::from_mat3( - m.into_inner(), - ) - .into(); - output + let output: ::glam::Mat2 = ::glam::Mat2::from_mat3( + safe_transmute(m), + ); + safe_transmute(output) } }; output @@ -46356,13 +44625,12 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |m: Val<::glam::Mat3>, i: usize, j: usize| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = ::glam::Mat2::from_mat3_minor( - m.into_inner(), - i, - j, - ) - .into(); - output + let output: ::glam::Mat2 = ::glam::Mat2::from_mat3_minor( + safe_transmute(m), + safe_transmute(i), + safe_transmute(j), + ); + safe_transmute(output) } }; output @@ -46375,11 +44643,10 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |m: Val<::glam::Mat3A>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = ::glam::Mat2::from_mat3a( - m.into_inner(), - ) - .into(); - output + let output: ::glam::Mat2 = ::glam::Mat2::from_mat3a( + safe_transmute(m), + ); + safe_transmute(output) } }; output @@ -46392,13 +44659,12 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |m: Val<::glam::Mat3A>, i: usize, j: usize| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = ::glam::Mat2::from_mat3a_minor( - m.into_inner(), - i, - j, - ) - .into(); - output + let output: ::glam::Mat2 = ::glam::Mat2::from_mat3a_minor( + safe_transmute(m), + safe_transmute(i), + safe_transmute(j), + ); + safe_transmute(output) } }; output @@ -46411,12 +44677,11 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |scale: Val<::glam::Vec2>, angle: f32| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = ::glam::Mat2::from_scale_angle( - scale.into_inner(), - angle, - ) - .into(); - output + let output: ::glam::Mat2 = ::glam::Mat2::from_scale_angle( + safe_transmute(scale), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -46429,9 +44694,10 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Ref<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = ::glam::Mat2::inverse(&_self) - .into(); - output + let output: ::glam::Mat2 = ::glam::Mat2::inverse( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -46444,8 +44710,10 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Ref<::glam::Mat2>| { let output: bool = { { - let output: bool = ::glam::Mat2::is_finite(&_self).into(); - output + let output: bool = ::glam::Mat2::is_finite( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -46458,8 +44726,8 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Ref<::glam::Mat2>| { let output: bool = { { - let output: bool = ::glam::Mat2::is_nan(&_self).into(); - output + let output: bool = ::glam::Mat2::is_nan(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -46472,11 +44740,10 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>, rhs: Ref<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Mul< + let output: ::glam::Mat2 = <::glam::Mat2 as ::core::ops::Mul< &::glam::Mat2, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -46489,11 +44756,10 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>, rhs: Ref<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Mat2 as ::core::ops::Mul< + let output: ::glam::Vec2 = <::glam::Mat2 as ::core::ops::Mul< &::glam::Vec2, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -46506,11 +44772,10 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>, rhs: Val<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Mul< + let output: ::glam::Mat2 = <::glam::Mat2 as ::core::ops::Mul< ::glam::Mat2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -46523,11 +44788,10 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = <::glam::Mat2 as ::core::ops::Mul< + let output: ::glam::Vec2 = <::glam::Mat2 as ::core::ops::Mul< ::glam::Vec2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -46540,11 +44804,10 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>, rhs: f32| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Mul< + let output: ::glam::Mat2 = <::glam::Mat2 as ::core::ops::Mul< f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -46557,12 +44820,11 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Ref<::glam::Mat2>, rhs: Ref<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = ::glam::Mat2::mul_mat2( - &_self, - &rhs, - ) - .into(); - output + let output: ::glam::Mat2 = ::glam::Mat2::mul_mat2( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -46575,12 +44837,11 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Ref<::glam::Mat2>, rhs: f32| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = ::glam::Mat2::mul_scalar( - &_self, - rhs, - ) - .into(); - output + let output: ::glam::Mat2 = ::glam::Mat2::mul_scalar( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -46593,12 +44854,11 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Ref<::glam::Mat2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Mat2::mul_vec2( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Mat2::mul_vec2( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -46611,11 +44871,10 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Mat2 = <::glam::Mat2 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -46628,9 +44887,11 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Ref<::glam::Mat2>, index: usize| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Mat2::row(&_self, index) - .into(); - output + let output: ::glam::Vec2 = ::glam::Mat2::row( + safe_transmute(_self), + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -46643,11 +44904,10 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>, rhs: Ref<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Sub< + let output: ::glam::Mat2 = <::glam::Mat2 as ::core::ops::Sub< &::glam::Mat2, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -46660,11 +44920,10 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Val<::glam::Mat2>, rhs: Val<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Sub< + let output: ::glam::Mat2 = <::glam::Mat2 as ::core::ops::Sub< ::glam::Mat2, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -46677,12 +44936,11 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Ref<::glam::Mat2>, rhs: Ref<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = ::glam::Mat2::sub_mat2( - &_self, - &rhs, - ) - .into(); - output + let output: ::glam::Mat2 = ::glam::Mat2::sub_mat2( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -46695,9 +44953,10 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Ref<::glam::Mat2>| { let output: [f32; 4] = { { - let output: [f32; 4] = ::glam::Mat2::to_cols_array(&_self) - .into(); - output + let output: [f32; 4] = ::glam::Mat2::to_cols_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -46711,10 +44970,9 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { let output: [[f32; 2]; 2] = { { let output: [[f32; 2]; 2] = ::glam::Mat2::to_cols_array_2d( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -46727,9 +44985,10 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { |_self: Ref<::glam::Mat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = ::glam::Mat2::transpose(&_self) - .into(); - output + let output: ::glam::Mat2 = ::glam::Mat2::transpose( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -46739,7 +44998,11 @@ pub(crate) fn register_mat_2_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::Mat2, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::Mat2, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_mat_3_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -46750,8 +45013,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::abs(&_self).into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -46765,12 +45030,11 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::Mat3::abs_diff_eq( - &_self, - rhs.into_inner(), - max_abs_diff, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_abs_diff), + ); + safe_transmute(output) } }; output @@ -46783,11 +45047,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Ref<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Add< + let output: ::glam::Mat3 = <::glam::Mat3 as ::core::ops::Add< &::glam::Mat3, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -46800,11 +45063,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Val<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Add< + let output: ::glam::Mat3 = <::glam::Mat3 as ::core::ops::Add< ::glam::Mat3, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -46817,12 +45079,11 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>, rhs: Ref<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::add_mat3( - &_self, - &rhs, - ) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::add_mat3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -46835,9 +45096,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::Mat3::as_dmat3(&_self) - .into(); - output + let output: ::glam::DMat3 = ::glam::Mat3::as_dmat3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -46850,11 +45112,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::Mat3 = <::glam::Mat3 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -46867,9 +45128,11 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>, index: usize| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Mat3::col(&_self, index) - .into(); - output + let output: ::glam::Vec3 = ::glam::Mat3::col( + safe_transmute(_self), + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -46882,8 +45145,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>| { let output: f32 = { { - let output: f32 = ::glam::Mat3::determinant(&_self).into(); - output + let output: f32 = ::glam::Mat3::determinant( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -46896,11 +45161,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: f32| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Div< + let output: ::glam::Mat3 = <::glam::Mat3 as ::core::ops::Div< f32, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -46913,12 +45177,11 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>, rhs: f32| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::div_scalar( - &_self, - rhs, - ) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::div_scalar( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -46933,9 +45196,8 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { { let output: bool = <::glam::Mat3 as ::core::cmp::PartialEq< ::glam::Mat3, - >>::eq(&_self, &rhs) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -46948,9 +45210,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |angle: f32| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::from_angle(angle) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::from_angle( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -46963,12 +45226,11 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |axis: Val<::glam::Vec3>, angle: f32| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::from_axis_angle( - axis.into_inner(), - angle, - ) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::from_axis_angle( + safe_transmute(axis), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -46985,13 +45247,12 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::from_cols( - x_axis.into_inner(), - y_axis.into_inner(), - z_axis.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::from_cols( + safe_transmute(x_axis), + safe_transmute(y_axis), + safe_transmute(z_axis), + ); + safe_transmute(output) } }; output @@ -47004,11 +45265,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |diagonal: Val<::glam::Vec3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::from_diagonal( - diagonal.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::from_diagonal( + safe_transmute(diagonal), + ); + safe_transmute(output) } }; output @@ -47021,14 +45281,13 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |order: Val<::glam::EulerRot>, a: f32, b: f32, c: f32| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::from_euler( - order.into_inner(), - a, - b, - c, - ) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::from_euler( + safe_transmute(order), + safe_transmute(a), + safe_transmute(b), + safe_transmute(c), + ); + safe_transmute(output) } }; output @@ -47041,11 +45300,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |m: Val<::glam::Mat2>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::from_mat2( - m.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::from_mat2( + safe_transmute(m), + ); + safe_transmute(output) } }; output @@ -47058,11 +45316,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |m: Val<::glam::Mat4>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::from_mat4( - m.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::from_mat4( + safe_transmute(m), + ); + safe_transmute(output) } }; output @@ -47075,13 +45332,12 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |m: Val<::glam::Mat4>, i: usize, j: usize| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::from_mat4_minor( - m.into_inner(), - i, - j, - ) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::from_mat4_minor( + safe_transmute(m), + safe_transmute(i), + safe_transmute(j), + ); + safe_transmute(output) } }; output @@ -47094,11 +45350,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |rotation: Val<::glam::Quat>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::from_quat( - rotation.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::from_quat( + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -47111,11 +45366,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |angle: f32| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::from_rotation_x( - angle, - ) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::from_rotation_x( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -47128,11 +45382,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |angle: f32| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::from_rotation_y( - angle, - ) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::from_rotation_y( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -47145,11 +45398,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |angle: f32| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::from_rotation_z( - angle, - ) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::from_rotation_z( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -47162,11 +45414,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |scale: Val<::glam::Vec2>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::from_scale( - scale.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::from_scale( + safe_transmute(scale), + ); + safe_transmute(output) } }; output @@ -47179,13 +45430,12 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |scale: Val<::glam::Vec2>, angle: f32, translation: Val<::glam::Vec2>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::from_scale_angle_translation( - scale.into_inner(), - angle, - translation.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::from_scale_angle_translation( + safe_transmute(scale), + safe_transmute(angle), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -47198,11 +45448,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |translation: Val<::glam::Vec2>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::from_translation( - translation.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::from_translation( + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -47215,9 +45464,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::inverse(&_self) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::inverse( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -47230,8 +45480,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>| { let output: bool = { { - let output: bool = ::glam::Mat3::is_finite(&_self).into(); - output + let output: bool = ::glam::Mat3::is_finite( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -47244,8 +45496,8 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>| { let output: bool = { { - let output: bool = ::glam::Mat3::is_nan(&_self).into(); - output + let output: bool = ::glam::Mat3::is_nan(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -47258,13 +45510,12 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |eye: Val<::glam::Vec3>, center: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::look_at_lh( - eye.into_inner(), - center.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::look_at_lh( + safe_transmute(eye), + safe_transmute(center), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -47277,13 +45528,12 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |eye: Val<::glam::Vec3>, center: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::look_at_rh( - eye.into_inner(), - center.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::look_at_rh( + safe_transmute(eye), + safe_transmute(center), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -47296,12 +45546,11 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |dir: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::look_to_lh( - dir.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::look_to_lh( + safe_transmute(dir), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -47314,12 +45563,11 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |dir: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::look_to_rh( - dir.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::look_to_rh( + safe_transmute(dir), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -47332,11 +45580,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Ref<::glam::Affine2>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Mul< + let output: ::glam::Mat3 = <::glam::Mat3 as ::core::ops::Mul< &::glam::Affine2, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -47349,11 +45596,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Ref<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Mul< + let output: ::glam::Mat3 = <::glam::Mat3 as ::core::ops::Mul< &::glam::Mat3, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -47366,11 +45612,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Mat3 as ::core::ops::Mul< + let output: ::glam::Vec3 = <::glam::Mat3 as ::core::ops::Mul< &::glam::Vec3, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -47383,11 +45628,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Mat3 as ::core::ops::Mul< + let output: ::glam::Vec3A = <::glam::Mat3 as ::core::ops::Mul< &::glam::Vec3A, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -47400,11 +45644,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Val<::glam::Affine2>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Mul< + let output: ::glam::Mat3 = <::glam::Mat3 as ::core::ops::Mul< ::glam::Affine2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -47417,11 +45660,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Val<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Mul< + let output: ::glam::Mat3 = <::glam::Mat3 as ::core::ops::Mul< ::glam::Mat3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -47434,11 +45676,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Mat3 as ::core::ops::Mul< + let output: ::glam::Vec3 = <::glam::Mat3 as ::core::ops::Mul< ::glam::Vec3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -47451,11 +45692,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Mat3 as ::core::ops::Mul< + let output: ::glam::Vec3A = <::glam::Mat3 as ::core::ops::Mul< ::glam::Vec3A, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -47468,11 +45708,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: f32| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Mul< + let output: ::glam::Mat3 = <::glam::Mat3 as ::core::ops::Mul< f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -47485,12 +45724,11 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>, rhs: Ref<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::mul_mat3( - &_self, - &rhs, - ) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::mul_mat3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -47503,12 +45741,11 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>, rhs: f32| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::mul_scalar( - &_self, - rhs, - ) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::mul_scalar( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -47521,12 +45758,11 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Mat3::mul_vec3( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Mat3::mul_vec3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -47539,12 +45775,11 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Mat3::mul_vec3a( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Mat3::mul_vec3a( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -47557,11 +45792,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3 = <::glam::Mat3 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -47574,9 +45808,11 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>, index: usize| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Mat3::row(&_self, index) - .into(); - output + let output: ::glam::Vec3 = ::glam::Mat3::row( + safe_transmute(_self), + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -47589,11 +45825,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Ref<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Sub< + let output: ::glam::Mat3 = <::glam::Mat3 as ::core::ops::Sub< &::glam::Mat3, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -47606,11 +45841,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Val<::glam::Mat3>, rhs: Val<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Sub< + let output: ::glam::Mat3 = <::glam::Mat3 as ::core::ops::Sub< ::glam::Mat3, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -47623,12 +45857,11 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>, rhs: Ref<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::sub_mat3( - &_self, - &rhs, - ) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::sub_mat3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -47641,9 +45874,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>| { let output: [f32; 9] = { { - let output: [f32; 9] = ::glam::Mat3::to_cols_array(&_self) - .into(); - output + let output: [f32; 9] = ::glam::Mat3::to_cols_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -47657,10 +45891,9 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { let output: [[f32; 3]; 3] = { { let output: [[f32; 3]; 3] = ::glam::Mat3::to_cols_array_2d( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -47674,11 +45907,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { let output: (f32, f32, f32) = { { let output: (f32, f32, f32) = ::glam::Mat3::to_euler( - &_self, - order.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(order), + ); + safe_transmute(output) } }; output @@ -47691,12 +45923,11 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Mat3::transform_point2( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Mat3::transform_point2( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -47709,12 +45940,11 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Mat3::transform_vector2( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Mat3::transform_vector2( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -47727,9 +45957,10 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { |_self: Ref<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::Mat3::transpose(&_self) - .into(); - output + let output: ::glam::Mat3 = ::glam::Mat3::transpose( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -47739,7 +45970,11 @@ pub(crate) fn register_mat_3_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::Mat3, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::Mat3, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_mat_3_a_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -47750,9 +45985,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::abs(&_self) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -47766,12 +46002,11 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::Mat3A::abs_diff_eq( - &_self, - rhs.into_inner(), - max_abs_diff, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_abs_diff), + ); + safe_transmute(output) } }; output @@ -47784,11 +46019,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Ref<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Add< + let output: ::glam::Mat3A = <::glam::Mat3A as ::core::ops::Add< &::glam::Mat3A, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -47801,11 +46035,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Val<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Add< + let output: ::glam::Mat3A = <::glam::Mat3A as ::core::ops::Add< ::glam::Mat3A, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -47818,12 +46051,11 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>, rhs: Ref<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::add_mat3( - &_self, - &rhs, - ) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::add_mat3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -47836,9 +46068,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::Mat3A::as_dmat3(&_self) - .into(); - output + let output: ::glam::DMat3 = ::glam::Mat3A::as_dmat3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -47851,11 +46084,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::Mat3A = <::glam::Mat3A as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -47868,12 +46100,11 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>, index: usize| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Mat3A::col( - &_self, - index, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Mat3A::col( + safe_transmute(_self), + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -47886,8 +46117,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>| { let output: f32 = { { - let output: f32 = ::glam::Mat3A::determinant(&_self).into(); - output + let output: f32 = ::glam::Mat3A::determinant( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -47900,11 +46133,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: f32| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Div< + let output: ::glam::Mat3A = <::glam::Mat3A as ::core::ops::Div< f32, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -47917,12 +46149,11 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>, rhs: f32| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::div_scalar( - &_self, - rhs, - ) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::div_scalar( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -47937,9 +46168,8 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { { let output: bool = <::glam::Mat3A as ::core::cmp::PartialEq< ::glam::Mat3A, - >>::eq(&_self, &rhs) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -47952,9 +46182,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |angle: f32| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_angle(angle) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::from_angle( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -47967,12 +46198,11 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |axis: Val<::glam::Vec3>, angle: f32| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_axis_angle( - axis.into_inner(), - angle, - ) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::from_axis_angle( + safe_transmute(axis), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -47989,13 +46219,12 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_cols( - x_axis.into_inner(), - y_axis.into_inner(), - z_axis.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::from_cols( + safe_transmute(x_axis), + safe_transmute(y_axis), + safe_transmute(z_axis), + ); + safe_transmute(output) } }; output @@ -48008,11 +46237,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |diagonal: Val<::glam::Vec3>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_diagonal( - diagonal.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::from_diagonal( + safe_transmute(diagonal), + ); + safe_transmute(output) } }; output @@ -48025,14 +46253,13 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |order: Val<::glam::EulerRot>, a: f32, b: f32, c: f32| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_euler( - order.into_inner(), - a, - b, - c, - ) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::from_euler( + safe_transmute(order), + safe_transmute(a), + safe_transmute(b), + safe_transmute(c), + ); + safe_transmute(output) } }; output @@ -48045,11 +46272,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |m: Val<::glam::Mat2>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_mat2( - m.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::from_mat2( + safe_transmute(m), + ); + safe_transmute(output) } }; output @@ -48062,11 +46288,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |m: Val<::glam::Mat4>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_mat4( - m.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::from_mat4( + safe_transmute(m), + ); + safe_transmute(output) } }; output @@ -48079,13 +46304,12 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |m: Val<::glam::Mat4>, i: usize, j: usize| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_mat4_minor( - m.into_inner(), - i, - j, - ) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::from_mat4_minor( + safe_transmute(m), + safe_transmute(i), + safe_transmute(j), + ); + safe_transmute(output) } }; output @@ -48098,11 +46322,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |rotation: Val<::glam::Quat>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_quat( - rotation.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::from_quat( + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -48115,11 +46338,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |angle: f32| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_rotation_x( - angle, - ) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::from_rotation_x( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -48132,11 +46354,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |angle: f32| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_rotation_y( - angle, - ) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::from_rotation_y( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -48149,11 +46370,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |angle: f32| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_rotation_z( - angle, - ) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::from_rotation_z( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -48166,11 +46386,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |scale: Val<::glam::Vec2>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_scale( - scale.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::from_scale( + safe_transmute(scale), + ); + safe_transmute(output) } }; output @@ -48183,13 +46402,12 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |scale: Val<::glam::Vec2>, angle: f32, translation: Val<::glam::Vec2>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_scale_angle_translation( - scale.into_inner(), - angle, - translation.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::from_scale_angle_translation( + safe_transmute(scale), + safe_transmute(angle), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -48202,11 +46420,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |translation: Val<::glam::Vec2>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_translation( - translation.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::from_translation( + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -48219,9 +46436,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::inverse(&_self) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::inverse( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -48234,8 +46452,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>| { let output: bool = { { - let output: bool = ::glam::Mat3A::is_finite(&_self).into(); - output + let output: bool = ::glam::Mat3A::is_finite( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -48248,8 +46468,8 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>| { let output: bool = { { - let output: bool = ::glam::Mat3A::is_nan(&_self).into(); - output + let output: bool = ::glam::Mat3A::is_nan(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -48262,13 +46482,12 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |eye: Val<::glam::Vec3>, center: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::look_at_lh( - eye.into_inner(), - center.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::look_at_lh( + safe_transmute(eye), + safe_transmute(center), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -48281,13 +46500,12 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |eye: Val<::glam::Vec3>, center: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::look_at_rh( - eye.into_inner(), - center.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::look_at_rh( + safe_transmute(eye), + safe_transmute(center), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -48300,12 +46518,11 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |dir: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::look_to_lh( - dir.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::look_to_lh( + safe_transmute(dir), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -48318,12 +46535,11 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |dir: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::look_to_rh( - dir.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::look_to_rh( + safe_transmute(dir), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -48336,11 +46552,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Ref<::glam::Affine2>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Mul< + let output: ::glam::Mat3A = <::glam::Mat3A as ::core::ops::Mul< &::glam::Affine2, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -48353,11 +46568,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Ref<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Mul< + let output: ::glam::Mat3A = <::glam::Mat3A as ::core::ops::Mul< &::glam::Mat3A, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -48370,11 +46584,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Ref<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Mat3A as ::core::ops::Mul< + let output: ::glam::Vec3 = <::glam::Mat3A as ::core::ops::Mul< &::glam::Vec3, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -48387,11 +46600,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Ref<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Mat3A as ::core::ops::Mul< + let output: ::glam::Vec3A = <::glam::Mat3A as ::core::ops::Mul< &::glam::Vec3A, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -48404,11 +46616,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Val<::glam::Affine2>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Mul< + let output: ::glam::Mat3A = <::glam::Mat3A as ::core::ops::Mul< ::glam::Affine2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -48421,11 +46632,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Val<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Mul< + let output: ::glam::Mat3A = <::glam::Mat3A as ::core::ops::Mul< ::glam::Mat3A, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -48438,11 +46648,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = <::glam::Mat3A as ::core::ops::Mul< + let output: ::glam::Vec3 = <::glam::Mat3A as ::core::ops::Mul< ::glam::Vec3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -48455,11 +46664,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = <::glam::Mat3A as ::core::ops::Mul< + let output: ::glam::Vec3A = <::glam::Mat3A as ::core::ops::Mul< ::glam::Vec3A, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -48472,11 +46680,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: f32| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Mul< + let output: ::glam::Mat3A = <::glam::Mat3A as ::core::ops::Mul< f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -48489,12 +46696,11 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>, rhs: Ref<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::mul_mat3( - &_self, - &rhs, - ) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::mul_mat3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -48507,12 +46713,11 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>, rhs: f32| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::mul_scalar( - &_self, - rhs, - ) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::mul_scalar( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -48525,12 +46730,11 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Mat3A::mul_vec3( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Mat3A::mul_vec3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -48543,12 +46747,11 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Mat3A::mul_vec3a( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Mat3A::mul_vec3a( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -48561,11 +46764,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Mat3A = <::glam::Mat3A as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -48578,12 +46780,11 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>, index: usize| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Mat3A::row( - &_self, - index, - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Mat3A::row( + safe_transmute(_self), + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -48596,11 +46797,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Ref<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Sub< + let output: ::glam::Mat3A = <::glam::Mat3A as ::core::ops::Sub< &::glam::Mat3A, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -48613,11 +46813,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Val<::glam::Mat3A>, rhs: Val<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Sub< + let output: ::glam::Mat3A = <::glam::Mat3A as ::core::ops::Sub< ::glam::Mat3A, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -48630,12 +46829,11 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>, rhs: Ref<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::sub_mat3( - &_self, - &rhs, - ) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::sub_mat3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -48648,9 +46846,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>| { let output: [f32; 9] = { { - let output: [f32; 9] = ::glam::Mat3A::to_cols_array(&_self) - .into(); - output + let output: [f32; 9] = ::glam::Mat3A::to_cols_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -48664,10 +46863,9 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { let output: [[f32; 3]; 3] = { { let output: [[f32; 3]; 3] = ::glam::Mat3A::to_cols_array_2d( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -48681,11 +46879,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { let output: (f32, f32, f32) = { { let output: (f32, f32, f32) = ::glam::Mat3A::to_euler( - &_self, - order.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(order), + ); + safe_transmute(output) } }; output @@ -48698,12 +46895,11 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Mat3A::transform_point2( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Mat3A::transform_point2( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -48716,12 +46912,11 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Mat3A::transform_vector2( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Mat3A::transform_vector2( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -48734,9 +46929,10 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { |_self: Ref<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = ::glam::Mat3A::transpose(&_self) - .into(); - output + let output: ::glam::Mat3A = ::glam::Mat3A::transpose( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -48746,7 +46942,11 @@ pub(crate) fn register_mat_3_a_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::Mat3A, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::Mat3A, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_mat_4_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -48757,8 +46957,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::abs(&_self).into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -48772,12 +46974,11 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::Mat4::abs_diff_eq( - &_self, - rhs.into_inner(), - max_abs_diff, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_abs_diff), + ); + safe_transmute(output) } }; output @@ -48790,11 +46991,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: Ref<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Add< + let output: ::glam::Mat4 = <::glam::Mat4 as ::core::ops::Add< &::glam::Mat4, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -48807,11 +47007,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: Val<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Add< + let output: ::glam::Mat4 = <::glam::Mat4 as ::core::ops::Add< ::glam::Mat4, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -48824,12 +47023,11 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>, rhs: Ref<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::add_mat4( - &_self, - &rhs, - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::add_mat4( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -48842,9 +47040,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::Mat4::as_dmat4(&_self) - .into(); - output + let output: ::glam::DMat4 = ::glam::Mat4::as_dmat4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -48857,11 +47056,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::Mat4 = <::glam::Mat4 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -48874,9 +47072,11 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>, index: usize| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Mat4::col(&_self, index) - .into(); - output + let output: ::glam::Vec4 = ::glam::Mat4::col( + safe_transmute(_self), + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -48889,8 +47089,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>| { let output: f32 = { { - let output: f32 = ::glam::Mat4::determinant(&_self).into(); - output + let output: f32 = ::glam::Mat4::determinant( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -48903,11 +47105,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Div< + let output: ::glam::Mat4 = <::glam::Mat4 as ::core::ops::Div< f32, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -48920,12 +47121,11 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>, rhs: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::div_scalar( - &_self, - rhs, - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::div_scalar( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -48940,9 +47140,8 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { { let output: bool = <::glam::Mat4 as ::core::cmp::PartialEq< ::glam::Mat4, - >>::eq(&_self, &rhs) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -48955,12 +47154,11 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |axis: Val<::glam::Vec3>, angle: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::from_axis_angle( - axis.into_inner(), - angle, - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::from_axis_angle( + safe_transmute(axis), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -48978,14 +47176,13 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::from_cols( - x_axis.into_inner(), - y_axis.into_inner(), - z_axis.into_inner(), - w_axis.into_inner(), - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::from_cols( + safe_transmute(x_axis), + safe_transmute(y_axis), + safe_transmute(z_axis), + safe_transmute(w_axis), + ); + safe_transmute(output) } }; output @@ -48998,11 +47195,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |diagonal: Val<::glam::Vec4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::from_diagonal( - diagonal.into_inner(), - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::from_diagonal( + safe_transmute(diagonal), + ); + safe_transmute(output) } }; output @@ -49015,14 +47211,13 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |order: Val<::glam::EulerRot>, a: f32, b: f32, c: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::from_euler( - order.into_inner(), - a, - b, - c, - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::from_euler( + safe_transmute(order), + safe_transmute(a), + safe_transmute(b), + safe_transmute(c), + ); + safe_transmute(output) } }; output @@ -49035,11 +47230,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |m: Val<::glam::Mat3>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::from_mat3( - m.into_inner(), - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::from_mat3( + safe_transmute(m), + ); + safe_transmute(output) } }; output @@ -49052,12 +47246,11 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |mat3: Val<::glam::Mat3>, translation: Val<::glam::Vec3>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::from_mat3_translation( - mat3.into_inner(), - translation.into_inner(), - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::from_mat3_translation( + safe_transmute(mat3), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -49070,11 +47263,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |m: Val<::glam::Mat3A>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::from_mat3a( - m.into_inner(), - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::from_mat3a( + safe_transmute(m), + ); + safe_transmute(output) } }; output @@ -49087,11 +47279,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |rotation: Val<::glam::Quat>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::from_quat( - rotation.into_inner(), - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::from_quat( + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -49104,12 +47295,11 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |rotation: Val<::glam::Quat>, translation: Val<::glam::Vec3>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::from_rotation_translation( - rotation.into_inner(), - translation.into_inner(), - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::from_rotation_translation( + safe_transmute(rotation), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -49122,11 +47312,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |angle: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::from_rotation_x( - angle, - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::from_rotation_x( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -49139,11 +47328,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |angle: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::from_rotation_y( - angle, - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::from_rotation_y( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -49156,11 +47344,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |angle: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::from_rotation_z( - angle, - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::from_rotation_z( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -49173,11 +47360,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |scale: Val<::glam::Vec3>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::from_scale( - scale.into_inner(), - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::from_scale( + safe_transmute(scale), + ); + safe_transmute(output) } }; output @@ -49194,13 +47380,12 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::from_scale_rotation_translation( - scale.into_inner(), - rotation.into_inner(), - translation.into_inner(), - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::from_scale_rotation_translation( + safe_transmute(scale), + safe_transmute(rotation), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -49213,11 +47398,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |translation: Val<::glam::Vec3>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::from_translation( - translation.into_inner(), - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::from_translation( + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -49230,16 +47414,15 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |left: f32, right: f32, bottom: f32, top: f32, z_near: f32, z_far: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::frustum_lh( - left, - right, - bottom, - top, - z_near, - z_far, - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::frustum_lh( + safe_transmute(left), + safe_transmute(right), + safe_transmute(bottom), + safe_transmute(top), + safe_transmute(z_near), + safe_transmute(z_far), + ); + safe_transmute(output) } }; output @@ -49252,16 +47435,15 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |left: f32, right: f32, bottom: f32, top: f32, z_near: f32, z_far: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::frustum_rh( - left, - right, - bottom, - top, - z_near, - z_far, - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::frustum_rh( + safe_transmute(left), + safe_transmute(right), + safe_transmute(bottom), + safe_transmute(top), + safe_transmute(z_near), + safe_transmute(z_far), + ); + safe_transmute(output) } }; output @@ -49274,16 +47456,15 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |left: f32, right: f32, bottom: f32, top: f32, z_near: f32, z_far: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::frustum_rh_gl( - left, - right, - bottom, - top, - z_near, - z_far, - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::frustum_rh_gl( + safe_transmute(left), + safe_transmute(right), + safe_transmute(bottom), + safe_transmute(top), + safe_transmute(z_near), + safe_transmute(z_far), + ); + safe_transmute(output) } }; output @@ -49296,9 +47477,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::inverse(&_self) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::inverse( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -49311,8 +47493,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>| { let output: bool = { { - let output: bool = ::glam::Mat4::is_finite(&_self).into(); - output + let output: bool = ::glam::Mat4::is_finite( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -49325,8 +47509,8 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>| { let output: bool = { { - let output: bool = ::glam::Mat4::is_nan(&_self).into(); - output + let output: bool = ::glam::Mat4::is_nan(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -49339,13 +47523,12 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |eye: Val<::glam::Vec3>, center: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::look_at_lh( - eye.into_inner(), - center.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::look_at_lh( + safe_transmute(eye), + safe_transmute(center), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -49358,13 +47541,12 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |eye: Val<::glam::Vec3>, center: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::look_at_rh( - eye.into_inner(), - center.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::look_at_rh( + safe_transmute(eye), + safe_transmute(center), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -49377,13 +47559,12 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |eye: Val<::glam::Vec3>, dir: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::look_to_lh( - eye.into_inner(), - dir.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::look_to_lh( + safe_transmute(eye), + safe_transmute(dir), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -49396,13 +47577,12 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |eye: Val<::glam::Vec3>, dir: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::look_to_rh( - eye.into_inner(), - dir.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::look_to_rh( + safe_transmute(eye), + safe_transmute(dir), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -49415,11 +47595,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: Ref<::glam::Affine3A>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Mul< + let output: ::glam::Mat4 = <::glam::Mat4 as ::core::ops::Mul< &::glam::Affine3A, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -49432,11 +47611,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: Ref<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Mul< + let output: ::glam::Mat4 = <::glam::Mat4 as ::core::ops::Mul< &::glam::Mat4, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -49449,11 +47627,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: Ref<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Mat4 as ::core::ops::Mul< + let output: ::glam::Vec4 = <::glam::Mat4 as ::core::ops::Mul< &::glam::Vec4, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -49466,11 +47643,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: Val<::glam::Affine3A>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Mul< + let output: ::glam::Mat4 = <::glam::Mat4 as ::core::ops::Mul< ::glam::Affine3A, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -49483,11 +47659,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: Val<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Mul< + let output: ::glam::Mat4 = <::glam::Mat4 as ::core::ops::Mul< ::glam::Mat4, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -49500,11 +47675,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = <::glam::Mat4 as ::core::ops::Mul< + let output: ::glam::Vec4 = <::glam::Mat4 as ::core::ops::Mul< ::glam::Vec4, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -49517,11 +47691,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Mul< + let output: ::glam::Mat4 = <::glam::Mat4 as ::core::ops::Mul< f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -49534,12 +47707,11 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>, rhs: Ref<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::mul_mat4( - &_self, - &rhs, - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::mul_mat4( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -49552,12 +47724,11 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>, rhs: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::mul_scalar( - &_self, - rhs, - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::mul_scalar( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -49570,12 +47741,11 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>, rhs: Val<::glam::Vec4>| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Mat4::mul_vec4( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec4 = ::glam::Mat4::mul_vec4( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -49588,11 +47758,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Mat4 = <::glam::Mat4 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -49605,16 +47774,15 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |left: f32, right: f32, bottom: f32, top: f32, near: f32, far: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::orthographic_lh( - left, - right, - bottom, - top, - near, - far, - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::orthographic_lh( + safe_transmute(left), + safe_transmute(right), + safe_transmute(bottom), + safe_transmute(top), + safe_transmute(near), + safe_transmute(far), + ); + safe_transmute(output) } }; output @@ -49627,16 +47795,15 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |left: f32, right: f32, bottom: f32, top: f32, near: f32, far: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::orthographic_rh( - left, - right, - bottom, - top, - near, - far, - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::orthographic_rh( + safe_transmute(left), + safe_transmute(right), + safe_transmute(bottom), + safe_transmute(top), + safe_transmute(near), + safe_transmute(far), + ); + safe_transmute(output) } }; output @@ -49649,16 +47816,15 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |left: f32, right: f32, bottom: f32, top: f32, near: f32, far: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::orthographic_rh_gl( - left, - right, - bottom, - top, - near, - far, - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::orthographic_rh_gl( + safe_transmute(left), + safe_transmute(right), + safe_transmute(bottom), + safe_transmute(top), + safe_transmute(near), + safe_transmute(far), + ); + safe_transmute(output) } }; output @@ -49671,13 +47837,12 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |fov_y_radians: f32, aspect_ratio: f32, z_near: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::perspective_infinite_lh( - fov_y_radians, - aspect_ratio, - z_near, - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::perspective_infinite_lh( + safe_transmute(fov_y_radians), + safe_transmute(aspect_ratio), + safe_transmute(z_near), + ); + safe_transmute(output) } }; output @@ -49690,13 +47855,12 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |fov_y_radians: f32, aspect_ratio: f32, z_near: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::perspective_infinite_reverse_lh( - fov_y_radians, - aspect_ratio, - z_near, - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::perspective_infinite_reverse_lh( + safe_transmute(fov_y_radians), + safe_transmute(aspect_ratio), + safe_transmute(z_near), + ); + safe_transmute(output) } }; output @@ -49709,13 +47873,12 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |fov_y_radians: f32, aspect_ratio: f32, z_near: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::perspective_infinite_reverse_rh( - fov_y_radians, - aspect_ratio, - z_near, - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::perspective_infinite_reverse_rh( + safe_transmute(fov_y_radians), + safe_transmute(aspect_ratio), + safe_transmute(z_near), + ); + safe_transmute(output) } }; output @@ -49728,13 +47891,12 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |fov_y_radians: f32, aspect_ratio: f32, z_near: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::perspective_infinite_rh( - fov_y_radians, - aspect_ratio, - z_near, - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::perspective_infinite_rh( + safe_transmute(fov_y_radians), + safe_transmute(aspect_ratio), + safe_transmute(z_near), + ); + safe_transmute(output) } }; output @@ -49747,14 +47909,13 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |fov_y_radians: f32, aspect_ratio: f32, z_near: f32, z_far: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::perspective_lh( - fov_y_radians, - aspect_ratio, - z_near, - z_far, - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::perspective_lh( + safe_transmute(fov_y_radians), + safe_transmute(aspect_ratio), + safe_transmute(z_near), + safe_transmute(z_far), + ); + safe_transmute(output) } }; output @@ -49767,14 +47928,13 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |fov_y_radians: f32, aspect_ratio: f32, z_near: f32, z_far: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::perspective_rh( - fov_y_radians, - aspect_ratio, - z_near, - z_far, - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::perspective_rh( + safe_transmute(fov_y_radians), + safe_transmute(aspect_ratio), + safe_transmute(z_near), + safe_transmute(z_far), + ); + safe_transmute(output) } }; output @@ -49787,14 +47947,13 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |fov_y_radians: f32, aspect_ratio: f32, z_near: f32, z_far: f32| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::perspective_rh_gl( - fov_y_radians, - aspect_ratio, - z_near, - z_far, - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::perspective_rh_gl( + safe_transmute(fov_y_radians), + safe_transmute(aspect_ratio), + safe_transmute(z_near), + safe_transmute(z_far), + ); + safe_transmute(output) } }; output @@ -49807,12 +47966,11 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Mat4::project_point3( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Mat4::project_point3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -49825,12 +47983,11 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Mat4::project_point3a( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Mat4::project_point3a( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -49843,9 +48000,11 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>, index: usize| { let output: Val<::glam::Vec4> = { { - let output: Val<::glam::Vec4> = ::glam::Mat4::row(&_self, index) - .into(); - output + let output: ::glam::Vec4 = ::glam::Mat4::row( + safe_transmute(_self), + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -49858,11 +48017,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: Ref<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Sub< + let output: ::glam::Mat4 = <::glam::Mat4 as ::core::ops::Sub< &::glam::Mat4, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -49875,11 +48033,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Val<::glam::Mat4>, rhs: Val<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Sub< + let output: ::glam::Mat4 = <::glam::Mat4 as ::core::ops::Sub< ::glam::Mat4, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -49892,12 +48049,11 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>, rhs: Ref<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::sub_mat4( - &_self, - &rhs, - ) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::sub_mat4( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -49910,9 +48066,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>| { let output: [f32; 16] = { { - let output: [f32; 16] = ::glam::Mat4::to_cols_array(&_self) - .into(); - output + let output: [f32; 16] = ::glam::Mat4::to_cols_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -49926,10 +48083,9 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { let output: [[f32; 4]; 4] = { { let output: [[f32; 4]; 4] = ::glam::Mat4::to_cols_array_2d( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -49943,11 +48099,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { let output: (f32, f32, f32) = { { let output: (f32, f32, f32) = ::glam::Mat4::to_euler( - &_self, - order.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(order), + ); + safe_transmute(output) } }; output @@ -49960,12 +48115,11 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Mat4::transform_point3( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Mat4::transform_point3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -49978,12 +48132,11 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Mat4::transform_point3a( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Mat4::transform_point3a( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -49996,12 +48149,11 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Mat4::transform_vector3( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Mat4::transform_vector3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -50014,12 +48166,11 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Mat4::transform_vector3a( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Mat4::transform_vector3a( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -50032,9 +48183,10 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { |_self: Ref<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::Mat4::transpose(&_self) - .into(); - output + let output: ::glam::Mat4 = ::glam::Mat4::transpose( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -50044,7 +48196,11 @@ pub(crate) fn register_mat_4_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::Mat4, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::Mat4, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_d_mat_2_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -50055,9 +48211,10 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Ref<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = ::glam::DMat2::abs(&_self) - .into(); - output + let output: ::glam::DMat2 = ::glam::DMat2::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -50071,12 +48228,11 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::DMat2::abs_diff_eq( - &_self, - rhs.into_inner(), - max_abs_diff, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_abs_diff), + ); + safe_transmute(output) } }; output @@ -50089,11 +48245,10 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>, rhs: Ref<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Add< + let output: ::glam::DMat2 = <::glam::DMat2 as ::core::ops::Add< &::glam::DMat2, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -50106,11 +48261,10 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>, rhs: Val<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Add< + let output: ::glam::DMat2 = <::glam::DMat2 as ::core::ops::Add< ::glam::DMat2, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -50123,12 +48277,11 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Ref<::glam::DMat2>, rhs: Ref<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = ::glam::DMat2::add_mat2( - &_self, - &rhs, - ) - .into(); - output + let output: ::glam::DMat2 = ::glam::DMat2::add_mat2( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -50141,9 +48294,10 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Ref<::glam::DMat2>| { let output: Val<::glam::Mat2> = { { - let output: Val<::glam::Mat2> = ::glam::DMat2::as_mat2(&_self) - .into(); - output + let output: ::glam::Mat2 = ::glam::DMat2::as_mat2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -50156,11 +48310,10 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Ref<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::DMat2 = <::glam::DMat2 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -50173,12 +48326,11 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Ref<::glam::DMat2>, index: usize| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DMat2::col( - &_self, - index, - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DMat2::col( + safe_transmute(_self), + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -50191,8 +48343,10 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Ref<::glam::DMat2>| { let output: f64 = { { - let output: f64 = ::glam::DMat2::determinant(&_self).into(); - output + let output: f64 = ::glam::DMat2::determinant( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -50205,11 +48359,10 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>, rhs: f64| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Div< + let output: ::glam::DMat2 = <::glam::DMat2 as ::core::ops::Div< f64, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -50222,12 +48375,11 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Ref<::glam::DMat2>, rhs: f64| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = ::glam::DMat2::div_scalar( - &_self, - rhs, - ) - .into(); - output + let output: ::glam::DMat2 = ::glam::DMat2::div_scalar( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -50242,9 +48394,8 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { { let output: bool = <::glam::DMat2 as ::core::cmp::PartialEq< ::glam::DMat2, - >>::eq(&_self, &rhs) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -50257,9 +48408,10 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |angle: f64| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = ::glam::DMat2::from_angle(angle) - .into(); - output + let output: ::glam::DMat2 = ::glam::DMat2::from_angle( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -50272,12 +48424,11 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |x_axis: Val<::glam::DVec2>, y_axis: Val<::glam::DVec2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = ::glam::DMat2::from_cols( - x_axis.into_inner(), - y_axis.into_inner(), - ) - .into(); - output + let output: ::glam::DMat2 = ::glam::DMat2::from_cols( + safe_transmute(x_axis), + safe_transmute(y_axis), + ); + safe_transmute(output) } }; output @@ -50290,11 +48441,10 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |diagonal: Val<::glam::DVec2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = ::glam::DMat2::from_diagonal( - diagonal.into_inner(), - ) - .into(); - output + let output: ::glam::DMat2 = ::glam::DMat2::from_diagonal( + safe_transmute(diagonal), + ); + safe_transmute(output) } }; output @@ -50307,11 +48457,10 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |m: Val<::glam::DMat3>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = ::glam::DMat2::from_mat3( - m.into_inner(), - ) - .into(); - output + let output: ::glam::DMat2 = ::glam::DMat2::from_mat3( + safe_transmute(m), + ); + safe_transmute(output) } }; output @@ -50324,13 +48473,12 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |m: Val<::glam::DMat3>, i: usize, j: usize| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = ::glam::DMat2::from_mat3_minor( - m.into_inner(), - i, - j, - ) - .into(); - output + let output: ::glam::DMat2 = ::glam::DMat2::from_mat3_minor( + safe_transmute(m), + safe_transmute(i), + safe_transmute(j), + ); + safe_transmute(output) } }; output @@ -50343,12 +48491,11 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |scale: Val<::glam::DVec2>, angle: f64| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = ::glam::DMat2::from_scale_angle( - scale.into_inner(), - angle, - ) - .into(); - output + let output: ::glam::DMat2 = ::glam::DMat2::from_scale_angle( + safe_transmute(scale), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -50361,9 +48508,10 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Ref<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = ::glam::DMat2::inverse(&_self) - .into(); - output + let output: ::glam::DMat2 = ::glam::DMat2::inverse( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -50376,8 +48524,10 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Ref<::glam::DMat2>| { let output: bool = { { - let output: bool = ::glam::DMat2::is_finite(&_self).into(); - output + let output: bool = ::glam::DMat2::is_finite( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -50390,8 +48540,8 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Ref<::glam::DMat2>| { let output: bool = { { - let output: bool = ::glam::DMat2::is_nan(&_self).into(); - output + let output: bool = ::glam::DMat2::is_nan(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -50404,11 +48554,10 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>, rhs: Ref<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Mul< + let output: ::glam::DMat2 = <::glam::DMat2 as ::core::ops::Mul< &::glam::DMat2, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -50421,11 +48570,10 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>, rhs: Ref<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DMat2 as ::core::ops::Mul< + let output: ::glam::DVec2 = <::glam::DMat2 as ::core::ops::Mul< &::glam::DVec2, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -50438,11 +48586,10 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>, rhs: Val<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Mul< + let output: ::glam::DMat2 = <::glam::DMat2 as ::core::ops::Mul< ::glam::DMat2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -50455,11 +48602,10 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = <::glam::DMat2 as ::core::ops::Mul< + let output: ::glam::DVec2 = <::glam::DMat2 as ::core::ops::Mul< ::glam::DVec2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -50472,11 +48618,10 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>, rhs: f64| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Mul< + let output: ::glam::DMat2 = <::glam::DMat2 as ::core::ops::Mul< f64, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -50489,12 +48634,11 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Ref<::glam::DMat2>, rhs: Ref<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = ::glam::DMat2::mul_mat2( - &_self, - &rhs, - ) - .into(); - output + let output: ::glam::DMat2 = ::glam::DMat2::mul_mat2( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -50507,12 +48651,11 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Ref<::glam::DMat2>, rhs: f64| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = ::glam::DMat2::mul_scalar( - &_self, - rhs, - ) - .into(); - output + let output: ::glam::DMat2 = ::glam::DMat2::mul_scalar( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -50525,12 +48668,11 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Ref<::glam::DMat2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DMat2::mul_vec2( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DMat2::mul_vec2( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -50543,11 +48685,10 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DMat2 = <::glam::DMat2 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -50560,12 +48701,11 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Ref<::glam::DMat2>, index: usize| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DMat2::row( - &_self, - index, - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DMat2::row( + safe_transmute(_self), + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -50578,11 +48718,10 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>, rhs: Ref<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Sub< + let output: ::glam::DMat2 = <::glam::DMat2 as ::core::ops::Sub< &::glam::DMat2, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -50595,11 +48734,10 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Val<::glam::DMat2>, rhs: Val<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Sub< + let output: ::glam::DMat2 = <::glam::DMat2 as ::core::ops::Sub< ::glam::DMat2, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -50612,12 +48750,11 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Ref<::glam::DMat2>, rhs: Ref<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = ::glam::DMat2::sub_mat2( - &_self, - &rhs, - ) - .into(); - output + let output: ::glam::DMat2 = ::glam::DMat2::sub_mat2( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -50630,9 +48767,10 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Ref<::glam::DMat2>| { let output: [f64; 4] = { { - let output: [f64; 4] = ::glam::DMat2::to_cols_array(&_self) - .into(); - output + let output: [f64; 4] = ::glam::DMat2::to_cols_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -50646,10 +48784,9 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { let output: [[f64; 2]; 2] = { { let output: [[f64; 2]; 2] = ::glam::DMat2::to_cols_array_2d( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -50662,9 +48799,10 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { |_self: Ref<::glam::DMat2>| { let output: Val<::glam::DMat2> = { { - let output: Val<::glam::DMat2> = ::glam::DMat2::transpose(&_self) - .into(); - output + let output: ::glam::DMat2 = ::glam::DMat2::transpose( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -50674,7 +48812,11 @@ pub(crate) fn register_d_mat_2_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::DMat2, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::DMat2, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_d_mat_3_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -50685,9 +48827,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Ref<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::abs(&_self) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -50701,12 +48844,11 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::DMat3::abs_diff_eq( - &_self, - rhs.into_inner(), - max_abs_diff, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_abs_diff), + ); + safe_transmute(output) } }; output @@ -50719,11 +48861,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: Ref<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Add< + let output: ::glam::DMat3 = <::glam::DMat3 as ::core::ops::Add< &::glam::DMat3, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -50736,11 +48877,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: Val<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Add< + let output: ::glam::DMat3 = <::glam::DMat3 as ::core::ops::Add< ::glam::DMat3, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -50753,12 +48893,11 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Ref<::glam::DMat3>, rhs: Ref<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::add_mat3( - &_self, - &rhs, - ) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::add_mat3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -50771,9 +48910,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Ref<::glam::DMat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = ::glam::DMat3::as_mat3(&_self) - .into(); - output + let output: ::glam::Mat3 = ::glam::DMat3::as_mat3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -50786,11 +48926,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Ref<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::DMat3 = <::glam::DMat3 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -50803,12 +48942,11 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Ref<::glam::DMat3>, index: usize| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DMat3::col( - &_self, - index, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DMat3::col( + safe_transmute(_self), + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -50821,8 +48959,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Ref<::glam::DMat3>| { let output: f64 = { { - let output: f64 = ::glam::DMat3::determinant(&_self).into(); - output + let output: f64 = ::glam::DMat3::determinant( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -50835,11 +48975,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: f64| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Div< + let output: ::glam::DMat3 = <::glam::DMat3 as ::core::ops::Div< f64, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -50852,12 +48991,11 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Ref<::glam::DMat3>, rhs: f64| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::div_scalar( - &_self, - rhs, - ) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::div_scalar( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -50872,9 +49010,8 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { { let output: bool = <::glam::DMat3 as ::core::cmp::PartialEq< ::glam::DMat3, - >>::eq(&_self, &rhs) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -50887,9 +49024,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |angle: f64| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::from_angle(angle) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::from_angle( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -50902,12 +49040,11 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |axis: Val<::glam::DVec3>, angle: f64| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::from_axis_angle( - axis.into_inner(), - angle, - ) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::from_axis_angle( + safe_transmute(axis), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -50924,13 +49061,12 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::from_cols( - x_axis.into_inner(), - y_axis.into_inner(), - z_axis.into_inner(), - ) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::from_cols( + safe_transmute(x_axis), + safe_transmute(y_axis), + safe_transmute(z_axis), + ); + safe_transmute(output) } }; output @@ -50943,11 +49079,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |diagonal: Val<::glam::DVec3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::from_diagonal( - diagonal.into_inner(), - ) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::from_diagonal( + safe_transmute(diagonal), + ); + safe_transmute(output) } }; output @@ -50960,14 +49095,13 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |order: Val<::glam::EulerRot>, a: f64, b: f64, c: f64| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::from_euler( - order.into_inner(), - a, - b, - c, - ) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::from_euler( + safe_transmute(order), + safe_transmute(a), + safe_transmute(b), + safe_transmute(c), + ); + safe_transmute(output) } }; output @@ -50980,11 +49114,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |m: Val<::glam::DMat2>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::from_mat2( - m.into_inner(), - ) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::from_mat2( + safe_transmute(m), + ); + safe_transmute(output) } }; output @@ -50997,11 +49130,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |m: Val<::glam::DMat4>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::from_mat4( - m.into_inner(), - ) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::from_mat4( + safe_transmute(m), + ); + safe_transmute(output) } }; output @@ -51014,13 +49146,12 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |m: Val<::glam::DMat4>, i: usize, j: usize| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::from_mat4_minor( - m.into_inner(), - i, - j, - ) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::from_mat4_minor( + safe_transmute(m), + safe_transmute(i), + safe_transmute(j), + ); + safe_transmute(output) } }; output @@ -51033,11 +49164,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |rotation: Val<::glam::DQuat>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::from_quat( - rotation.into_inner(), - ) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::from_quat( + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -51050,11 +49180,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |angle: f64| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::from_rotation_x( - angle, - ) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::from_rotation_x( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -51067,11 +49196,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |angle: f64| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::from_rotation_y( - angle, - ) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::from_rotation_y( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -51084,11 +49212,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |angle: f64| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::from_rotation_z( - angle, - ) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::from_rotation_z( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -51101,11 +49228,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |scale: Val<::glam::DVec2>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::from_scale( - scale.into_inner(), - ) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::from_scale( + safe_transmute(scale), + ); + safe_transmute(output) } }; output @@ -51118,13 +49244,12 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |scale: Val<::glam::DVec2>, angle: f64, translation: Val<::glam::DVec2>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::from_scale_angle_translation( - scale.into_inner(), - angle, - translation.into_inner(), - ) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::from_scale_angle_translation( + safe_transmute(scale), + safe_transmute(angle), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -51137,11 +49262,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |translation: Val<::glam::DVec2>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::from_translation( - translation.into_inner(), - ) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::from_translation( + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -51154,9 +49278,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Ref<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::inverse(&_self) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::inverse( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -51169,8 +49294,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Ref<::glam::DMat3>| { let output: bool = { { - let output: bool = ::glam::DMat3::is_finite(&_self).into(); - output + let output: bool = ::glam::DMat3::is_finite( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -51183,8 +49310,8 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Ref<::glam::DMat3>| { let output: bool = { { - let output: bool = ::glam::DMat3::is_nan(&_self).into(); - output + let output: bool = ::glam::DMat3::is_nan(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -51201,13 +49328,12 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::look_at_lh( - eye.into_inner(), - center.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::look_at_lh( + safe_transmute(eye), + safe_transmute(center), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -51224,13 +49350,12 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::look_at_rh( - eye.into_inner(), - center.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::look_at_rh( + safe_transmute(eye), + safe_transmute(center), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -51243,12 +49368,11 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |dir: Val<::glam::DVec3>, up: Val<::glam::DVec3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::look_to_lh( - dir.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::look_to_lh( + safe_transmute(dir), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -51261,12 +49385,11 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |dir: Val<::glam::DVec3>, up: Val<::glam::DVec3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::look_to_rh( - dir.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::look_to_rh( + safe_transmute(dir), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -51279,11 +49402,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: Ref<::glam::DAffine2>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Mul< + let output: ::glam::DMat3 = <::glam::DMat3 as ::core::ops::Mul< &::glam::DAffine2, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -51296,11 +49418,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: Ref<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Mul< + let output: ::glam::DMat3 = <::glam::DMat3 as ::core::ops::Mul< &::glam::DMat3, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -51313,11 +49434,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DMat3 as ::core::ops::Mul< + let output: ::glam::DVec3 = <::glam::DMat3 as ::core::ops::Mul< &::glam::DVec3, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -51330,11 +49450,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: Val<::glam::DAffine2>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Mul< + let output: ::glam::DMat3 = <::glam::DMat3 as ::core::ops::Mul< ::glam::DAffine2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -51347,11 +49466,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: Val<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Mul< + let output: ::glam::DMat3 = <::glam::DMat3 as ::core::ops::Mul< ::glam::DMat3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -51364,11 +49482,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DMat3 as ::core::ops::Mul< + let output: ::glam::DVec3 = <::glam::DMat3 as ::core::ops::Mul< ::glam::DVec3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -51381,11 +49498,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: f64| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Mul< + let output: ::glam::DMat3 = <::glam::DMat3 as ::core::ops::Mul< f64, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -51398,12 +49514,11 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Ref<::glam::DMat3>, rhs: Ref<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::mul_mat3( - &_self, - &rhs, - ) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::mul_mat3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -51416,12 +49531,11 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Ref<::glam::DMat3>, rhs: f64| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::mul_scalar( - &_self, - rhs, - ) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::mul_scalar( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -51434,12 +49548,11 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Ref<::glam::DMat3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DMat3::mul_vec3( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DMat3::mul_vec3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -51452,11 +49565,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DMat3 = <::glam::DMat3 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -51469,12 +49581,11 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Ref<::glam::DMat3>, index: usize| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DMat3::row( - &_self, - index, - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DMat3::row( + safe_transmute(_self), + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -51487,11 +49598,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: Ref<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Sub< + let output: ::glam::DMat3 = <::glam::DMat3 as ::core::ops::Sub< &::glam::DMat3, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -51504,11 +49614,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Val<::glam::DMat3>, rhs: Val<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Sub< + let output: ::glam::DMat3 = <::glam::DMat3 as ::core::ops::Sub< ::glam::DMat3, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -51521,12 +49630,11 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Ref<::glam::DMat3>, rhs: Ref<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::sub_mat3( - &_self, - &rhs, - ) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::sub_mat3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -51539,9 +49647,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Ref<::glam::DMat3>| { let output: [f64; 9] = { { - let output: [f64; 9] = ::glam::DMat3::to_cols_array(&_self) - .into(); - output + let output: [f64; 9] = ::glam::DMat3::to_cols_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -51555,10 +49664,9 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { let output: [[f64; 3]; 3] = { { let output: [[f64; 3]; 3] = ::glam::DMat3::to_cols_array_2d( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -51572,11 +49680,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { let output: (f64, f64, f64) = { { let output: (f64, f64, f64) = ::glam::DMat3::to_euler( - &_self, - order.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(order), + ); + safe_transmute(output) } }; output @@ -51589,12 +49696,11 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Ref<::glam::DMat3>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DMat3::transform_point2( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DMat3::transform_point2( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -51607,12 +49713,11 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Ref<::glam::DMat3>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DMat3::transform_vector2( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DMat3::transform_vector2( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -51625,9 +49730,10 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { |_self: Ref<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = ::glam::DMat3::transpose(&_self) - .into(); - output + let output: ::glam::DMat3 = ::glam::DMat3::transpose( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -51637,7 +49743,11 @@ pub(crate) fn register_d_mat_3_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::DMat3, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::DMat3, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_d_mat_4_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -51648,9 +49758,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::abs(&_self) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::abs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -51664,12 +49775,11 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::DMat4::abs_diff_eq( - &_self, - rhs.into_inner(), - max_abs_diff, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_abs_diff), + ); + safe_transmute(output) } }; output @@ -51682,11 +49792,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: Ref<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Add< + let output: ::glam::DMat4 = <::glam::DMat4 as ::core::ops::Add< &::glam::DMat4, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -51699,11 +49808,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: Val<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Add< + let output: ::glam::DMat4 = <::glam::DMat4 as ::core::ops::Add< ::glam::DMat4, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -51716,12 +49824,11 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>, rhs: Ref<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::add_mat4( - &_self, - &rhs, - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::add_mat4( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -51734,9 +49841,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = ::glam::DMat4::as_mat4(&_self) - .into(); - output + let output: ::glam::Mat4 = ::glam::DMat4::as_mat4( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -51749,11 +49857,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::DMat4 = <::glam::DMat4 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -51766,12 +49873,11 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>, index: usize| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DMat4::col( - &_self, - index, - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DMat4::col( + safe_transmute(_self), + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -51784,8 +49890,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>| { let output: f64 = { { - let output: f64 = ::glam::DMat4::determinant(&_self).into(); - output + let output: f64 = ::glam::DMat4::determinant( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -51798,11 +49906,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Div< + let output: ::glam::DMat4 = <::glam::DMat4 as ::core::ops::Div< f64, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -51815,12 +49922,11 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>, rhs: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::div_scalar( - &_self, - rhs, - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::div_scalar( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -51835,9 +49941,8 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { { let output: bool = <::glam::DMat4 as ::core::cmp::PartialEq< ::glam::DMat4, - >>::eq(&_self, &rhs) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -51850,12 +49955,11 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |axis: Val<::glam::DVec3>, angle: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::from_axis_angle( - axis.into_inner(), - angle, - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::from_axis_angle( + safe_transmute(axis), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -51873,14 +49977,13 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::from_cols( - x_axis.into_inner(), - y_axis.into_inner(), - z_axis.into_inner(), - w_axis.into_inner(), - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::from_cols( + safe_transmute(x_axis), + safe_transmute(y_axis), + safe_transmute(z_axis), + safe_transmute(w_axis), + ); + safe_transmute(output) } }; output @@ -51893,11 +49996,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |diagonal: Val<::glam::DVec4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::from_diagonal( - diagonal.into_inner(), - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::from_diagonal( + safe_transmute(diagonal), + ); + safe_transmute(output) } }; output @@ -51910,14 +50012,13 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |order: Val<::glam::EulerRot>, a: f64, b: f64, c: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::from_euler( - order.into_inner(), - a, - b, - c, - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::from_euler( + safe_transmute(order), + safe_transmute(a), + safe_transmute(b), + safe_transmute(c), + ); + safe_transmute(output) } }; output @@ -51930,11 +50031,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |m: Val<::glam::DMat3>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::from_mat3( - m.into_inner(), - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::from_mat3( + safe_transmute(m), + ); + safe_transmute(output) } }; output @@ -51947,12 +50047,11 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |mat3: Val<::glam::DMat3>, translation: Val<::glam::DVec3>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::from_mat3_translation( - mat3.into_inner(), - translation.into_inner(), - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::from_mat3_translation( + safe_transmute(mat3), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -51965,11 +50064,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |rotation: Val<::glam::DQuat>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::from_quat( - rotation.into_inner(), - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::from_quat( + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -51982,12 +50080,11 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |rotation: Val<::glam::DQuat>, translation: Val<::glam::DVec3>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::from_rotation_translation( - rotation.into_inner(), - translation.into_inner(), - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::from_rotation_translation( + safe_transmute(rotation), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -52000,11 +50097,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |angle: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::from_rotation_x( - angle, - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::from_rotation_x( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -52017,11 +50113,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |angle: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::from_rotation_y( - angle, - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::from_rotation_y( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -52034,11 +50129,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |angle: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::from_rotation_z( - angle, - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::from_rotation_z( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -52051,11 +50145,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |scale: Val<::glam::DVec3>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::from_scale( - scale.into_inner(), - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::from_scale( + safe_transmute(scale), + ); + safe_transmute(output) } }; output @@ -52072,13 +50165,12 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::from_scale_rotation_translation( - scale.into_inner(), - rotation.into_inner(), - translation.into_inner(), - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::from_scale_rotation_translation( + safe_transmute(scale), + safe_transmute(rotation), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -52091,11 +50183,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |translation: Val<::glam::DVec3>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::from_translation( - translation.into_inner(), - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::from_translation( + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -52108,16 +50199,15 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |left: f64, right: f64, bottom: f64, top: f64, z_near: f64, z_far: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::frustum_lh( - left, - right, - bottom, - top, - z_near, - z_far, - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::frustum_lh( + safe_transmute(left), + safe_transmute(right), + safe_transmute(bottom), + safe_transmute(top), + safe_transmute(z_near), + safe_transmute(z_far), + ); + safe_transmute(output) } }; output @@ -52130,16 +50220,15 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |left: f64, right: f64, bottom: f64, top: f64, z_near: f64, z_far: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::frustum_rh( - left, - right, - bottom, - top, - z_near, - z_far, - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::frustum_rh( + safe_transmute(left), + safe_transmute(right), + safe_transmute(bottom), + safe_transmute(top), + safe_transmute(z_near), + safe_transmute(z_far), + ); + safe_transmute(output) } }; output @@ -52152,16 +50241,15 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |left: f64, right: f64, bottom: f64, top: f64, z_near: f64, z_far: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::frustum_rh_gl( - left, - right, - bottom, - top, - z_near, - z_far, - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::frustum_rh_gl( + safe_transmute(left), + safe_transmute(right), + safe_transmute(bottom), + safe_transmute(top), + safe_transmute(z_near), + safe_transmute(z_far), + ); + safe_transmute(output) } }; output @@ -52174,9 +50262,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::inverse(&_self) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::inverse( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -52189,8 +50278,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>| { let output: bool = { { - let output: bool = ::glam::DMat4::is_finite(&_self).into(); - output + let output: bool = ::glam::DMat4::is_finite( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -52203,8 +50294,8 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>| { let output: bool = { { - let output: bool = ::glam::DMat4::is_nan(&_self).into(); - output + let output: bool = ::glam::DMat4::is_nan(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -52221,13 +50312,12 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::look_at_lh( - eye.into_inner(), - center.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::look_at_lh( + safe_transmute(eye), + safe_transmute(center), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -52244,13 +50334,12 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::look_at_rh( - eye.into_inner(), - center.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::look_at_rh( + safe_transmute(eye), + safe_transmute(center), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -52263,13 +50352,12 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |eye: Val<::glam::DVec3>, dir: Val<::glam::DVec3>, up: Val<::glam::DVec3>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::look_to_lh( - eye.into_inner(), - dir.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::look_to_lh( + safe_transmute(eye), + safe_transmute(dir), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -52282,13 +50370,12 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |eye: Val<::glam::DVec3>, dir: Val<::glam::DVec3>, up: Val<::glam::DVec3>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::look_to_rh( - eye.into_inner(), - dir.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::look_to_rh( + safe_transmute(eye), + safe_transmute(dir), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -52301,11 +50388,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: Ref<::glam::DAffine3>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Mul< + let output: ::glam::DMat4 = <::glam::DMat4 as ::core::ops::Mul< &::glam::DAffine3, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -52318,11 +50404,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: Ref<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Mul< + let output: ::glam::DMat4 = <::glam::DMat4 as ::core::ops::Mul< &::glam::DMat4, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -52335,11 +50420,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: Ref<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DMat4 as ::core::ops::Mul< + let output: ::glam::DVec4 = <::glam::DMat4 as ::core::ops::Mul< &::glam::DVec4, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -52352,11 +50436,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: Val<::glam::DAffine3>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Mul< + let output: ::glam::DMat4 = <::glam::DMat4 as ::core::ops::Mul< ::glam::DAffine3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -52369,11 +50452,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: Val<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Mul< + let output: ::glam::DMat4 = <::glam::DMat4 as ::core::ops::Mul< ::glam::DMat4, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -52386,11 +50468,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = <::glam::DMat4 as ::core::ops::Mul< + let output: ::glam::DVec4 = <::glam::DMat4 as ::core::ops::Mul< ::glam::DVec4, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -52403,11 +50484,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Mul< + let output: ::glam::DMat4 = <::glam::DMat4 as ::core::ops::Mul< f64, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -52420,12 +50500,11 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>, rhs: Ref<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::mul_mat4( - &_self, - &rhs, - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::mul_mat4( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -52438,12 +50517,11 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>, rhs: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::mul_scalar( - &_self, - rhs, - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::mul_scalar( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -52456,12 +50534,11 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>, rhs: Val<::glam::DVec4>| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DMat4::mul_vec4( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DMat4::mul_vec4( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -52474,11 +50551,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DMat4 = <::glam::DMat4 as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -52491,16 +50567,15 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |left: f64, right: f64, bottom: f64, top: f64, near: f64, far: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::orthographic_lh( - left, - right, - bottom, - top, - near, - far, - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::orthographic_lh( + safe_transmute(left), + safe_transmute(right), + safe_transmute(bottom), + safe_transmute(top), + safe_transmute(near), + safe_transmute(far), + ); + safe_transmute(output) } }; output @@ -52513,16 +50588,15 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |left: f64, right: f64, bottom: f64, top: f64, near: f64, far: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::orthographic_rh( - left, - right, - bottom, - top, - near, - far, - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::orthographic_rh( + safe_transmute(left), + safe_transmute(right), + safe_transmute(bottom), + safe_transmute(top), + safe_transmute(near), + safe_transmute(far), + ); + safe_transmute(output) } }; output @@ -52535,16 +50609,15 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |left: f64, right: f64, bottom: f64, top: f64, near: f64, far: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::orthographic_rh_gl( - left, - right, - bottom, - top, - near, - far, - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::orthographic_rh_gl( + safe_transmute(left), + safe_transmute(right), + safe_transmute(bottom), + safe_transmute(top), + safe_transmute(near), + safe_transmute(far), + ); + safe_transmute(output) } }; output @@ -52557,13 +50630,12 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |fov_y_radians: f64, aspect_ratio: f64, z_near: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::perspective_infinite_lh( - fov_y_radians, - aspect_ratio, - z_near, - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::perspective_infinite_lh( + safe_transmute(fov_y_radians), + safe_transmute(aspect_ratio), + safe_transmute(z_near), + ); + safe_transmute(output) } }; output @@ -52576,13 +50648,12 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |fov_y_radians: f64, aspect_ratio: f64, z_near: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::perspective_infinite_reverse_lh( - fov_y_radians, - aspect_ratio, - z_near, - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::perspective_infinite_reverse_lh( + safe_transmute(fov_y_radians), + safe_transmute(aspect_ratio), + safe_transmute(z_near), + ); + safe_transmute(output) } }; output @@ -52595,13 +50666,12 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |fov_y_radians: f64, aspect_ratio: f64, z_near: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::perspective_infinite_reverse_rh( - fov_y_radians, - aspect_ratio, - z_near, - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::perspective_infinite_reverse_rh( + safe_transmute(fov_y_radians), + safe_transmute(aspect_ratio), + safe_transmute(z_near), + ); + safe_transmute(output) } }; output @@ -52614,13 +50684,12 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |fov_y_radians: f64, aspect_ratio: f64, z_near: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::perspective_infinite_rh( - fov_y_radians, - aspect_ratio, - z_near, - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::perspective_infinite_rh( + safe_transmute(fov_y_radians), + safe_transmute(aspect_ratio), + safe_transmute(z_near), + ); + safe_transmute(output) } }; output @@ -52633,14 +50702,13 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |fov_y_radians: f64, aspect_ratio: f64, z_near: f64, z_far: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::perspective_lh( - fov_y_radians, - aspect_ratio, - z_near, - z_far, - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::perspective_lh( + safe_transmute(fov_y_radians), + safe_transmute(aspect_ratio), + safe_transmute(z_near), + safe_transmute(z_far), + ); + safe_transmute(output) } }; output @@ -52653,14 +50721,13 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |fov_y_radians: f64, aspect_ratio: f64, z_near: f64, z_far: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::perspective_rh( - fov_y_radians, - aspect_ratio, - z_near, - z_far, - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::perspective_rh( + safe_transmute(fov_y_radians), + safe_transmute(aspect_ratio), + safe_transmute(z_near), + safe_transmute(z_far), + ); + safe_transmute(output) } }; output @@ -52673,14 +50740,13 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |fov_y_radians: f64, aspect_ratio: f64, z_near: f64, z_far: f64| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::perspective_rh_gl( - fov_y_radians, - aspect_ratio, - z_near, - z_far, - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::perspective_rh_gl( + safe_transmute(fov_y_radians), + safe_transmute(aspect_ratio), + safe_transmute(z_near), + safe_transmute(z_far), + ); + safe_transmute(output) } }; output @@ -52693,12 +50759,11 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DMat4::project_point3( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DMat4::project_point3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -52711,12 +50776,11 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>, index: usize| { let output: Val<::glam::DVec4> = { { - let output: Val<::glam::DVec4> = ::glam::DMat4::row( - &_self, - index, - ) - .into(); - output + let output: ::glam::DVec4 = ::glam::DMat4::row( + safe_transmute(_self), + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -52729,11 +50793,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: Ref<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Sub< + let output: ::glam::DMat4 = <::glam::DMat4 as ::core::ops::Sub< &::glam::DMat4, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -52746,11 +50809,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Val<::glam::DMat4>, rhs: Val<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Sub< + let output: ::glam::DMat4 = <::glam::DMat4 as ::core::ops::Sub< ::glam::DMat4, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -52763,12 +50825,11 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>, rhs: Ref<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::sub_mat4( - &_self, - &rhs, - ) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::sub_mat4( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -52781,9 +50842,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>| { let output: [f64; 16] = { { - let output: [f64; 16] = ::glam::DMat4::to_cols_array(&_self) - .into(); - output + let output: [f64; 16] = ::glam::DMat4::to_cols_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -52797,10 +50859,9 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { let output: [[f64; 4]; 4] = { { let output: [[f64; 4]; 4] = ::glam::DMat4::to_cols_array_2d( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -52814,11 +50875,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { let output: (f64, f64, f64) = { { let output: (f64, f64, f64) = ::glam::DMat4::to_euler( - &_self, - order.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(order), + ); + safe_transmute(output) } }; output @@ -52831,12 +50891,11 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DMat4::transform_point3( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DMat4::transform_point3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -52849,12 +50908,11 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DMat4::transform_vector3( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DMat4::transform_vector3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -52867,9 +50925,10 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { |_self: Ref<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = ::glam::DMat4::transpose(&_self) - .into(); - output + let output: ::glam::DMat4 = ::glam::DMat4::transpose( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -52879,7 +50938,11 @@ pub(crate) fn register_d_mat_4_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::DMat4, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::DMat4, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_affine_2_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -52891,12 +50954,11 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::Affine2::abs_diff_eq( - &_self, - rhs.into_inner(), - max_abs_diff, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_abs_diff), + ); + safe_transmute(output) } }; output @@ -52909,11 +50971,10 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Ref<::glam::Affine2>| { let output: Val<::glam::DAffine2> = { { - let output: Val<::glam::DAffine2> = ::glam::Affine2::as_daffine2( - &_self, - ) - .into(); - output + let output: ::glam::DAffine2 = ::glam::Affine2::as_daffine2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -52926,11 +50987,10 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Ref<::glam::Affine2>| { let output: Val<::glam::Affine2> = { { - let output: Val<::glam::Affine2> = <::glam::Affine2 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::Affine2 = <::glam::Affine2 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -52945,9 +51005,8 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { { let output: bool = <::glam::Affine2 as ::core::cmp::PartialEq< ::glam::Affine2, - >>::eq(&_self, &rhs) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -52960,11 +51019,10 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |angle: f32| { let output: Val<::glam::Affine2> = { { - let output: Val<::glam::Affine2> = ::glam::Affine2::from_angle( - angle, - ) - .into(); - output + let output: ::glam::Affine2 = ::glam::Affine2::from_angle( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -52977,12 +51035,11 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |angle: f32, translation: Val<::glam::Vec2>| { let output: Val<::glam::Affine2> = { { - let output: Val<::glam::Affine2> = ::glam::Affine2::from_angle_translation( - angle, - translation.into_inner(), - ) - .into(); - output + let output: ::glam::Affine2 = ::glam::Affine2::from_angle_translation( + safe_transmute(angle), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -52999,13 +51056,12 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { { let output: Val<::glam::Affine2> = { { - let output: Val<::glam::Affine2> = ::glam::Affine2::from_cols( - x_axis.into_inner(), - y_axis.into_inner(), - z_axis.into_inner(), - ) - .into(); - output + let output: ::glam::Affine2 = ::glam::Affine2::from_cols( + safe_transmute(x_axis), + safe_transmute(y_axis), + safe_transmute(z_axis), + ); + safe_transmute(output) } }; output @@ -53018,11 +51074,10 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |matrix2: Val<::glam::Mat2>| { let output: Val<::glam::Affine2> = { { - let output: Val<::glam::Affine2> = ::glam::Affine2::from_mat2( - matrix2.into_inner(), - ) - .into(); - output + let output: ::glam::Affine2 = ::glam::Affine2::from_mat2( + safe_transmute(matrix2), + ); + safe_transmute(output) } }; output @@ -53035,12 +51090,11 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |matrix2: Val<::glam::Mat2>, translation: Val<::glam::Vec2>| { let output: Val<::glam::Affine2> = { { - let output: Val<::glam::Affine2> = ::glam::Affine2::from_mat2_translation( - matrix2.into_inner(), - translation.into_inner(), - ) - .into(); - output + let output: ::glam::Affine2 = ::glam::Affine2::from_mat2_translation( + safe_transmute(matrix2), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -53053,11 +51107,10 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |m: Val<::glam::Mat3>| { let output: Val<::glam::Affine2> = { { - let output: Val<::glam::Affine2> = ::glam::Affine2::from_mat3( - m.into_inner(), - ) - .into(); - output + let output: ::glam::Affine2 = ::glam::Affine2::from_mat3( + safe_transmute(m), + ); + safe_transmute(output) } }; output @@ -53070,11 +51123,10 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |m: Val<::glam::Mat3A>| { let output: Val<::glam::Affine2> = { { - let output: Val<::glam::Affine2> = ::glam::Affine2::from_mat3a( - m.into_inner(), - ) - .into(); - output + let output: ::glam::Affine2 = ::glam::Affine2::from_mat3a( + safe_transmute(m), + ); + safe_transmute(output) } }; output @@ -53087,11 +51139,10 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |scale: Val<::glam::Vec2>| { let output: Val<::glam::Affine2> = { { - let output: Val<::glam::Affine2> = ::glam::Affine2::from_scale( - scale.into_inner(), - ) - .into(); - output + let output: ::glam::Affine2 = ::glam::Affine2::from_scale( + safe_transmute(scale), + ); + safe_transmute(output) } }; output @@ -53104,13 +51155,12 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |scale: Val<::glam::Vec2>, angle: f32, translation: Val<::glam::Vec2>| { let output: Val<::glam::Affine2> = { { - let output: Val<::glam::Affine2> = ::glam::Affine2::from_scale_angle_translation( - scale.into_inner(), - angle, - translation.into_inner(), - ) - .into(); - output + let output: ::glam::Affine2 = ::glam::Affine2::from_scale_angle_translation( + safe_transmute(scale), + safe_transmute(angle), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -53123,11 +51173,10 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |translation: Val<::glam::Vec2>| { let output: Val<::glam::Affine2> = { { - let output: Val<::glam::Affine2> = ::glam::Affine2::from_translation( - translation.into_inner(), - ) - .into(); - output + let output: ::glam::Affine2 = ::glam::Affine2::from_translation( + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -53140,11 +51189,10 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Ref<::glam::Affine2>| { let output: Val<::glam::Affine2> = { { - let output: Val<::glam::Affine2> = ::glam::Affine2::inverse( - &_self, - ) - .into(); - output + let output: ::glam::Affine2 = ::glam::Affine2::inverse( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -53157,8 +51205,10 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Ref<::glam::Affine2>| { let output: bool = { { - let output: bool = ::glam::Affine2::is_finite(&_self).into(); - output + let output: bool = ::glam::Affine2::is_finite( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -53171,8 +51221,10 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Ref<::glam::Affine2>| { let output: bool = { { - let output: bool = ::glam::Affine2::is_nan(&_self).into(); - output + let output: bool = ::glam::Affine2::is_nan( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -53185,11 +51237,10 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Val<::glam::Affine2>, rhs: Ref<::glam::Affine2>| { let output: Val<::glam::Affine2> = { { - let output: Val<::glam::Affine2> = <::glam::Affine2 as ::core::ops::Mul< + let output: ::glam::Affine2 = <::glam::Affine2 as ::core::ops::Mul< &::glam::Affine2, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -53202,11 +51253,10 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Val<::glam::Affine2>, rhs: Ref<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Affine2 as ::core::ops::Mul< + let output: ::glam::Mat3 = <::glam::Affine2 as ::core::ops::Mul< &::glam::Mat3, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -53219,11 +51269,10 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Val<::glam::Affine2>, rhs: Ref<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Affine2 as ::core::ops::Mul< + let output: ::glam::Mat3A = <::glam::Affine2 as ::core::ops::Mul< &::glam::Mat3A, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -53236,11 +51285,10 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Val<::glam::Affine2>, rhs: Val<::glam::Affine2>| { let output: Val<::glam::Affine2> = { { - let output: Val<::glam::Affine2> = <::glam::Affine2 as ::core::ops::Mul< + let output: ::glam::Affine2 = <::glam::Affine2 as ::core::ops::Mul< ::glam::Affine2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -53253,11 +51301,10 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Val<::glam::Affine2>, rhs: Val<::glam::Mat3>| { let output: Val<::glam::Mat3> = { { - let output: Val<::glam::Mat3> = <::glam::Affine2 as ::core::ops::Mul< + let output: ::glam::Mat3 = <::glam::Affine2 as ::core::ops::Mul< ::glam::Mat3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -53270,11 +51317,10 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Val<::glam::Affine2>, rhs: Val<::glam::Mat3A>| { let output: Val<::glam::Mat3A> = { { - let output: Val<::glam::Mat3A> = <::glam::Affine2 as ::core::ops::Mul< + let output: ::glam::Mat3A = <::glam::Affine2 as ::core::ops::Mul< ::glam::Mat3A, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -53287,9 +51333,10 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Ref<::glam::Affine2>| { let output: [f32; 6] = { { - let output: [f32; 6] = ::glam::Affine2::to_cols_array(&_self) - .into(); - output + let output: [f32; 6] = ::glam::Affine2::to_cols_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -53303,10 +51350,9 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { let output: [[f32; 2]; 3] = { { let output: [[f32; 2]; 3] = ::glam::Affine2::to_cols_array_2d( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -53319,12 +51365,11 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Ref<::glam::Affine2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Affine2::transform_point2( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Affine2::transform_point2( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -53337,12 +51382,11 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { |_self: Ref<::glam::Affine2>, rhs: Val<::glam::Vec2>| { let output: Val<::glam::Vec2> = { { - let output: Val<::glam::Vec2> = ::glam::Affine2::transform_vector2( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec2 = ::glam::Affine2::transform_vector2( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -53352,7 +51396,11 @@ pub(crate) fn register_affine_2_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::Affine2, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::Affine2, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_affine_3_a_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -53368,12 +51416,11 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::Affine3A::abs_diff_eq( - &_self, - rhs.into_inner(), - max_abs_diff, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_abs_diff), + ); + safe_transmute(output) } }; output @@ -53386,11 +51433,10 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |_self: Ref<::glam::Affine3A>| { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = ::glam::Affine3A::as_daffine3( - &_self, - ) - .into(); - output + let output: ::glam::DAffine3 = ::glam::Affine3A::as_daffine3( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -53403,11 +51449,10 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |_self: Ref<::glam::Affine3A>| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = <::glam::Affine3A as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::Affine3A = <::glam::Affine3A as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -53422,9 +51467,8 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { { let output: bool = <::glam::Affine3A as ::core::cmp::PartialEq< ::glam::Affine3A, - >>::eq(&_self, &rhs) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -53437,12 +51481,11 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |axis: Val<::glam::Vec3>, angle: f32| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_axis_angle( - axis.into_inner(), - angle, - ) - .into(); - output + let output: ::glam::Affine3A = ::glam::Affine3A::from_axis_angle( + safe_transmute(axis), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -53460,14 +51503,13 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_cols( - x_axis.into_inner(), - y_axis.into_inner(), - z_axis.into_inner(), - w_axis.into_inner(), - ) - .into(); - output + let output: ::glam::Affine3A = ::glam::Affine3A::from_cols( + safe_transmute(x_axis), + safe_transmute(y_axis), + safe_transmute(z_axis), + safe_transmute(w_axis), + ); + safe_transmute(output) } }; output @@ -53480,11 +51522,10 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |mat3: Val<::glam::Mat3>| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_mat3( - mat3.into_inner(), - ) - .into(); - output + let output: ::glam::Affine3A = ::glam::Affine3A::from_mat3( + safe_transmute(mat3), + ); + safe_transmute(output) } }; output @@ -53497,12 +51538,11 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |mat3: Val<::glam::Mat3>, translation: Val<::glam::Vec3>| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_mat3_translation( - mat3.into_inner(), - translation.into_inner(), - ) - .into(); - output + let output: ::glam::Affine3A = ::glam::Affine3A::from_mat3_translation( + safe_transmute(mat3), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -53515,11 +51555,10 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |m: Val<::glam::Mat4>| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_mat4( - m.into_inner(), - ) - .into(); - output + let output: ::glam::Affine3A = ::glam::Affine3A::from_mat4( + safe_transmute(m), + ); + safe_transmute(output) } }; output @@ -53532,11 +51571,10 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |rotation: Val<::glam::Quat>| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_quat( - rotation.into_inner(), - ) - .into(); - output + let output: ::glam::Affine3A = ::glam::Affine3A::from_quat( + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -53549,12 +51587,11 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |rotation: Val<::glam::Quat>, translation: Val<::glam::Vec3>| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_rotation_translation( - rotation.into_inner(), - translation.into_inner(), - ) - .into(); - output + let output: ::glam::Affine3A = ::glam::Affine3A::from_rotation_translation( + safe_transmute(rotation), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -53567,11 +51604,10 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |angle: f32| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_rotation_x( - angle, - ) - .into(); - output + let output: ::glam::Affine3A = ::glam::Affine3A::from_rotation_x( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -53584,11 +51620,10 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |angle: f32| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_rotation_y( - angle, - ) - .into(); - output + let output: ::glam::Affine3A = ::glam::Affine3A::from_rotation_y( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -53601,11 +51636,10 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |angle: f32| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_rotation_z( - angle, - ) - .into(); - output + let output: ::glam::Affine3A = ::glam::Affine3A::from_rotation_z( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -53618,11 +51652,10 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |scale: Val<::glam::Vec3>| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_scale( - scale.into_inner(), - ) - .into(); - output + let output: ::glam::Affine3A = ::glam::Affine3A::from_scale( + safe_transmute(scale), + ); + safe_transmute(output) } }; output @@ -53639,13 +51672,12 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_scale_rotation_translation( - scale.into_inner(), - rotation.into_inner(), - translation.into_inner(), - ) - .into(); - output + let output: ::glam::Affine3A = ::glam::Affine3A::from_scale_rotation_translation( + safe_transmute(scale), + safe_transmute(rotation), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -53658,11 +51690,10 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |translation: Val<::glam::Vec3>| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_translation( - translation.into_inner(), - ) - .into(); - output + let output: ::glam::Affine3A = ::glam::Affine3A::from_translation( + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -53675,11 +51706,10 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |_self: Ref<::glam::Affine3A>| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = ::glam::Affine3A::inverse( - &_self, - ) - .into(); - output + let output: ::glam::Affine3A = ::glam::Affine3A::inverse( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -53692,8 +51722,10 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |_self: Ref<::glam::Affine3A>| { let output: bool = { { - let output: bool = ::glam::Affine3A::is_finite(&_self).into(); - output + let output: bool = ::glam::Affine3A::is_finite( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -53706,8 +51738,10 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |_self: Ref<::glam::Affine3A>| { let output: bool = { { - let output: bool = ::glam::Affine3A::is_nan(&_self).into(); - output + let output: bool = ::glam::Affine3A::is_nan( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -53720,13 +51754,12 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |eye: Val<::glam::Vec3>, center: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = ::glam::Affine3A::look_at_lh( - eye.into_inner(), - center.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::Affine3A = ::glam::Affine3A::look_at_lh( + safe_transmute(eye), + safe_transmute(center), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -53739,13 +51772,12 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |eye: Val<::glam::Vec3>, center: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = ::glam::Affine3A::look_at_rh( - eye.into_inner(), - center.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::Affine3A = ::glam::Affine3A::look_at_rh( + safe_transmute(eye), + safe_transmute(center), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -53758,13 +51790,12 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |eye: Val<::glam::Vec3>, dir: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = ::glam::Affine3A::look_to_lh( - eye.into_inner(), - dir.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::Affine3A = ::glam::Affine3A::look_to_lh( + safe_transmute(eye), + safe_transmute(dir), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -53777,13 +51808,12 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |eye: Val<::glam::Vec3>, dir: Val<::glam::Vec3>, up: Val<::glam::Vec3>| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = ::glam::Affine3A::look_to_rh( - eye.into_inner(), - dir.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::Affine3A = ::glam::Affine3A::look_to_rh( + safe_transmute(eye), + safe_transmute(dir), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -53796,11 +51826,10 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |_self: Val<::glam::Affine3A>, rhs: Ref<::glam::Affine3A>| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = <::glam::Affine3A as ::core::ops::Mul< + let output: ::glam::Affine3A = <::glam::Affine3A as ::core::ops::Mul< &::glam::Affine3A, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -53813,11 +51842,10 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |_self: Val<::glam::Affine3A>, rhs: Ref<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Affine3A as ::core::ops::Mul< + let output: ::glam::Mat4 = <::glam::Affine3A as ::core::ops::Mul< &::glam::Mat4, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -53830,11 +51858,10 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |_self: Val<::glam::Affine3A>, rhs: Val<::glam::Affine3A>| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = <::glam::Affine3A as ::core::ops::Mul< + let output: ::glam::Affine3A = <::glam::Affine3A as ::core::ops::Mul< ::glam::Affine3A, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -53847,11 +51874,10 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |_self: Val<::glam::Affine3A>, rhs: Val<::glam::Mat4>| { let output: Val<::glam::Mat4> = { { - let output: Val<::glam::Mat4> = <::glam::Affine3A as ::core::ops::Mul< + let output: ::glam::Mat4 = <::glam::Affine3A as ::core::ops::Mul< ::glam::Mat4, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -53864,9 +51890,10 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |_self: Ref<::glam::Affine3A>| { let output: [f32; 12] = { { - let output: [f32; 12] = ::glam::Affine3A::to_cols_array(&_self) - .into(); - output + let output: [f32; 12] = ::glam::Affine3A::to_cols_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -53880,10 +51907,9 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { let output: [[f32; 3]; 4] = { { let output: [[f32; 3]; 4] = ::glam::Affine3A::to_cols_array_2d( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -53896,12 +51922,11 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |_self: Ref<::glam::Affine3A>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Affine3A::transform_point3( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Affine3A::transform_point3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -53914,12 +51939,11 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |_self: Ref<::glam::Affine3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Affine3A::transform_point3a( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Affine3A::transform_point3a( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -53932,12 +51956,11 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |_self: Ref<::glam::Affine3A>, rhs: Val<::glam::Vec3>| { let output: Val<::glam::Vec3> = { { - let output: Val<::glam::Vec3> = ::glam::Affine3A::transform_vector3( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3 = ::glam::Affine3A::transform_vector3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -53950,12 +51973,11 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { |_self: Ref<::glam::Affine3A>, rhs: Val<::glam::Vec3A>| { let output: Val<::glam::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::glam::Affine3A::transform_vector3a( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::Vec3A = ::glam::Affine3A::transform_vector3a( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -53965,7 +51987,11 @@ pub(crate) fn register_affine_3_a_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::Affine3A, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::Affine3A, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_d_affine_2_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -53981,12 +52007,11 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::DAffine2::abs_diff_eq( - &_self, - rhs.into_inner(), - max_abs_diff, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_abs_diff), + ); + safe_transmute(output) } }; output @@ -53999,11 +52024,10 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |_self: Ref<::glam::DAffine2>| { let output: Val<::glam::Affine2> = { { - let output: Val<::glam::Affine2> = ::glam::DAffine2::as_affine2( - &_self, - ) - .into(); - output + let output: ::glam::Affine2 = ::glam::DAffine2::as_affine2( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -54016,11 +52040,10 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |_self: Ref<::glam::DAffine2>| { let output: Val<::glam::DAffine2> = { { - let output: Val<::glam::DAffine2> = <::glam::DAffine2 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::DAffine2 = <::glam::DAffine2 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -54035,9 +52058,8 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { { let output: bool = <::glam::DAffine2 as ::core::cmp::PartialEq< ::glam::DAffine2, - >>::eq(&_self, &rhs) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -54050,11 +52072,10 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |angle: f64| { let output: Val<::glam::DAffine2> = { { - let output: Val<::glam::DAffine2> = ::glam::DAffine2::from_angle( - angle, - ) - .into(); - output + let output: ::glam::DAffine2 = ::glam::DAffine2::from_angle( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -54067,12 +52088,11 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |angle: f64, translation: Val<::glam::DVec2>| { let output: Val<::glam::DAffine2> = { { - let output: Val<::glam::DAffine2> = ::glam::DAffine2::from_angle_translation( - angle, - translation.into_inner(), - ) - .into(); - output + let output: ::glam::DAffine2 = ::glam::DAffine2::from_angle_translation( + safe_transmute(angle), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -54089,13 +52109,12 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { { let output: Val<::glam::DAffine2> = { { - let output: Val<::glam::DAffine2> = ::glam::DAffine2::from_cols( - x_axis.into_inner(), - y_axis.into_inner(), - z_axis.into_inner(), - ) - .into(); - output + let output: ::glam::DAffine2 = ::glam::DAffine2::from_cols( + safe_transmute(x_axis), + safe_transmute(y_axis), + safe_transmute(z_axis), + ); + safe_transmute(output) } }; output @@ -54108,11 +52127,10 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |matrix2: Val<::glam::DMat2>| { let output: Val<::glam::DAffine2> = { { - let output: Val<::glam::DAffine2> = ::glam::DAffine2::from_mat2( - matrix2.into_inner(), - ) - .into(); - output + let output: ::glam::DAffine2 = ::glam::DAffine2::from_mat2( + safe_transmute(matrix2), + ); + safe_transmute(output) } }; output @@ -54125,12 +52143,11 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |matrix2: Val<::glam::DMat2>, translation: Val<::glam::DVec2>| { let output: Val<::glam::DAffine2> = { { - let output: Val<::glam::DAffine2> = ::glam::DAffine2::from_mat2_translation( - matrix2.into_inner(), - translation.into_inner(), - ) - .into(); - output + let output: ::glam::DAffine2 = ::glam::DAffine2::from_mat2_translation( + safe_transmute(matrix2), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -54143,11 +52160,10 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |m: Val<::glam::DMat3>| { let output: Val<::glam::DAffine2> = { { - let output: Val<::glam::DAffine2> = ::glam::DAffine2::from_mat3( - m.into_inner(), - ) - .into(); - output + let output: ::glam::DAffine2 = ::glam::DAffine2::from_mat3( + safe_transmute(m), + ); + safe_transmute(output) } }; output @@ -54160,11 +52176,10 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |scale: Val<::glam::DVec2>| { let output: Val<::glam::DAffine2> = { { - let output: Val<::glam::DAffine2> = ::glam::DAffine2::from_scale( - scale.into_inner(), - ) - .into(); - output + let output: ::glam::DAffine2 = ::glam::DAffine2::from_scale( + safe_transmute(scale), + ); + safe_transmute(output) } }; output @@ -54177,13 +52192,12 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |scale: Val<::glam::DVec2>, angle: f64, translation: Val<::glam::DVec2>| { let output: Val<::glam::DAffine2> = { { - let output: Val<::glam::DAffine2> = ::glam::DAffine2::from_scale_angle_translation( - scale.into_inner(), - angle, - translation.into_inner(), - ) - .into(); - output + let output: ::glam::DAffine2 = ::glam::DAffine2::from_scale_angle_translation( + safe_transmute(scale), + safe_transmute(angle), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -54196,11 +52210,10 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |translation: Val<::glam::DVec2>| { let output: Val<::glam::DAffine2> = { { - let output: Val<::glam::DAffine2> = ::glam::DAffine2::from_translation( - translation.into_inner(), - ) - .into(); - output + let output: ::glam::DAffine2 = ::glam::DAffine2::from_translation( + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -54213,11 +52226,10 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |_self: Ref<::glam::DAffine2>| { let output: Val<::glam::DAffine2> = { { - let output: Val<::glam::DAffine2> = ::glam::DAffine2::inverse( - &_self, - ) - .into(); - output + let output: ::glam::DAffine2 = ::glam::DAffine2::inverse( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -54230,8 +52242,10 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |_self: Ref<::glam::DAffine2>| { let output: bool = { { - let output: bool = ::glam::DAffine2::is_finite(&_self).into(); - output + let output: bool = ::glam::DAffine2::is_finite( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -54244,8 +52258,10 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |_self: Ref<::glam::DAffine2>| { let output: bool = { { - let output: bool = ::glam::DAffine2::is_nan(&_self).into(); - output + let output: bool = ::glam::DAffine2::is_nan( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -54258,11 +52274,10 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |_self: Val<::glam::DAffine2>, rhs: Ref<::glam::DAffine2>| { let output: Val<::glam::DAffine2> = { { - let output: Val<::glam::DAffine2> = <::glam::DAffine2 as ::core::ops::Mul< + let output: ::glam::DAffine2 = <::glam::DAffine2 as ::core::ops::Mul< &::glam::DAffine2, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -54275,11 +52290,10 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |_self: Val<::glam::DAffine2>, rhs: Ref<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DAffine2 as ::core::ops::Mul< + let output: ::glam::DMat3 = <::glam::DAffine2 as ::core::ops::Mul< &::glam::DMat3, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -54292,11 +52306,10 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |_self: Val<::glam::DAffine2>, rhs: Val<::glam::DAffine2>| { let output: Val<::glam::DAffine2> = { { - let output: Val<::glam::DAffine2> = <::glam::DAffine2 as ::core::ops::Mul< + let output: ::glam::DAffine2 = <::glam::DAffine2 as ::core::ops::Mul< ::glam::DAffine2, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -54309,11 +52322,10 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |_self: Val<::glam::DAffine2>, rhs: Val<::glam::DMat3>| { let output: Val<::glam::DMat3> = { { - let output: Val<::glam::DMat3> = <::glam::DAffine2 as ::core::ops::Mul< + let output: ::glam::DMat3 = <::glam::DAffine2 as ::core::ops::Mul< ::glam::DMat3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -54326,9 +52338,10 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |_self: Ref<::glam::DAffine2>| { let output: [f64; 6] = { { - let output: [f64; 6] = ::glam::DAffine2::to_cols_array(&_self) - .into(); - output + let output: [f64; 6] = ::glam::DAffine2::to_cols_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -54342,10 +52355,9 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { let output: [[f64; 2]; 3] = { { let output: [[f64; 2]; 3] = ::glam::DAffine2::to_cols_array_2d( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -54358,12 +52370,11 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |_self: Ref<::glam::DAffine2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DAffine2::transform_point2( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DAffine2::transform_point2( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -54376,12 +52387,11 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { |_self: Ref<::glam::DAffine2>, rhs: Val<::glam::DVec2>| { let output: Val<::glam::DVec2> = { { - let output: Val<::glam::DVec2> = ::glam::DAffine2::transform_vector2( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec2 = ::glam::DAffine2::transform_vector2( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -54391,7 +52401,11 @@ pub(crate) fn register_d_affine_2_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::DAffine2, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::DAffine2, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_d_affine_3_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -54407,12 +52421,11 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::DAffine3::abs_diff_eq( - &_self, - rhs.into_inner(), - max_abs_diff, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_abs_diff), + ); + safe_transmute(output) } }; output @@ -54425,11 +52438,10 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |_self: Ref<::glam::DAffine3>| { let output: Val<::glam::Affine3A> = { { - let output: Val<::glam::Affine3A> = ::glam::DAffine3::as_affine3a( - &_self, - ) - .into(); - output + let output: ::glam::Affine3A = ::glam::DAffine3::as_affine3a( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -54442,11 +52454,10 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |_self: Ref<::glam::DAffine3>| { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = <::glam::DAffine3 as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::DAffine3 = <::glam::DAffine3 as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -54461,9 +52472,8 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { { let output: bool = <::glam::DAffine3 as ::core::cmp::PartialEq< ::glam::DAffine3, - >>::eq(&_self, &rhs) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -54476,12 +52486,11 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |axis: Val<::glam::DVec3>, angle: f64| { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_axis_angle( - axis.into_inner(), - angle, - ) - .into(); - output + let output: ::glam::DAffine3 = ::glam::DAffine3::from_axis_angle( + safe_transmute(axis), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -54499,14 +52508,13 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_cols( - x_axis.into_inner(), - y_axis.into_inner(), - z_axis.into_inner(), - w_axis.into_inner(), - ) - .into(); - output + let output: ::glam::DAffine3 = ::glam::DAffine3::from_cols( + safe_transmute(x_axis), + safe_transmute(y_axis), + safe_transmute(z_axis), + safe_transmute(w_axis), + ); + safe_transmute(output) } }; output @@ -54519,11 +52527,10 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |mat3: Val<::glam::DMat3>| { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_mat3( - mat3.into_inner(), - ) - .into(); - output + let output: ::glam::DAffine3 = ::glam::DAffine3::from_mat3( + safe_transmute(mat3), + ); + safe_transmute(output) } }; output @@ -54536,12 +52543,11 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |mat3: Val<::glam::DMat3>, translation: Val<::glam::DVec3>| { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_mat3_translation( - mat3.into_inner(), - translation.into_inner(), - ) - .into(); - output + let output: ::glam::DAffine3 = ::glam::DAffine3::from_mat3_translation( + safe_transmute(mat3), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -54554,11 +52560,10 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |m: Val<::glam::DMat4>| { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_mat4( - m.into_inner(), - ) - .into(); - output + let output: ::glam::DAffine3 = ::glam::DAffine3::from_mat4( + safe_transmute(m), + ); + safe_transmute(output) } }; output @@ -54571,11 +52576,10 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |rotation: Val<::glam::DQuat>| { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_quat( - rotation.into_inner(), - ) - .into(); - output + let output: ::glam::DAffine3 = ::glam::DAffine3::from_quat( + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -54588,12 +52592,11 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |rotation: Val<::glam::DQuat>, translation: Val<::glam::DVec3>| { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_rotation_translation( - rotation.into_inner(), - translation.into_inner(), - ) - .into(); - output + let output: ::glam::DAffine3 = ::glam::DAffine3::from_rotation_translation( + safe_transmute(rotation), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -54606,11 +52609,10 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |angle: f64| { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_rotation_x( - angle, - ) - .into(); - output + let output: ::glam::DAffine3 = ::glam::DAffine3::from_rotation_x( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -54623,11 +52625,10 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |angle: f64| { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_rotation_y( - angle, - ) - .into(); - output + let output: ::glam::DAffine3 = ::glam::DAffine3::from_rotation_y( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -54640,11 +52641,10 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |angle: f64| { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_rotation_z( - angle, - ) - .into(); - output + let output: ::glam::DAffine3 = ::glam::DAffine3::from_rotation_z( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -54657,11 +52657,10 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |scale: Val<::glam::DVec3>| { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_scale( - scale.into_inner(), - ) - .into(); - output + let output: ::glam::DAffine3 = ::glam::DAffine3::from_scale( + safe_transmute(scale), + ); + safe_transmute(output) } }; output @@ -54678,13 +52677,12 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_scale_rotation_translation( - scale.into_inner(), - rotation.into_inner(), - translation.into_inner(), - ) - .into(); - output + let output: ::glam::DAffine3 = ::glam::DAffine3::from_scale_rotation_translation( + safe_transmute(scale), + safe_transmute(rotation), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -54697,11 +52695,10 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |translation: Val<::glam::DVec3>| { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_translation( - translation.into_inner(), - ) - .into(); - output + let output: ::glam::DAffine3 = ::glam::DAffine3::from_translation( + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -54714,11 +52711,10 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |_self: Ref<::glam::DAffine3>| { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = ::glam::DAffine3::inverse( - &_self, - ) - .into(); - output + let output: ::glam::DAffine3 = ::glam::DAffine3::inverse( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -54731,8 +52727,10 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |_self: Ref<::glam::DAffine3>| { let output: bool = { { - let output: bool = ::glam::DAffine3::is_finite(&_self).into(); - output + let output: bool = ::glam::DAffine3::is_finite( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -54745,8 +52743,10 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |_self: Ref<::glam::DAffine3>| { let output: bool = { { - let output: bool = ::glam::DAffine3::is_nan(&_self).into(); - output + let output: bool = ::glam::DAffine3::is_nan( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -54763,13 +52763,12 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = ::glam::DAffine3::look_at_lh( - eye.into_inner(), - center.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::DAffine3 = ::glam::DAffine3::look_at_lh( + safe_transmute(eye), + safe_transmute(center), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -54786,13 +52785,12 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = ::glam::DAffine3::look_at_rh( - eye.into_inner(), - center.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::DAffine3 = ::glam::DAffine3::look_at_rh( + safe_transmute(eye), + safe_transmute(center), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -54805,13 +52803,12 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |eye: Val<::glam::DVec3>, dir: Val<::glam::DVec3>, up: Val<::glam::DVec3>| { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = ::glam::DAffine3::look_to_lh( - eye.into_inner(), - dir.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::DAffine3 = ::glam::DAffine3::look_to_lh( + safe_transmute(eye), + safe_transmute(dir), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -54824,13 +52821,12 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |eye: Val<::glam::DVec3>, dir: Val<::glam::DVec3>, up: Val<::glam::DVec3>| { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = ::glam::DAffine3::look_to_rh( - eye.into_inner(), - dir.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::DAffine3 = ::glam::DAffine3::look_to_rh( + safe_transmute(eye), + safe_transmute(dir), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -54843,11 +52839,10 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |_self: Val<::glam::DAffine3>, rhs: Ref<::glam::DAffine3>| { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = <::glam::DAffine3 as ::core::ops::Mul< + let output: ::glam::DAffine3 = <::glam::DAffine3 as ::core::ops::Mul< &::glam::DAffine3, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -54860,11 +52855,10 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |_self: Val<::glam::DAffine3>, rhs: Ref<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DAffine3 as ::core::ops::Mul< + let output: ::glam::DMat4 = <::glam::DAffine3 as ::core::ops::Mul< &::glam::DMat4, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -54877,11 +52871,10 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |_self: Val<::glam::DAffine3>, rhs: Val<::glam::DAffine3>| { let output: Val<::glam::DAffine3> = { { - let output: Val<::glam::DAffine3> = <::glam::DAffine3 as ::core::ops::Mul< + let output: ::glam::DAffine3 = <::glam::DAffine3 as ::core::ops::Mul< ::glam::DAffine3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -54894,11 +52887,10 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |_self: Val<::glam::DAffine3>, rhs: Val<::glam::DMat4>| { let output: Val<::glam::DMat4> = { { - let output: Val<::glam::DMat4> = <::glam::DAffine3 as ::core::ops::Mul< + let output: ::glam::DMat4 = <::glam::DAffine3 as ::core::ops::Mul< ::glam::DMat4, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -54911,9 +52903,10 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |_self: Ref<::glam::DAffine3>| { let output: [f64; 12] = { { - let output: [f64; 12] = ::glam::DAffine3::to_cols_array(&_self) - .into(); - output + let output: [f64; 12] = ::glam::DAffine3::to_cols_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -54927,10 +52920,9 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { let output: [[f64; 3]; 4] = { { let output: [[f64; 3]; 4] = ::glam::DAffine3::to_cols_array_2d( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -54943,12 +52935,11 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |_self: Ref<::glam::DAffine3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DAffine3::transform_point3( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DAffine3::transform_point3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -54961,12 +52952,11 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { |_self: Ref<::glam::DAffine3>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DAffine3::transform_vector3( - &_self, - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DAffine3::transform_vector3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -54976,7 +52966,11 @@ pub(crate) fn register_d_affine_3_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::DAffine3, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::DAffine3, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_d_quat_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -54988,12 +52982,11 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::DQuat::abs_diff_eq( - _self.into_inner(), - rhs.into_inner(), - max_abs_diff, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_abs_diff), + ); + safe_transmute(output) } }; output @@ -55006,11 +52999,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: Ref<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Add< + let output: ::glam::DQuat = <::glam::DQuat as ::core::ops::Add< &::glam::DQuat, - >>::add(_self.into_inner(), &rhs) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -55023,11 +53015,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: Val<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Add< + let output: ::glam::DQuat = <::glam::DQuat as ::core::ops::Add< ::glam::DQuat, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -55041,11 +53032,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::glam::DQuat::angle_between( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -55058,11 +53048,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>| { let output: Val<::glam::Quat> = { { - let output: Val<::glam::Quat> = ::glam::DQuat::as_quat( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::Quat = ::glam::DQuat::as_quat( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -55075,11 +53064,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Ref<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::DQuat = <::glam::DQuat as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -55092,11 +53080,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::conjugate( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::conjugate( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -55109,11 +53096,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: f64| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Div< + let output: ::glam::DQuat = <::glam::DQuat as ::core::ops::Div< f64, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -55127,11 +53113,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::glam::DQuat::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -55146,9 +53131,8 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { { let output: bool = <::glam::DQuat as ::core::cmp::PartialEq< ::glam::DQuat, - >>::eq(&_self, &rhs) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -55161,9 +53145,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |a: Ref<::glam::DAffine3>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::from_affine3(&a) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::from_affine3( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -55176,9 +53161,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |a: [f64; 4]| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::from_array(a) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -55191,12 +53177,11 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |axis: Val<::glam::DVec3>, angle: f64| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::from_axis_angle( - axis.into_inner(), - angle, - ) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::from_axis_angle( + safe_transmute(axis), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -55209,14 +53194,13 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |euler: Val<::glam::EulerRot>, a: f64, b: f64, c: f64| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::from_euler( - euler.into_inner(), - a, - b, - c, - ) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::from_euler( + safe_transmute(euler), + safe_transmute(a), + safe_transmute(b), + safe_transmute(c), + ); + safe_transmute(output) } }; output @@ -55229,9 +53213,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |mat: Ref<::glam::DMat3>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::from_mat3(&mat) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::from_mat3( + safe_transmute(mat), + ); + safe_transmute(output) } }; output @@ -55244,9 +53229,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |mat: Ref<::glam::DMat4>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::from_mat4(&mat) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::from_mat4( + safe_transmute(mat), + ); + safe_transmute(output) } }; output @@ -55259,12 +53245,11 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |from: Val<::glam::DVec3>, to: Val<::glam::DVec3>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::from_rotation_arc( - from.into_inner(), - to.into_inner(), - ) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::from_rotation_arc( + safe_transmute(from), + safe_transmute(to), + ); + safe_transmute(output) } }; output @@ -55277,12 +53262,11 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |from: Val<::glam::DVec2>, to: Val<::glam::DVec2>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::from_rotation_arc_2d( - from.into_inner(), - to.into_inner(), - ) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::from_rotation_arc_2d( + safe_transmute(from), + safe_transmute(to), + ); + safe_transmute(output) } }; output @@ -55295,12 +53279,11 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |from: Val<::glam::DVec3>, to: Val<::glam::DVec3>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::from_rotation_arc_colinear( - from.into_inner(), - to.into_inner(), - ) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::from_rotation_arc_colinear( + safe_transmute(from), + safe_transmute(to), + ); + safe_transmute(output) } }; output @@ -55313,11 +53296,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |angle: f64| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::from_rotation_x( - angle, - ) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::from_rotation_x( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -55330,11 +53312,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |angle: f64| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::from_rotation_y( - angle, - ) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::from_rotation_y( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -55347,11 +53328,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |angle: f64| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::from_rotation_z( - angle, - ) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::from_rotation_z( + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -55364,11 +53344,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |v: Val<::glam::DVec3>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::from_scaled_axis( - v.into_inner(), - ) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::from_scaled_axis( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -55381,11 +53360,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |v: Val<::glam::DVec4>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::from_vec4( - v.into_inner(), - ) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::from_vec4( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -55398,14 +53376,13 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |x: f64, y: f64, z: f64, w: f64| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::from_xyzw( - x, - y, - z, - w, - ) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::from_xyzw( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -55418,11 +53395,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::inverse( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::inverse( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -55435,9 +53411,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>| { let output: bool = { { - let output: bool = ::glam::DQuat::is_finite(_self.into_inner()) - .into(); - output + let output: bool = ::glam::DQuat::is_finite( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -55450,9 +53427,8 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>| { let output: bool = { { - let output: bool = ::glam::DQuat::is_nan(_self.into_inner()) - .into(); - output + let output: bool = ::glam::DQuat::is_nan(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -55466,10 +53442,9 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::DQuat::is_near_identity( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -55483,10 +53458,9 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { let output: bool = { { let output: bool = ::glam::DQuat::is_normalized( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -55499,9 +53473,8 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>| { let output: f64 = { { - let output: f64 = ::glam::DQuat::length(_self.into_inner()) - .into(); - output + let output: f64 = ::glam::DQuat::length(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -55514,9 +53487,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>| { let output: f64 = { { - let output: f64 = ::glam::DQuat::length_recip(_self.into_inner()) - .into(); - output + let output: f64 = ::glam::DQuat::length_recip( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -55530,10 +53504,9 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::glam::DQuat::length_squared( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -55546,13 +53519,12 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, end: Val<::glam::DQuat>, s: f64| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::lerp( - _self.into_inner(), - end.into_inner(), - s, - ) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::lerp( + safe_transmute(_self), + safe_transmute(end), + safe_transmute(s), + ); + safe_transmute(output) } }; output @@ -55569,13 +53541,12 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::look_at_lh( - eye.into_inner(), - center.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::look_at_lh( + safe_transmute(eye), + safe_transmute(center), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -55592,13 +53563,12 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::look_at_rh( - eye.into_inner(), - center.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::look_at_rh( + safe_transmute(eye), + safe_transmute(center), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -55611,12 +53581,11 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |dir: Val<::glam::DVec3>, up: Val<::glam::DVec3>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::look_to_lh( - dir.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::look_to_lh( + safe_transmute(dir), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -55629,12 +53598,11 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |dir: Val<::glam::DVec3>, up: Val<::glam::DVec3>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::look_to_rh( - dir.into_inner(), - up.into_inner(), - ) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::look_to_rh( + safe_transmute(dir), + safe_transmute(up), + ); + safe_transmute(output) } }; output @@ -55647,11 +53615,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: Ref<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Mul< + let output: ::glam::DQuat = <::glam::DQuat as ::core::ops::Mul< &::glam::DQuat, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -55664,11 +53631,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: Ref<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DQuat as ::core::ops::Mul< + let output: ::glam::DVec3 = <::glam::DQuat as ::core::ops::Mul< &::glam::DVec3, - >>::mul(_self.into_inner(), &rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -55681,11 +53647,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: Val<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Mul< + let output: ::glam::DQuat = <::glam::DQuat as ::core::ops::Mul< ::glam::DQuat, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -55698,11 +53663,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = <::glam::DQuat as ::core::ops::Mul< + let output: ::glam::DVec3 = <::glam::DQuat as ::core::ops::Mul< ::glam::DVec3, - >>::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -55715,11 +53679,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: f64| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Mul< + let output: ::glam::DQuat = <::glam::DQuat as ::core::ops::Mul< f64, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -55732,12 +53695,11 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: Val<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::mul_quat( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::mul_quat( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -55750,12 +53712,11 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: Val<::glam::DVec3>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DQuat::mul_vec3( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DQuat::mul_vec3( + safe_transmute(_self), + safe_transmute(rhs), + ); + safe_transmute(output) } }; output @@ -55768,11 +53729,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DQuat = <::glam::DQuat as ::core::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -55785,11 +53745,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::normalize( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::normalize( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -55802,13 +53761,12 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Ref<::glam::DQuat>, rhs: Val<::glam::DQuat>, max_angle: f64| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::rotate_towards( - &_self, - rhs.into_inner(), - max_angle, - ) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::rotate_towards( + safe_transmute(_self), + safe_transmute(rhs), + safe_transmute(max_angle), + ); + safe_transmute(output) } }; output @@ -55821,13 +53779,12 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, end: Val<::glam::DQuat>, s: f64| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = ::glam::DQuat::slerp( - _self.into_inner(), - end.into_inner(), - s, - ) - .into(); - output + let output: ::glam::DQuat = ::glam::DQuat::slerp( + safe_transmute(_self), + safe_transmute(end), + safe_transmute(s), + ); + safe_transmute(output) } }; output @@ -55840,11 +53797,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: Ref<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Sub< + let output: ::glam::DQuat = <::glam::DQuat as ::core::ops::Sub< &::glam::DQuat, - >>::sub(_self.into_inner(), &rhs) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -55857,11 +53813,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>, rhs: Val<::glam::DQuat>| { let output: Val<::glam::DQuat> = { { - let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Sub< + let output: ::glam::DQuat = <::glam::DQuat as ::core::ops::Sub< ::glam::DQuat, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -55874,8 +53829,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Ref<::glam::DQuat>| { let output: [f64; 4] = { { - let output: [f64; 4] = ::glam::DQuat::to_array(&_self).into(); - output + let output: [f64; 4] = ::glam::DQuat::to_array( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -55889,11 +53846,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { let output: (f64, f64, f64) = { { let output: (f64, f64, f64) = ::glam::DQuat::to_euler( - _self.into_inner(), - order.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(order), + ); + safe_transmute(output) } }; output @@ -55906,11 +53862,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DQuat::to_scaled_axis( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DQuat::to_scaled_axis( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -55923,11 +53878,10 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { |_self: Val<::glam::DQuat>| { let output: Val<::glam::DVec3> = { { - let output: Val<::glam::DVec3> = ::glam::DQuat::xyz( - _self.into_inner(), - ) - .into(); - output + let output: ::glam::DVec3 = ::glam::DQuat::xyz( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -55937,63 +53891,71 @@ pub(crate) fn register_d_quat_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::DQuat, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::DQuat, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_euler_rot_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<::glam::EulerRot>::new( - world, - ) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::glam::EulerRot>| { - let output: () = { - { - let output: () = - <::glam::EulerRot as ::core::cmp::Eq>::assert_receiver_is_total_eq(&_self) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::glam::EulerRot>| { - let output: Val<::glam::EulerRot> = { - { - let output: Val<::glam::EulerRot> = - <::glam::EulerRot as ::core::clone::Clone>::clone(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::glam::EulerRot>, other: Ref<::glam::EulerRot>| { - let output: bool = { - { - let output: bool = <::glam::EulerRot as ::core::cmp::PartialEq< - ::glam::EulerRot, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ); + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::glam::EulerRot, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::glam::EulerRot>| { + let output: () = { + { + let output: () = <::glam::EulerRot as ::core::cmp::Eq>::assert_receiver_is_total_eq( + safe_transmute(_self), + ); + safe_transmute(output) + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::glam::EulerRot>| { + let output: Val<::glam::EulerRot> = { + { + let output: ::glam::EulerRot = <::glam::EulerRot as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::glam::EulerRot>, other: Ref<::glam::EulerRot>| { + let output: bool = { + { + let output: bool = <::glam::EulerRot as ::core::cmp::PartialEq< + ::glam::EulerRot, + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) + } + }; + output + }, + "", + &["_self", "other"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::EulerRot, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::EulerRot, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_b_vec_3_a_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -56004,9 +53966,8 @@ pub(crate) fn register_b_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::BVec3A>| { let output: bool = { { - let output: bool = ::glam::BVec3A::all(_self.into_inner()) - .into(); - output + let output: bool = ::glam::BVec3A::all(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -56019,9 +53980,8 @@ pub(crate) fn register_b_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::BVec3A>| { let output: bool = { { - let output: bool = ::glam::BVec3A::any(_self.into_inner()) - .into(); - output + let output: bool = ::glam::BVec3A::any(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -56034,9 +53994,8 @@ pub(crate) fn register_b_vec_3_a_functions(world: &mut World) { |_self: Val<::glam::BVec3A>| { let output: u32 = { { - let output: u32 = ::glam::BVec3A::bitmask(_self.into_inner()) - .into(); - output + let output: u32 = ::glam::BVec3A::bitmask(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -56049,11 +54008,10 @@ pub(crate) fn register_b_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::BVec3A>| { let output: Val<::glam::BVec3A> = { { - let output: Val<::glam::BVec3A> = <::glam::BVec3A as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::BVec3A = <::glam::BVec3A as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -56068,9 +54026,8 @@ pub(crate) fn register_b_vec_3_a_functions(world: &mut World) { { let output: bool = <::glam::BVec3A as ::core::cmp::PartialEq< ::glam::BVec3A, - >>::eq(&_self, &rhs) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -56083,9 +54040,10 @@ pub(crate) fn register_b_vec_3_a_functions(world: &mut World) { |a: [bool; 3]| { let output: Val<::glam::BVec3A> = { { - let output: Val<::glam::BVec3A> = ::glam::BVec3A::from_array(a) - .into(); - output + let output: ::glam::BVec3A = ::glam::BVec3A::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -56098,9 +54056,12 @@ pub(crate) fn register_b_vec_3_a_functions(world: &mut World) { |x: bool, y: bool, z: bool| { let output: Val<::glam::BVec3A> = { { - let output: Val<::glam::BVec3A> = ::glam::BVec3A::new(x, y, z) - .into(); - output + let output: ::glam::BVec3A = ::glam::BVec3A::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -56113,9 +54074,12 @@ pub(crate) fn register_b_vec_3_a_functions(world: &mut World) { |mut _self: Mut<::glam::BVec3A>, index: usize, value: bool| { let output: () = { { - let output: () = ::glam::BVec3A::set(&mut _self, index, value) - .into(); - output + let output: () = ::glam::BVec3A::set( + safe_transmute(_self), + safe_transmute(index), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -56128,9 +54092,10 @@ pub(crate) fn register_b_vec_3_a_functions(world: &mut World) { |v: bool| { let output: Val<::glam::BVec3A> = { { - let output: Val<::glam::BVec3A> = ::glam::BVec3A::splat(v) - .into(); - output + let output: ::glam::BVec3A = ::glam::BVec3A::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -56143,8 +54108,11 @@ pub(crate) fn register_b_vec_3_a_functions(world: &mut World) { |_self: Ref<::glam::BVec3A>, index: usize| { let output: bool = { { - let output: bool = ::glam::BVec3A::test(&_self, index).into(); - output + let output: bool = ::glam::BVec3A::test( + safe_transmute(_self), + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -56154,7 +54122,11 @@ pub(crate) fn register_b_vec_3_a_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::BVec3A, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::BVec3A, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_b_vec_4_a_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -56165,9 +54137,8 @@ pub(crate) fn register_b_vec_4_a_functions(world: &mut World) { |_self: Val<::glam::BVec4A>| { let output: bool = { { - let output: bool = ::glam::BVec4A::all(_self.into_inner()) - .into(); - output + let output: bool = ::glam::BVec4A::all(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -56180,9 +54151,8 @@ pub(crate) fn register_b_vec_4_a_functions(world: &mut World) { |_self: Val<::glam::BVec4A>| { let output: bool = { { - let output: bool = ::glam::BVec4A::any(_self.into_inner()) - .into(); - output + let output: bool = ::glam::BVec4A::any(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -56195,9 +54165,8 @@ pub(crate) fn register_b_vec_4_a_functions(world: &mut World) { |_self: Val<::glam::BVec4A>| { let output: u32 = { { - let output: u32 = ::glam::BVec4A::bitmask(_self.into_inner()) - .into(); - output + let output: u32 = ::glam::BVec4A::bitmask(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -56210,11 +54179,10 @@ pub(crate) fn register_b_vec_4_a_functions(world: &mut World) { |_self: Ref<::glam::BVec4A>| { let output: Val<::glam::BVec4A> = { { - let output: Val<::glam::BVec4A> = <::glam::BVec4A as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::glam::BVec4A = <::glam::BVec4A as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -56229,9 +54197,8 @@ pub(crate) fn register_b_vec_4_a_functions(world: &mut World) { { let output: bool = <::glam::BVec4A as ::core::cmp::PartialEq< ::glam::BVec4A, - >>::eq(&_self, &rhs) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -56244,9 +54211,10 @@ pub(crate) fn register_b_vec_4_a_functions(world: &mut World) { |a: [bool; 4]| { let output: Val<::glam::BVec4A> = { { - let output: Val<::glam::BVec4A> = ::glam::BVec4A::from_array(a) - .into(); - output + let output: ::glam::BVec4A = ::glam::BVec4A::from_array( + safe_transmute(a), + ); + safe_transmute(output) } }; output @@ -56259,9 +54227,13 @@ pub(crate) fn register_b_vec_4_a_functions(world: &mut World) { |x: bool, y: bool, z: bool, w: bool| { let output: Val<::glam::BVec4A> = { { - let output: Val<::glam::BVec4A> = ::glam::BVec4A::new(x, y, z, w) - .into(); - output + let output: ::glam::BVec4A = ::glam::BVec4A::new( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + safe_transmute(w), + ); + safe_transmute(output) } }; output @@ -56274,9 +54246,12 @@ pub(crate) fn register_b_vec_4_a_functions(world: &mut World) { |mut _self: Mut<::glam::BVec4A>, index: usize, value: bool| { let output: () = { { - let output: () = ::glam::BVec4A::set(&mut _self, index, value) - .into(); - output + let output: () = ::glam::BVec4A::set( + safe_transmute(_self), + safe_transmute(index), + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -56289,9 +54264,10 @@ pub(crate) fn register_b_vec_4_a_functions(world: &mut World) { |v: bool| { let output: Val<::glam::BVec4A> = { { - let output: Val<::glam::BVec4A> = ::glam::BVec4A::splat(v) - .into(); - output + let output: ::glam::BVec4A = ::glam::BVec4A::splat( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -56304,8 +54280,11 @@ pub(crate) fn register_b_vec_4_a_functions(world: &mut World) { |_self: Ref<::glam::BVec4A>, index: usize| { let output: bool = { { - let output: bool = ::glam::BVec4A::test(&_self, index).into(); - output + let output: bool = ::glam::BVec4A::test( + safe_transmute(_self), + safe_transmute(index), + ); + safe_transmute(output) } }; output @@ -56315,105 +54294,119 @@ pub(crate) fn register_b_vec_4_a_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::glam::BVec4A, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::glam::BVec4A, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_smol_str_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<::smol_str::SmolStr>::new( - world, - ) - .register_documented( - "clone", - |_self: Ref<::smol_str::SmolStr>| { - let output: Val<::smol_str::SmolStr> = { - { - let output: Val<::smol_str::SmolStr> = - <::smol_str::SmolStr as ::core::clone::Clone>::clone(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::smol_str::SmolStr>, other: Ref<::smol_str::SmolStr>| { - let output: bool = { - { - let output: bool = <::smol_str::SmolStr as ::core::cmp::PartialEq< - ::smol_str::SmolStr, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "is_empty", - |_self: Ref<::smol_str::SmolStr>| { - let output: bool = { - { - let output: bool = ::smol_str::SmolStr::is_empty(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "is_heap_allocated", - |_self: Ref<::smol_str::SmolStr>| { - let output: bool = { - { - let output: bool = ::smol_str::SmolStr::is_heap_allocated(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "len", - |_self: Ref<::smol_str::SmolStr>| { - let output: usize = { - { - let output: usize = ::smol_str::SmolStr::len(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "to_string", - |_self: Ref<::smol_str::SmolStr>| { - let output: ::std::string::String = { - { - let output: ::std::string::String = - ::smol_str::SmolStr::to_string(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ); + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::smol_str::SmolStr, + >::new(world) + .register_documented( + "clone", + |_self: Ref<::smol_str::SmolStr>| { + let output: Val<::smol_str::SmolStr> = { + { + let output: ::smol_str::SmolStr = <::smol_str::SmolStr as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::smol_str::SmolStr>, other: Ref<::smol_str::SmolStr>| { + let output: bool = { + { + let output: bool = <::smol_str::SmolStr as ::core::cmp::PartialEq< + ::smol_str::SmolStr, + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "is_empty", + |_self: Ref<::smol_str::SmolStr>| { + let output: bool = { + { + let output: bool = ::smol_str::SmolStr::is_empty( + safe_transmute(_self), + ); + safe_transmute(output) + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "is_heap_allocated", + |_self: Ref<::smol_str::SmolStr>| { + let output: bool = { + { + let output: bool = ::smol_str::SmolStr::is_heap_allocated( + safe_transmute(_self), + ); + safe_transmute(output) + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "len", + |_self: Ref<::smol_str::SmolStr>| { + let output: usize = { + { + let output: usize = ::smol_str::SmolStr::len( + safe_transmute(_self), + ); + safe_transmute(output) + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "to_string", + |_self: Ref<::smol_str::SmolStr>| { + let output: ::std::string::String = { + { + let output: ::std::string::String = ::smol_str::SmolStr::to_string( + safe_transmute(_self), + ); + safe_transmute(output) + } + }; + output + }, + "", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::smol_str::SmolStr, bevy_mod_scripting_bindings::MarkAsGenerated>(); + .register_type_data::< + ::smol_str::SmolStr, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_uuid_functions(world: &mut World) { bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< @@ -56424,8 +54417,8 @@ pub(crate) fn register_uuid_functions(world: &mut World) { |_self: Ref<::uuid::Uuid>| { let output: u128 = { { - let output: u128 = ::uuid::Uuid::as_u128(&_self).into(); - output + let output: u128 = ::uuid::Uuid::as_u128(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -56438,9 +54431,10 @@ pub(crate) fn register_uuid_functions(world: &mut World) { |_self: Ref<::uuid::Uuid>| { let output: (u64, u64) = { { - let output: (u64, u64) = ::uuid::Uuid::as_u64_pair(&_self) - .into(); - output + let output: (u64, u64) = ::uuid::Uuid::as_u64_pair( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -56454,10 +54448,9 @@ pub(crate) fn register_uuid_functions(world: &mut World) { let output: () = { { let output: () = <::uuid::Uuid as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -56470,11 +54463,10 @@ pub(crate) fn register_uuid_functions(world: &mut World) { |_self: Ref<::uuid::Uuid>| { let output: Val<::uuid::Uuid> = { { - let output: Val<::uuid::Uuid> = <::uuid::Uuid as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::uuid::Uuid = <::uuid::Uuid as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -56487,8 +54479,8 @@ pub(crate) fn register_uuid_functions(world: &mut World) { || { let output: [u8; 45] = { { - let output: [u8; 45] = ::uuid::Uuid::encode_buffer().into(); - output + let output: [u8; 45] = ::uuid::Uuid::encode_buffer(); + safe_transmute(output) } }; output @@ -56503,9 +54495,8 @@ pub(crate) fn register_uuid_functions(world: &mut World) { { let output: bool = <::uuid::Uuid as ::core::cmp::PartialEq< ::uuid::NonNilUuid, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -56520,9 +54511,8 @@ pub(crate) fn register_uuid_functions(world: &mut World) { { let output: bool = <::uuid::Uuid as ::core::cmp::PartialEq< ::uuid::Uuid, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -56535,9 +54525,10 @@ pub(crate) fn register_uuid_functions(world: &mut World) { |bytes: [u8; 16]| { let output: Val<::uuid::Uuid> = { { - let output: Val<::uuid::Uuid> = ::uuid::Uuid::from_bytes(bytes) - .into(); - output + let output: ::uuid::Uuid = ::uuid::Uuid::from_bytes( + safe_transmute(bytes), + ); + safe_transmute(output) } }; output @@ -56550,9 +54541,10 @@ pub(crate) fn register_uuid_functions(world: &mut World) { |b: [u8; 16]| { let output: Val<::uuid::Uuid> = { { - let output: Val<::uuid::Uuid> = ::uuid::Uuid::from_bytes_le(b) - .into(); - output + let output: ::uuid::Uuid = ::uuid::Uuid::from_bytes_le( + safe_transmute(b), + ); + safe_transmute(output) } }; output @@ -56565,9 +54557,10 @@ pub(crate) fn register_uuid_functions(world: &mut World) { |v: u128| { let output: Val<::uuid::Uuid> = { { - let output: Val<::uuid::Uuid> = ::uuid::Uuid::from_u128(v) - .into(); - output + let output: ::uuid::Uuid = ::uuid::Uuid::from_u128( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -56580,9 +54573,10 @@ pub(crate) fn register_uuid_functions(world: &mut World) { |v: u128| { let output: Val<::uuid::Uuid> = { { - let output: Val<::uuid::Uuid> = ::uuid::Uuid::from_u128_le(v) - .into(); - output + let output: ::uuid::Uuid = ::uuid::Uuid::from_u128_le( + safe_transmute(v), + ); + safe_transmute(output) } }; output @@ -56595,12 +54589,11 @@ pub(crate) fn register_uuid_functions(world: &mut World) { |high_bits: u64, low_bits: u64| { let output: Val<::uuid::Uuid> = { { - let output: Val<::uuid::Uuid> = ::uuid::Uuid::from_u64_pair( - high_bits, - low_bits, - ) - .into(); - output + let output: ::uuid::Uuid = ::uuid::Uuid::from_u64_pair( + safe_transmute(high_bits), + safe_transmute(low_bits), + ); + safe_transmute(output) } }; output @@ -56614,10 +54607,9 @@ pub(crate) fn register_uuid_functions(world: &mut World) { let output: ::core::option::Option<[u8; 6]> = { { let output: ::core::option::Option<[u8; 6]> = ::uuid::Uuid::get_node_id( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -56630,8 +54622,10 @@ pub(crate) fn register_uuid_functions(world: &mut World) { |_self: Ref<::uuid::Uuid>| { let output: usize = { { - let output: usize = ::uuid::Uuid::get_version_num(&_self).into(); - output + let output: usize = ::uuid::Uuid::get_version_num( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -56645,10 +54639,9 @@ pub(crate) fn register_uuid_functions(world: &mut World) { let output: [u8; 16] = { { let output: [u8; 16] = ::uuid::Uuid::into_bytes( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -56661,8 +54654,8 @@ pub(crate) fn register_uuid_functions(world: &mut World) { |_self: Ref<::uuid::Uuid>| { let output: bool = { { - let output: bool = ::uuid::Uuid::is_max(&_self).into(); - output + let output: bool = ::uuid::Uuid::is_max(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -56675,8 +54668,8 @@ pub(crate) fn register_uuid_functions(world: &mut World) { |_self: Ref<::uuid::Uuid>| { let output: bool = { { - let output: bool = ::uuid::Uuid::is_nil(&_self).into(); - output + let output: bool = ::uuid::Uuid::is_nil(safe_transmute(_self)); + safe_transmute(output) } }; output @@ -56689,8 +54682,8 @@ pub(crate) fn register_uuid_functions(world: &mut World) { || { let output: Val<::uuid::Uuid> = { { - let output: Val<::uuid::Uuid> = ::uuid::Uuid::max().into(); - output + let output: ::uuid::Uuid = ::uuid::Uuid::max(); + safe_transmute(output) } }; output @@ -56703,8 +54696,8 @@ pub(crate) fn register_uuid_functions(world: &mut World) { || { let output: Val<::uuid::Uuid> = { { - let output: Val<::uuid::Uuid> = ::uuid::Uuid::new_v4().into(); - output + let output: ::uuid::Uuid = ::uuid::Uuid::new_v4(); + safe_transmute(output) } }; output @@ -56717,8 +54710,8 @@ pub(crate) fn register_uuid_functions(world: &mut World) { || { let output: Val<::uuid::Uuid> = { { - let output: Val<::uuid::Uuid> = ::uuid::Uuid::nil().into(); - output + let output: ::uuid::Uuid = ::uuid::Uuid::nil(); + safe_transmute(output) } }; output @@ -56731,8 +54724,10 @@ pub(crate) fn register_uuid_functions(world: &mut World) { |_self: Ref<::uuid::Uuid>| { let output: [u8; 16] = { { - let output: [u8; 16] = ::uuid::Uuid::to_bytes_le(&_self).into(); - output + let output: [u8; 16] = ::uuid::Uuid::to_bytes_le( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -56745,8 +54740,10 @@ pub(crate) fn register_uuid_functions(world: &mut World) { |_self: Ref<::uuid::Uuid>| { let output: u128 = { { - let output: u128 = ::uuid::Uuid::to_u128_le(&_self).into(); - output + let output: u128 = ::uuid::Uuid::to_u128_le( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -56756,98 +54753,103 @@ pub(crate) fn register_uuid_functions(world: &mut World) { ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); - registry.register_type_data::<::uuid::Uuid, bevy_mod_scripting_bindings::MarkAsGenerated>(); + registry + .register_type_data::< + ::uuid::Uuid, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } pub(crate) fn register_non_nil_uuid_functions(world: &mut World) { - bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<::uuid::NonNilUuid>::new( - world, - ) - .register_documented( - "assert_receiver_is_total_eq", - |_self: Ref<::uuid::NonNilUuid>| { - let output: () = { - { - let output: () = - <::uuid::NonNilUuid as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "clone", - |_self: Ref<::uuid::NonNilUuid>| { - let output: Val<::uuid::NonNilUuid> = { - { - let output: Val<::uuid::NonNilUuid> = - <::uuid::NonNilUuid as ::core::clone::Clone>::clone(&_self).into(); - output - } - }; - output - }, - "", - &["_self"], - ) - .register_documented( - "eq", - |_self: Ref<::uuid::NonNilUuid>, other: Ref<::uuid::NonNilUuid>| { - let output: bool = { - { - let output: bool = <::uuid::NonNilUuid as ::core::cmp::PartialEq< - ::uuid::NonNilUuid, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "eq", - |_self: Ref<::uuid::NonNilUuid>, other: Ref<::uuid::Uuid>| { - let output: bool = { - { - let output: bool = <::uuid::NonNilUuid as ::core::cmp::PartialEq< - ::uuid::Uuid, - >>::eq(&_self, &other) - .into(); - output - } - }; - output - }, - "", - &["_self", "other"], - ) - .register_documented( - "get", - |_self: Val<::uuid::NonNilUuid>| { - let output: Val<::uuid::Uuid> = { - { - let output: Val<::uuid::Uuid> = - ::uuid::NonNilUuid::get(_self.into_inner()).into(); - output - } - }; - output - }, - " Get the underlying [`Uuid`] value.", - &["_self"], - ); + bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::< + ::uuid::NonNilUuid, + >::new(world) + .register_documented( + "assert_receiver_is_total_eq", + |_self: Ref<::uuid::NonNilUuid>| { + let output: () = { + { + let output: () = <::uuid::NonNilUuid as ::core::cmp::Eq>::assert_receiver_is_total_eq( + safe_transmute(_self), + ); + safe_transmute(output) + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "clone", + |_self: Ref<::uuid::NonNilUuid>| { + let output: Val<::uuid::NonNilUuid> = { + { + let output: ::uuid::NonNilUuid = <::uuid::NonNilUuid as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) + } + }; + output + }, + "", + &["_self"], + ) + .register_documented( + "eq", + |_self: Ref<::uuid::NonNilUuid>, other: Ref<::uuid::NonNilUuid>| { + let output: bool = { + { + let output: bool = <::uuid::NonNilUuid as ::core::cmp::PartialEq< + ::uuid::NonNilUuid, + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "eq", + |_self: Ref<::uuid::NonNilUuid>, other: Ref<::uuid::Uuid>| { + let output: bool = { + { + let output: bool = <::uuid::NonNilUuid as ::core::cmp::PartialEq< + ::uuid::Uuid, + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) + } + }; + output + }, + "", + &["_self", "other"], + ) + .register_documented( + "get", + |_self: Val<::uuid::NonNilUuid>| { + let output: Val<::uuid::Uuid> = { + { + let output: ::uuid::Uuid = ::uuid::NonNilUuid::get( + safe_transmute(_self), + ); + safe_transmute(output) + } + }; + output + }, + " Get the underlying [`Uuid`] value.", + &["_self"], + ); let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry - .register_type_data::<::uuid::NonNilUuid, bevy_mod_scripting_bindings::MarkAsGenerated>(); + .register_type_data::< + ::uuid::NonNilUuid, + bevy_mod_scripting_bindings::MarkAsGenerated, + >(); } impl Plugin for BevyReflectScriptingPlugin { fn build(&self, app: &mut App) { diff --git a/crates/bindings/bevy_render_bms_bindings/src/lib.rs b/crates/bindings/bevy_render_bms_bindings/src/lib.rs index 646fc37c29..8285260a43 100644 --- a/crates/bindings/bevy_render_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_render_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -24,11 +24,10 @@ pub(crate) fn register_alpha_mode_functions(world: &mut World) { |_self: Ref<::bevy_render::alpha::AlphaMode>| { let output: Val<::bevy_render::alpha::AlphaMode> = { { - let output: Val<::bevy_render::alpha::AlphaMode> = <::bevy_render::alpha::AlphaMode as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_render::alpha::AlphaMode = <::bevy_render::alpha::AlphaMode as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -46,9 +45,8 @@ pub(crate) fn register_alpha_mode_functions(world: &mut World) { { let output: bool = <::bevy_render::alpha::AlphaMode as ::std::cmp::PartialEq< ::bevy_render::alpha::AlphaMode, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -74,10 +72,9 @@ pub(crate) fn register_msaa_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_render::view::Msaa as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -90,11 +87,10 @@ pub(crate) fn register_msaa_functions(world: &mut World) { |_self: Ref<::bevy_render::view::Msaa>| { let output: Val<::bevy_render::view::Msaa> = { { - let output: Val<::bevy_render::view::Msaa> = <::bevy_render::view::Msaa as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_render::view::Msaa = <::bevy_render::view::Msaa as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -112,9 +108,8 @@ pub(crate) fn register_msaa_functions(world: &mut World) { { let output: bool = <::bevy_render::view::Msaa as ::std::cmp::PartialEq< ::bevy_render::view::Msaa, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -127,11 +122,10 @@ pub(crate) fn register_msaa_functions(world: &mut World) { |samples: u32| { let output: Val<::bevy_render::view::Msaa> = { { - let output: Val<::bevy_render::view::Msaa> = ::bevy_render::view::Msaa::from_samples( - samples, - ) - .into(); - output + let output: ::bevy_render::view::Msaa = ::bevy_render::view::Msaa::from_samples( + safe_transmute(samples), + ); + safe_transmute(output) } }; output @@ -144,9 +138,10 @@ pub(crate) fn register_msaa_functions(world: &mut World) { |_self: Ref<::bevy_render::view::Msaa>| { let output: u32 = { { - let output: u32 = ::bevy_render::view::Msaa::samples(&_self) - .into(); - output + let output: u32 = ::bevy_render::view::Msaa::samples( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -172,10 +167,9 @@ pub(crate) fn register_main_entity_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_render::sync_world::MainEntity as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -188,11 +182,10 @@ pub(crate) fn register_main_entity_functions(world: &mut World) { |_self: Ref<::bevy_render::sync_world::MainEntity>| { let output: Val<::bevy_render::sync_world::MainEntity> = { { - let output: Val<::bevy_render::sync_world::MainEntity> = <::bevy_render::sync_world::MainEntity as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_render::sync_world::MainEntity = <::bevy_render::sync_world::MainEntity as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -210,9 +203,8 @@ pub(crate) fn register_main_entity_functions(world: &mut World) { { let output: bool = <::bevy_render::sync_world::MainEntity as ::std::cmp::PartialEq< ::bevy_render::sync_world::MainEntity, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -225,11 +217,10 @@ pub(crate) fn register_main_entity_functions(world: &mut World) { |_self: Ref<::bevy_render::sync_world::MainEntity>| { let output: Val<::bevy_ecs::entity::Entity> = { { - let output: Val<::bevy_ecs::entity::Entity> = ::bevy_render::sync_world::MainEntity::id( - &_self, - ) - .into(); - output + let output: ::bevy_ecs::entity::Entity = ::bevy_render::sync_world::MainEntity::id( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -260,13 +251,10 @@ pub(crate) fn register_occlusion_culling_functions(world: &mut World) { ::bevy_render::experimental::occlusion_culling::OcclusionCulling, > = { { - let output: Val< - ::bevy_render::experimental::occlusion_culling::OcclusionCulling, - > = <::bevy_render::experimental::occlusion_culling::OcclusionCulling as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_render::experimental::occlusion_culling::OcclusionCulling = <::bevy_render::experimental::occlusion_culling::OcclusionCulling as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -292,10 +280,9 @@ pub(crate) fn register_render_entity_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_render::sync_world::RenderEntity as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -308,11 +295,10 @@ pub(crate) fn register_render_entity_functions(world: &mut World) { |_self: Ref<::bevy_render::sync_world::RenderEntity>| { let output: Val<::bevy_render::sync_world::RenderEntity> = { { - let output: Val<::bevy_render::sync_world::RenderEntity> = <::bevy_render::sync_world::RenderEntity as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_render::sync_world::RenderEntity = <::bevy_render::sync_world::RenderEntity as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -330,9 +316,8 @@ pub(crate) fn register_render_entity_functions(world: &mut World) { { let output: bool = <::bevy_render::sync_world::RenderEntity as ::std::cmp::PartialEq< ::bevy_render::sync_world::RenderEntity, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -345,11 +330,10 @@ pub(crate) fn register_render_entity_functions(world: &mut World) { |_self: Ref<::bevy_render::sync_world::RenderEntity>| { let output: Val<::bevy_ecs::entity::Entity> = { { - let output: Val<::bevy_ecs::entity::Entity> = ::bevy_render::sync_world::RenderEntity::id( - &_self, - ) - .into(); - output + let output: ::bevy_ecs::entity::Entity = ::bevy_render::sync_world::RenderEntity::id( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -374,11 +358,10 @@ pub(crate) fn register_sync_to_render_world_functions(world: &mut World) { |_self: Ref<::bevy_render::sync_world::SyncToRenderWorld>| { let output: Val<::bevy_render::sync_world::SyncToRenderWorld> = { { - let output: Val<::bevy_render::sync_world::SyncToRenderWorld> = <::bevy_render::sync_world::SyncToRenderWorld as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_render::sync_world::SyncToRenderWorld = <::bevy_render::sync_world::SyncToRenderWorld as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -403,11 +386,10 @@ pub(crate) fn register_color_grading_functions(world: &mut World) { |_self: Ref<::bevy_render::view::ColorGrading>| { let output: Val<::bevy_render::view::ColorGrading> = { { - let output: Val<::bevy_render::view::ColorGrading> = <::bevy_render::view::ColorGrading as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_render::view::ColorGrading = <::bevy_render::view::ColorGrading as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -423,12 +405,11 @@ pub(crate) fn register_color_grading_functions(world: &mut World) { { let output: Val<::bevy_render::view::ColorGrading> = { { - let output: Val<::bevy_render::view::ColorGrading> = ::bevy_render::view::ColorGrading::with_identical_sections( - global.into_inner(), - section.into_inner(), - ) - .into(); - output + let output: ::bevy_render::view::ColorGrading = ::bevy_render::view::ColorGrading::with_identical_sections( + safe_transmute(global), + safe_transmute(section), + ); + safe_transmute(output) } }; output @@ -454,10 +435,9 @@ pub(crate) fn register_hdr_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_render::view::Hdr as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -470,11 +450,10 @@ pub(crate) fn register_hdr_functions(world: &mut World) { |_self: Ref<::bevy_render::view::Hdr>| { let output: Val<::bevy_render::view::Hdr> = { { - let output: Val<::bevy_render::view::Hdr> = <::bevy_render::view::Hdr as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_render::view::Hdr = <::bevy_render::view::Hdr as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -489,9 +468,8 @@ pub(crate) fn register_hdr_functions(world: &mut World) { { let output: bool = <::bevy_render::view::Hdr as ::std::cmp::PartialEq< ::bevy_render::view::Hdr, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -516,11 +494,10 @@ pub(crate) fn register_render_visible_entities_functions(world: &mut World) { |_self: Ref<::bevy_render::view::RenderVisibleEntities>| { let output: Val<::bevy_render::view::RenderVisibleEntities> = { { - let output: Val<::bevy_render::view::RenderVisibleEntities> = <::bevy_render::view::RenderVisibleEntities as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_render::view::RenderVisibleEntities = <::bevy_render::view::RenderVisibleEntities as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -545,11 +522,10 @@ pub(crate) fn register_camera_render_graph_functions(world: &mut World) { |_self: Ref<::bevy_render::camera::CameraRenderGraph>| { let output: Val<::bevy_render::camera::CameraRenderGraph> = { { - let output: Val<::bevy_render::camera::CameraRenderGraph> = <::bevy_render::camera::CameraRenderGraph as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_render::camera::CameraRenderGraph = <::bevy_render::camera::CameraRenderGraph as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -574,11 +550,10 @@ pub(crate) fn register_temporal_jitter_functions(world: &mut World) { |_self: Ref<::bevy_render::camera::TemporalJitter>| { let output: Val<::bevy_render::camera::TemporalJitter> = { { - let output: Val<::bevy_render::camera::TemporalJitter> = <::bevy_render::camera::TemporalJitter as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_render::camera::TemporalJitter = <::bevy_render::camera::TemporalJitter as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -590,18 +565,17 @@ pub(crate) fn register_temporal_jitter_functions(world: &mut World) { "jitter_projection", | _self: Ref<::bevy_render::camera::TemporalJitter>, - mut clip_from_view: Mut<::glam::Mat4>, - view_size: Val<::glam::Vec2>| + mut clip_from_view: Mut<::bevy_math::Mat4>, + view_size: Val<::bevy_math::Vec2>| { let output: () = { { let output: () = ::bevy_render::camera::TemporalJitter::jitter_projection( - &_self, - &mut clip_from_view, - view_size.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(clip_from_view), + safe_transmute(view_size), + ); + safe_transmute(output) } }; output @@ -626,11 +600,10 @@ pub(crate) fn register_mip_bias_functions(world: &mut World) { |_self: Ref<::bevy_render::camera::MipBias>| { let output: Val<::bevy_render::camera::MipBias> = { { - let output: Val<::bevy_render::camera::MipBias> = <::bevy_render::camera::MipBias as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_render::camera::MipBias = <::bevy_render::camera::MipBias as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -655,11 +628,10 @@ pub(crate) fn register_globals_uniform_functions(world: &mut World) { |_self: Ref<::bevy_render::globals::GlobalsUniform>| { let output: Val<::bevy_render::globals::GlobalsUniform> = { { - let output: Val<::bevy_render::globals::GlobalsUniform> = <::bevy_render::globals::GlobalsUniform as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_render::globals::GlobalsUniform = <::bevy_render::globals::GlobalsUniform as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -684,11 +656,10 @@ pub(crate) fn register_shader_storage_buffer_functions(world: &mut World) { |_self: Ref<::bevy_render::storage::ShaderStorageBuffer>| { let output: Val<::bevy_render::storage::ShaderStorageBuffer> = { { - let output: Val<::bevy_render::storage::ShaderStorageBuffer> = <::bevy_render::storage::ShaderStorageBuffer as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_render::storage::ShaderStorageBuffer = <::bevy_render::storage::ShaderStorageBuffer as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -701,12 +672,11 @@ pub(crate) fn register_shader_storage_buffer_functions(world: &mut World) { |size: usize, asset_usage: Val<::bevy_asset::RenderAssetUsages>| { let output: Val<::bevy_render::storage::ShaderStorageBuffer> = { { - let output: Val<::bevy_render::storage::ShaderStorageBuffer> = ::bevy_render::storage::ShaderStorageBuffer::with_size( - size, - asset_usage.into_inner(), - ) - .into(); - output + let output: ::bevy_render::storage::ShaderStorageBuffer = ::bevy_render::storage::ShaderStorageBuffer::with_size( + safe_transmute(size), + safe_transmute(asset_usage), + ); + safe_transmute(output) } }; output @@ -743,13 +713,10 @@ pub(crate) fn register_temporary_render_entity_functions(world: &mut World) { |_self: Ref<::bevy_render::sync_world::TemporaryRenderEntity>| { let output: Val<::bevy_render::sync_world::TemporaryRenderEntity> = { { - let output: Val< - ::bevy_render::sync_world::TemporaryRenderEntity, - > = <::bevy_render::sync_world::TemporaryRenderEntity as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_render::sync_world::TemporaryRenderEntity = <::bevy_render::sync_world::TemporaryRenderEntity as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -774,11 +741,10 @@ pub(crate) fn register_color_grading_global_functions(world: &mut World) { |_self: Ref<::bevy_render::view::ColorGradingGlobal>| { let output: Val<::bevy_render::view::ColorGradingGlobal> = { { - let output: Val<::bevy_render::view::ColorGradingGlobal> = <::bevy_render::view::ColorGradingGlobal as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_render::view::ColorGradingGlobal = <::bevy_render::view::ColorGradingGlobal as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -803,11 +769,10 @@ pub(crate) fn register_color_grading_section_functions(world: &mut World) { |_self: Ref<::bevy_render::view::ColorGradingSection>| { let output: Val<::bevy_render::view::ColorGradingSection> = { { - let output: Val<::bevy_render::view::ColorGradingSection> = <::bevy_render::view::ColorGradingSection as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_render::view::ColorGradingSection = <::bevy_render::view::ColorGradingSection as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -825,9 +790,8 @@ pub(crate) fn register_color_grading_section_functions(world: &mut World) { { let output: bool = <::bevy_render::view::ColorGradingSection as ::std::cmp::PartialEq< ::bevy_render::view::ColorGradingSection, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -864,9 +828,8 @@ pub(crate) fn register_screenshot_functions(world: &mut World) { || { let output: Val<::bevy_render::view::screenshot::Screenshot> = { { - let output: Val<::bevy_render::view::screenshot::Screenshot> = ::bevy_render::view::screenshot::Screenshot::primary_window() - .into(); - output + let output: ::bevy_render::view::screenshot::Screenshot = ::bevy_render::view::screenshot::Screenshot::primary_window(); + safe_transmute(output) } }; output @@ -879,11 +842,10 @@ pub(crate) fn register_screenshot_functions(world: &mut World) { |texture_view: Val<::bevy_camera::ManualTextureViewHandle>| { let output: Val<::bevy_render::view::screenshot::Screenshot> = { { - let output: Val<::bevy_render::view::screenshot::Screenshot> = ::bevy_render::view::screenshot::Screenshot::texture_view( - texture_view.into_inner(), - ) - .into(); - output + let output: ::bevy_render::view::screenshot::Screenshot = ::bevy_render::view::screenshot::Screenshot::texture_view( + safe_transmute(texture_view), + ); + safe_transmute(output) } }; output @@ -896,11 +858,10 @@ pub(crate) fn register_screenshot_functions(world: &mut World) { |window: Val<::bevy_ecs::entity::Entity>| { let output: Val<::bevy_render::view::screenshot::Screenshot> = { { - let output: Val<::bevy_render::view::screenshot::Screenshot> = ::bevy_render::view::screenshot::Screenshot::window( - window.into_inner(), - ) - .into(); - output + let output: ::bevy_render::view::screenshot::Screenshot = ::bevy_render::view::screenshot::Screenshot::window( + safe_transmute(window), + ); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_scene_bms_bindings/src/lib.rs b/crates/bindings/bevy_scene_bms_bindings/src/lib.rs index 20fa0b4e58..742af9eb7c 100644 --- a/crates/bindings/bevy_scene_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_scene_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -25,10 +25,9 @@ pub(crate) fn register_dynamic_scene_root_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_scene::DynamicSceneRoot as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41,11 +40,10 @@ pub(crate) fn register_dynamic_scene_root_functions(world: &mut World) { |_self: Ref<::bevy_scene::DynamicSceneRoot>| { let output: Val<::bevy_scene::DynamicSceneRoot> = { { - let output: Val<::bevy_scene::DynamicSceneRoot> = <::bevy_scene::DynamicSceneRoot as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_scene::DynamicSceneRoot = <::bevy_scene::DynamicSceneRoot as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -63,9 +61,8 @@ pub(crate) fn register_dynamic_scene_root_functions(world: &mut World) { { let output: bool = <::bevy_scene::DynamicSceneRoot as ::std::cmp::PartialEq< ::bevy_scene::DynamicSceneRoot, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -91,10 +88,9 @@ pub(crate) fn register_scene_root_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_scene::SceneRoot as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -107,11 +103,10 @@ pub(crate) fn register_scene_root_functions(world: &mut World) { |_self: Ref<::bevy_scene::SceneRoot>| { let output: Val<::bevy_scene::SceneRoot> = { { - let output: Val<::bevy_scene::SceneRoot> = <::bevy_scene::SceneRoot as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_scene::SceneRoot = <::bevy_scene::SceneRoot as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -126,9 +121,8 @@ pub(crate) fn register_scene_root_functions(world: &mut World) { { let output: bool = <::bevy_scene::SceneRoot as ::std::cmp::PartialEq< ::bevy_scene::SceneRoot, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -154,10 +148,9 @@ pub(crate) fn register_scene_instance_ready_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_scene::SceneInstanceReady as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -170,11 +163,10 @@ pub(crate) fn register_scene_instance_ready_functions(world: &mut World) { |_self: Ref<::bevy_scene::SceneInstanceReady>| { let output: Val<::bevy_scene::SceneInstanceReady> = { { - let output: Val<::bevy_scene::SceneInstanceReady> = <::bevy_scene::SceneInstanceReady as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_scene::SceneInstanceReady = <::bevy_scene::SceneInstanceReady as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -192,9 +184,8 @@ pub(crate) fn register_scene_instance_ready_functions(world: &mut World) { { let output: bool = <::bevy_scene::SceneInstanceReady as ::std::cmp::PartialEq< ::bevy_scene::SceneInstanceReady, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -220,10 +211,9 @@ pub(crate) fn register_instance_id_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_scene::InstanceId as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -236,11 +226,10 @@ pub(crate) fn register_instance_id_functions(world: &mut World) { |_self: Ref<::bevy_scene::InstanceId>| { let output: Val<::bevy_scene::InstanceId> = { { - let output: Val<::bevy_scene::InstanceId> = <::bevy_scene::InstanceId as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_scene::InstanceId = <::bevy_scene::InstanceId as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -255,9 +244,8 @@ pub(crate) fn register_instance_id_functions(world: &mut World) { { let output: bool = <::bevy_scene::InstanceId as ::std::cmp::PartialEq< ::bevy_scene::InstanceId, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_sprite_bms_bindings/src/lib.rs b/crates/bindings/bevy_sprite_bms_bindings/src/lib.rs index a6fddab100..310c47bf78 100644 --- a/crates/bindings/bevy_sprite_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_sprite_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -24,11 +24,10 @@ pub(crate) fn register_sprite_picking_camera_functions(world: &mut World) { |_self: Ref<::bevy_sprite::SpritePickingCamera>| { let output: Val<::bevy_sprite::SpritePickingCamera> = { { - let output: Val<::bevy_sprite::SpritePickingCamera> = <::bevy_sprite::SpritePickingCamera as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_sprite::SpritePickingCamera = <::bevy_sprite::SpritePickingCamera as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -53,11 +52,10 @@ pub(crate) fn register_sprite_picking_mode_functions(world: &mut World) { |_self: Ref<::bevy_sprite::SpritePickingMode>| { let output: Val<::bevy_sprite::SpritePickingMode> = { { - let output: Val<::bevy_sprite::SpritePickingMode> = <::bevy_sprite::SpritePickingMode as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_sprite::SpritePickingMode = <::bevy_sprite::SpritePickingMode as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -94,11 +92,10 @@ pub(crate) fn register_text_2_d_functions(world: &mut World) { |_self: Ref<::bevy_sprite::Text2d>| { let output: Val<::bevy_sprite::Text2d> = { { - let output: Val<::bevy_sprite::Text2d> = <::bevy_sprite::Text2d as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_sprite::Text2d = <::bevy_sprite::Text2d as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -123,11 +120,10 @@ pub(crate) fn register_sprite_functions(world: &mut World) { |_self: Ref<::bevy_sprite::Sprite>| { let output: Val<::bevy_sprite::Sprite> = { { - let output: Val<::bevy_sprite::Sprite> = <::bevy_sprite::Sprite as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_sprite::Sprite = <::bevy_sprite::Sprite as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -137,14 +133,13 @@ pub(crate) fn register_sprite_functions(world: &mut World) { ) .register_documented( "sized", - |custom_size: Val<::glam::Vec2>| { + |custom_size: Val<::bevy_math::Vec2>| { let output: Val<::bevy_sprite::Sprite> = { { - let output: Val<::bevy_sprite::Sprite> = ::bevy_sprite::Sprite::sized( - custom_size.into_inner(), - ) - .into(); - output + let output: ::bevy_sprite::Sprite = ::bevy_sprite::Sprite::sized( + safe_transmute(custom_size), + ); + safe_transmute(output) } }; output @@ -169,11 +164,10 @@ pub(crate) fn register_sprite_image_mode_functions(world: &mut World) { |_self: Ref<::bevy_sprite::SpriteImageMode>| { let output: Val<::bevy_sprite::SpriteImageMode> = { { - let output: Val<::bevy_sprite::SpriteImageMode> = <::bevy_sprite::SpriteImageMode as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_sprite::SpriteImageMode = <::bevy_sprite::SpriteImageMode as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -191,9 +185,8 @@ pub(crate) fn register_sprite_image_mode_functions(world: &mut World) { { let output: bool = <::bevy_sprite::SpriteImageMode as ::std::cmp::PartialEq< ::bevy_sprite::SpriteImageMode, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -207,10 +200,9 @@ pub(crate) fn register_sprite_image_mode_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_sprite::SpriteImageMode::uses_slices( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -235,11 +227,10 @@ pub(crate) fn register_border_rect_functions(world: &mut World) { |_self: Val<::bevy_sprite::BorderRect>, rhs: Val<::bevy_sprite::BorderRect>| { let output: Val<::bevy_sprite::BorderRect> = { { - let output: Val<::bevy_sprite::BorderRect> = <::bevy_sprite::BorderRect as ::std::ops::Add< + let output: ::bevy_sprite::BorderRect = <::bevy_sprite::BorderRect as ::std::ops::Add< ::bevy_sprite::BorderRect, - >>::add(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::add(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -252,11 +243,10 @@ pub(crate) fn register_border_rect_functions(world: &mut World) { |extent: f32| { let output: Val<::bevy_sprite::BorderRect> = { { - let output: Val<::bevy_sprite::BorderRect> = ::bevy_sprite::BorderRect::all( - extent, - ) - .into(); - output + let output: ::bevy_sprite::BorderRect = ::bevy_sprite::BorderRect::all( + safe_transmute(extent), + ); + safe_transmute(output) } }; output @@ -269,12 +259,11 @@ pub(crate) fn register_border_rect_functions(world: &mut World) { |horizontal: f32, vertical: f32| { let output: Val<::bevy_sprite::BorderRect> = { { - let output: Val<::bevy_sprite::BorderRect> = ::bevy_sprite::BorderRect::axes( - horizontal, - vertical, - ) - .into(); - output + let output: ::bevy_sprite::BorderRect = ::bevy_sprite::BorderRect::axes( + safe_transmute(horizontal), + safe_transmute(vertical), + ); + safe_transmute(output) } }; output @@ -287,11 +276,10 @@ pub(crate) fn register_border_rect_functions(world: &mut World) { |_self: Ref<::bevy_sprite::BorderRect>| { let output: Val<::bevy_sprite::BorderRect> = { { - let output: Val<::bevy_sprite::BorderRect> = <::bevy_sprite::BorderRect as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_sprite::BorderRect = <::bevy_sprite::BorderRect as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -304,11 +292,10 @@ pub(crate) fn register_border_rect_functions(world: &mut World) { |_self: Val<::bevy_sprite::BorderRect>, rhs: f32| { let output: Val<::bevy_sprite::BorderRect> = { { - let output: Val<::bevy_sprite::BorderRect> = <::bevy_sprite::BorderRect as ::std::ops::Div< + let output: ::bevy_sprite::BorderRect = <::bevy_sprite::BorderRect as ::std::ops::Div< f32, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -326,9 +313,8 @@ pub(crate) fn register_border_rect_functions(world: &mut World) { { let output: bool = <::bevy_sprite::BorderRect as ::std::cmp::PartialEq< ::bevy_sprite::BorderRect, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -341,11 +327,10 @@ pub(crate) fn register_border_rect_functions(world: &mut World) { |_self: Val<::bevy_sprite::BorderRect>, rhs: f32| { let output: Val<::bevy_sprite::BorderRect> = { { - let output: Val<::bevy_sprite::BorderRect> = <::bevy_sprite::BorderRect as ::std::ops::Mul< + let output: ::bevy_sprite::BorderRect = <::bevy_sprite::BorderRect as ::std::ops::Mul< f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -358,11 +343,10 @@ pub(crate) fn register_border_rect_functions(world: &mut World) { |_self: Val<::bevy_sprite::BorderRect>, rhs: Val<::bevy_sprite::BorderRect>| { let output: Val<::bevy_sprite::BorderRect> = { { - let output: Val<::bevy_sprite::BorderRect> = <::bevy_sprite::BorderRect as ::std::ops::Sub< + let output: ::bevy_sprite::BorderRect = <::bevy_sprite::BorderRect as ::std::ops::Sub< ::bevy_sprite::BorderRect, - >>::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output + >>::sub(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -387,11 +371,10 @@ pub(crate) fn register_slice_scale_mode_functions(world: &mut World) { |_self: Ref<::bevy_sprite::SliceScaleMode>| { let output: Val<::bevy_sprite::SliceScaleMode> = { { - let output: Val<::bevy_sprite::SliceScaleMode> = <::bevy_sprite::SliceScaleMode as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_sprite::SliceScaleMode = <::bevy_sprite::SliceScaleMode as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -409,9 +392,8 @@ pub(crate) fn register_slice_scale_mode_functions(world: &mut World) { { let output: bool = <::bevy_sprite::SliceScaleMode as ::std::cmp::PartialEq< ::bevy_sprite::SliceScaleMode, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -436,11 +418,10 @@ pub(crate) fn register_texture_slicer_functions(world: &mut World) { |_self: Ref<::bevy_sprite::TextureSlicer>| { let output: Val<::bevy_sprite::TextureSlicer> = { { - let output: Val<::bevy_sprite::TextureSlicer> = <::bevy_sprite::TextureSlicer as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_sprite::TextureSlicer = <::bevy_sprite::TextureSlicer as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -458,9 +439,8 @@ pub(crate) fn register_texture_slicer_functions(world: &mut World) { { let output: bool = <::bevy_sprite::TextureSlicer as ::std::cmp::PartialEq< ::bevy_sprite::TextureSlicer, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -485,11 +465,10 @@ pub(crate) fn register_scaling_mode_functions(world: &mut World) { |_self: Ref<::bevy_sprite::ScalingMode>| { let output: Val<::bevy_sprite::ScalingMode> = { { - let output: Val<::bevy_sprite::ScalingMode> = <::bevy_sprite::ScalingMode as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_sprite::ScalingMode = <::bevy_sprite::ScalingMode as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -507,9 +486,8 @@ pub(crate) fn register_scaling_mode_functions(world: &mut World) { { let output: bool = <::bevy_sprite::ScalingMode as ::std::cmp::PartialEq< ::bevy_sprite::ScalingMode, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -532,13 +510,12 @@ pub(crate) fn register_anchor_functions(world: &mut World) { .register_documented( "as_vec", |_self: Ref<::bevy_sprite::Anchor>| { - let output: Val<::glam::Vec2> = { + let output: Val<::bevy_math::Vec2> = { { - let output: Val<::glam::Vec2> = ::bevy_sprite::Anchor::as_vec( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_sprite::Anchor::as_vec( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -551,11 +528,10 @@ pub(crate) fn register_anchor_functions(world: &mut World) { |_self: Ref<::bevy_sprite::Anchor>| { let output: Val<::bevy_sprite::Anchor> = { { - let output: Val<::bevy_sprite::Anchor> = <::bevy_sprite::Anchor as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_sprite::Anchor = <::bevy_sprite::Anchor as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -570,9 +546,8 @@ pub(crate) fn register_anchor_functions(world: &mut World) { { let output: bool = <::bevy_sprite::Anchor as ::std::cmp::PartialEq< ::bevy_sprite::Anchor, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -597,11 +572,10 @@ pub(crate) fn register_text_2_d_shadow_functions(world: &mut World) { |_self: Ref<::bevy_sprite::Text2dShadow>| { let output: Val<::bevy_sprite::Text2dShadow> = { { - let output: Val<::bevy_sprite::Text2dShadow> = <::bevy_sprite::Text2dShadow as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_sprite::Text2dShadow = <::bevy_sprite::Text2dShadow as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -619,9 +593,8 @@ pub(crate) fn register_text_2_d_shadow_functions(world: &mut World) { { let output: bool = <::bevy_sprite::Text2dShadow as ::std::cmp::PartialEq< ::bevy_sprite::Text2dShadow, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_sprite_render_bms_bindings/src/lib.rs b/crates/bindings/bevy_sprite_render_bms_bindings/src/lib.rs index fa23fd1250..8fc4a655d3 100644 --- a/crates/bindings/bevy_sprite_render_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_sprite_render_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -24,11 +24,10 @@ pub(crate) fn register_color_material_functions(world: &mut World) { |_self: Ref<::bevy_sprite_render::ColorMaterial>| { let output: Val<::bevy_sprite_render::ColorMaterial> = { { - let output: Val<::bevy_sprite_render::ColorMaterial> = <::bevy_sprite_render::ColorMaterial as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_sprite_render::ColorMaterial = <::bevy_sprite_render::ColorMaterial as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -53,11 +52,10 @@ pub(crate) fn register_alpha_mode_2_d_functions(world: &mut World) { |_self: Ref<::bevy_sprite_render::AlphaMode2d>| { let output: Val<::bevy_sprite_render::AlphaMode2d> = { { - let output: Val<::bevy_sprite_render::AlphaMode2d> = <::bevy_sprite_render::AlphaMode2d as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_sprite_render::AlphaMode2d = <::bevy_sprite_render::AlphaMode2d as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -75,9 +73,8 @@ pub(crate) fn register_alpha_mode_2_d_functions(world: &mut World) { { let output: bool = <::bevy_sprite_render::AlphaMode2d as ::std::cmp::PartialEq< ::bevy_sprite_render::AlphaMode2d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -102,11 +99,10 @@ pub(crate) fn register_wireframe_2_d_material_functions(world: &mut World) { |_self: Ref<::bevy_sprite_render::Wireframe2dMaterial>| { let output: Val<::bevy_sprite_render::Wireframe2dMaterial> = { { - let output: Val<::bevy_sprite_render::Wireframe2dMaterial> = <::bevy_sprite_render::Wireframe2dMaterial as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_sprite_render::Wireframe2dMaterial = <::bevy_sprite_render::Wireframe2dMaterial as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -131,11 +127,10 @@ pub(crate) fn register_wireframe_2_d_config_functions(world: &mut World) { |_self: Ref<::bevy_sprite_render::Wireframe2dConfig>| { let output: Val<::bevy_sprite_render::Wireframe2dConfig> = { { - let output: Val<::bevy_sprite_render::Wireframe2dConfig> = <::bevy_sprite_render::Wireframe2dConfig as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_sprite_render::Wireframe2dConfig = <::bevy_sprite_render::Wireframe2dConfig as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -161,10 +156,9 @@ pub(crate) fn register_wireframe_2_d_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_sprite_render::Wireframe2d as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -177,11 +171,10 @@ pub(crate) fn register_wireframe_2_d_functions(world: &mut World) { |_self: Ref<::bevy_sprite_render::Wireframe2d>| { let output: Val<::bevy_sprite_render::Wireframe2d> = { { - let output: Val<::bevy_sprite_render::Wireframe2d> = <::bevy_sprite_render::Wireframe2d as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_sprite_render::Wireframe2d = <::bevy_sprite_render::Wireframe2d as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -199,9 +192,8 @@ pub(crate) fn register_wireframe_2_d_functions(world: &mut World) { { let output: bool = <::bevy_sprite_render::Wireframe2d as ::std::cmp::PartialEq< ::bevy_sprite_render::Wireframe2d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -226,11 +218,10 @@ pub(crate) fn register_wireframe_2_d_color_functions(world: &mut World) { |_self: Ref<::bevy_sprite_render::Wireframe2dColor>| { let output: Val<::bevy_sprite_render::Wireframe2dColor> = { { - let output: Val<::bevy_sprite_render::Wireframe2dColor> = <::bevy_sprite_render::Wireframe2dColor as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_sprite_render::Wireframe2dColor = <::bevy_sprite_render::Wireframe2dColor as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -256,10 +247,9 @@ pub(crate) fn register_no_wireframe_2_d_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_sprite_render::NoWireframe2d as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -272,11 +262,10 @@ pub(crate) fn register_no_wireframe_2_d_functions(world: &mut World) { |_self: Ref<::bevy_sprite_render::NoWireframe2d>| { let output: Val<::bevy_sprite_render::NoWireframe2d> = { { - let output: Val<::bevy_sprite_render::NoWireframe2d> = <::bevy_sprite_render::NoWireframe2d as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_sprite_render::NoWireframe2d = <::bevy_sprite_render::NoWireframe2d as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -294,9 +283,8 @@ pub(crate) fn register_no_wireframe_2_d_functions(world: &mut World) { { let output: bool = <::bevy_sprite_render::NoWireframe2d as ::std::cmp::PartialEq< ::bevy_sprite_render::NoWireframe2d, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -322,10 +310,9 @@ pub(crate) fn register_mesh_2_d_wireframe_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_sprite_render::Mesh2dWireframe as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -338,11 +325,10 @@ pub(crate) fn register_mesh_2_d_wireframe_functions(world: &mut World) { |_self: Ref<::bevy_sprite_render::Mesh2dWireframe>| { let output: Val<::bevy_sprite_render::Mesh2dWireframe> = { { - let output: Val<::bevy_sprite_render::Mesh2dWireframe> = <::bevy_sprite_render::Mesh2dWireframe as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_sprite_render::Mesh2dWireframe = <::bevy_sprite_render::Mesh2dWireframe as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -360,9 +346,8 @@ pub(crate) fn register_mesh_2_d_wireframe_functions(world: &mut World) { { let output: bool = <::bevy_sprite_render::Mesh2dWireframe as ::std::cmp::PartialEq< ::bevy_sprite_render::Mesh2dWireframe, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -398,16 +383,15 @@ pub(crate) fn register_tilemap_chunk_functions(world: &mut World) { "calculate_tile_transform", | _self: Ref<::bevy_sprite_render::TilemapChunk>, - position: Val<::glam::UVec2>| + position: Val<::bevy_math::UVec2>| { let output: Val<::bevy_transform::components::Transform> = { { - let output: Val<::bevy_transform::components::Transform> = ::bevy_sprite_render::TilemapChunk::calculate_tile_transform( - &_self, - position.into_inner(), - ) - .into(); - output + let output: ::bevy_transform::components::Transform = ::bevy_sprite_render::TilemapChunk::calculate_tile_transform( + safe_transmute(_self), + safe_transmute(position), + ); + safe_transmute(output) } }; output @@ -420,11 +404,10 @@ pub(crate) fn register_tilemap_chunk_functions(world: &mut World) { |_self: Ref<::bevy_sprite_render::TilemapChunk>| { let output: Val<::bevy_sprite_render::TilemapChunk> = { { - let output: Val<::bevy_sprite_render::TilemapChunk> = <::bevy_sprite_render::TilemapChunk as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_sprite_render::TilemapChunk = <::bevy_sprite_render::TilemapChunk as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -449,11 +432,10 @@ pub(crate) fn register_tile_data_functions(world: &mut World) { |_self: Ref<::bevy_sprite_render::TileData>| { let output: Val<::bevy_sprite_render::TileData> = { { - let output: Val<::bevy_sprite_render::TileData> = <::bevy_sprite_render::TileData as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_sprite_render::TileData = <::bevy_sprite_render::TileData as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -466,11 +448,10 @@ pub(crate) fn register_tile_data_functions(world: &mut World) { |tileset_index: u16| { let output: Val<::bevy_sprite_render::TileData> = { { - let output: Val<::bevy_sprite_render::TileData> = ::bevy_sprite_render::TileData::from_tileset_index( - tileset_index, - ) - .into(); - output + let output: ::bevy_sprite_render::TileData = ::bevy_sprite_render::TileData::from_tileset_index( + safe_transmute(tileset_index), + ); + safe_transmute(output) } }; output @@ -495,11 +476,10 @@ pub(crate) fn register_tilemap_chunk_tile_data_functions(world: &mut World) { |_self: Ref<::bevy_sprite_render::TilemapChunkTileData>| { let output: Val<::bevy_sprite_render::TilemapChunkTileData> = { { - let output: Val<::bevy_sprite_render::TilemapChunkTileData> = <::bevy_sprite_render::TilemapChunkTileData as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_sprite_render::TilemapChunkTileData = <::bevy_sprite_render::TilemapChunkTileData as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_text_bms_bindings/src/lib.rs b/crates/bindings/bevy_text_bms_bindings/src/lib.rs index ea0f7a8b7d..43de4d2839 100644 --- a/crates/bindings/bevy_text_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_text_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -25,10 +25,9 @@ pub(crate) fn register_justify_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_text::Justify as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41,11 +40,10 @@ pub(crate) fn register_justify_functions(world: &mut World) { |_self: Ref<::bevy_text::Justify>| { let output: Val<::bevy_text::Justify> = { { - let output: Val<::bevy_text::Justify> = <::bevy_text::Justify as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_text::Justify = <::bevy_text::Justify as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -60,9 +58,8 @@ pub(crate) fn register_justify_functions(world: &mut World) { { let output: bool = <::bevy_text::Justify as ::std::cmp::PartialEq< ::bevy_text::Justify, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -88,10 +85,9 @@ pub(crate) fn register_line_break_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_text::LineBreak as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -104,11 +100,10 @@ pub(crate) fn register_line_break_functions(world: &mut World) { |_self: Ref<::bevy_text::LineBreak>| { let output: Val<::bevy_text::LineBreak> = { { - let output: Val<::bevy_text::LineBreak> = <::bevy_text::LineBreak as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_text::LineBreak = <::bevy_text::LineBreak as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -123,9 +118,8 @@ pub(crate) fn register_line_break_functions(world: &mut World) { { let output: bool = <::bevy_text::LineBreak as ::std::cmp::PartialEq< ::bevy_text::LineBreak, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -150,11 +144,10 @@ pub(crate) fn register_text_color_functions(world: &mut World) { |_self: Ref<::bevy_text::TextColor>| { let output: Val<::bevy_text::TextColor> = { { - let output: Val<::bevy_text::TextColor> = <::bevy_text::TextColor as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_text::TextColor = <::bevy_text::TextColor as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -169,9 +162,8 @@ pub(crate) fn register_text_color_functions(world: &mut World) { { let output: bool = <::bevy_text::TextColor as ::std::cmp::PartialEq< ::bevy_text::TextColor, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -196,11 +188,10 @@ pub(crate) fn register_text_font_functions(world: &mut World) { |_self: Ref<::bevy_text::TextFont>| { let output: Val<::bevy_text::TextFont> = { { - let output: Val<::bevy_text::TextFont> = <::bevy_text::TextFont as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_text::TextFont = <::bevy_text::TextFont as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -215,9 +206,8 @@ pub(crate) fn register_text_font_functions(world: &mut World) { { let output: bool = <::bevy_text::TextFont as ::std::cmp::PartialEq< ::bevy_text::TextFont, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -230,11 +220,10 @@ pub(crate) fn register_text_font_functions(world: &mut World) { |font_size: f32| { let output: Val<::bevy_text::TextFont> = { { - let output: Val<::bevy_text::TextFont> = ::bevy_text::TextFont::from_font_size( - font_size, - ) - .into(); - output + let output: ::bevy_text::TextFont = ::bevy_text::TextFont::from_font_size( + safe_transmute(font_size), + ); + safe_transmute(output) } }; output @@ -247,12 +236,11 @@ pub(crate) fn register_text_font_functions(world: &mut World) { |_self: Val<::bevy_text::TextFont>, font_size: f32| { let output: Val<::bevy_text::TextFont> = { { - let output: Val<::bevy_text::TextFont> = ::bevy_text::TextFont::with_font_size( - _self.into_inner(), - font_size, - ) - .into(); - output + let output: ::bevy_text::TextFont = ::bevy_text::TextFont::with_font_size( + safe_transmute(_self), + safe_transmute(font_size), + ); + safe_transmute(output) } }; output @@ -268,12 +256,11 @@ pub(crate) fn register_text_font_functions(world: &mut World) { { let output: Val<::bevy_text::TextFont> = { { - let output: Val<::bevy_text::TextFont> = ::bevy_text::TextFont::with_font_smoothing( - _self.into_inner(), - font_smoothing.into_inner(), - ) - .into(); - output + let output: ::bevy_text::TextFont = ::bevy_text::TextFont::with_font_smoothing( + safe_transmute(_self), + safe_transmute(font_smoothing), + ); + safe_transmute(output) } }; output @@ -289,12 +276,11 @@ pub(crate) fn register_text_font_functions(world: &mut World) { { let output: Val<::bevy_text::TextFont> = { { - let output: Val<::bevy_text::TextFont> = ::bevy_text::TextFont::with_line_height( - _self.into_inner(), - line_height.into_inner(), - ) - .into(); - output + let output: ::bevy_text::TextFont = ::bevy_text::TextFont::with_line_height( + safe_transmute(_self), + safe_transmute(line_height), + ); + safe_transmute(output) } }; output @@ -319,11 +305,10 @@ pub(crate) fn register_text_layout_functions(world: &mut World) { |_self: Ref<::bevy_text::TextLayout>| { let output: Val<::bevy_text::TextLayout> = { { - let output: Val<::bevy_text::TextLayout> = <::bevy_text::TextLayout as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_text::TextLayout = <::bevy_text::TextLayout as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -336,12 +321,11 @@ pub(crate) fn register_text_layout_functions(world: &mut World) { |justify: Val<::bevy_text::Justify>, linebreak: Val<::bevy_text::LineBreak>| { let output: Val<::bevy_text::TextLayout> = { { - let output: Val<::bevy_text::TextLayout> = ::bevy_text::TextLayout::new( - justify.into_inner(), - linebreak.into_inner(), - ) - .into(); - output + let output: ::bevy_text::TextLayout = ::bevy_text::TextLayout::new( + safe_transmute(justify), + safe_transmute(linebreak), + ); + safe_transmute(output) } }; output @@ -354,11 +338,10 @@ pub(crate) fn register_text_layout_functions(world: &mut World) { |justify: Val<::bevy_text::Justify>| { let output: Val<::bevy_text::TextLayout> = { { - let output: Val<::bevy_text::TextLayout> = ::bevy_text::TextLayout::new_with_justify( - justify.into_inner(), - ) - .into(); - output + let output: ::bevy_text::TextLayout = ::bevy_text::TextLayout::new_with_justify( + safe_transmute(justify), + ); + safe_transmute(output) } }; output @@ -371,11 +354,10 @@ pub(crate) fn register_text_layout_functions(world: &mut World) { |linebreak: Val<::bevy_text::LineBreak>| { let output: Val<::bevy_text::TextLayout> = { { - let output: Val<::bevy_text::TextLayout> = ::bevy_text::TextLayout::new_with_linebreak( - linebreak.into_inner(), - ) - .into(); - output + let output: ::bevy_text::TextLayout = ::bevy_text::TextLayout::new_with_linebreak( + safe_transmute(linebreak), + ); + safe_transmute(output) } }; output @@ -388,9 +370,8 @@ pub(crate) fn register_text_layout_functions(world: &mut World) { || { let output: Val<::bevy_text::TextLayout> = { { - let output: Val<::bevy_text::TextLayout> = ::bevy_text::TextLayout::new_with_no_wrap() - .into(); - output + let output: ::bevy_text::TextLayout = ::bevy_text::TextLayout::new_with_no_wrap(); + safe_transmute(output) } }; output @@ -403,12 +384,11 @@ pub(crate) fn register_text_layout_functions(world: &mut World) { |_self: Val<::bevy_text::TextLayout>, justify: Val<::bevy_text::Justify>| { let output: Val<::bevy_text::TextLayout> = { { - let output: Val<::bevy_text::TextLayout> = ::bevy_text::TextLayout::with_justify( - _self.into_inner(), - justify.into_inner(), - ) - .into(); - output + let output: ::bevy_text::TextLayout = ::bevy_text::TextLayout::with_justify( + safe_transmute(_self), + safe_transmute(justify), + ); + safe_transmute(output) } }; output @@ -424,12 +404,11 @@ pub(crate) fn register_text_layout_functions(world: &mut World) { { let output: Val<::bevy_text::TextLayout> = { { - let output: Val<::bevy_text::TextLayout> = ::bevy_text::TextLayout::with_linebreak( - _self.into_inner(), - linebreak.into_inner(), - ) - .into(); - output + let output: ::bevy_text::TextLayout = ::bevy_text::TextLayout::with_linebreak( + safe_transmute(_self), + safe_transmute(linebreak), + ); + safe_transmute(output) } }; output @@ -442,11 +421,10 @@ pub(crate) fn register_text_layout_functions(world: &mut World) { |_self: Val<::bevy_text::TextLayout>| { let output: Val<::bevy_text::TextLayout> = { { - let output: Val<::bevy_text::TextLayout> = ::bevy_text::TextLayout::with_no_wrap( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_text::TextLayout = ::bevy_text::TextLayout::with_no_wrap( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -471,11 +449,10 @@ pub(crate) fn register_text_span_functions(world: &mut World) { |_self: Ref<::bevy_text::TextSpan>| { let output: Val<::bevy_text::TextSpan> = { { - let output: Val<::bevy_text::TextSpan> = <::bevy_text::TextSpan as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_text::TextSpan = <::bevy_text::TextSpan as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -500,11 +477,10 @@ pub(crate) fn register_text_bounds_functions(world: &mut World) { |_self: Ref<::bevy_text::TextBounds>| { let output: Val<::bevy_text::TextBounds> = { { - let output: Val<::bevy_text::TextBounds> = <::bevy_text::TextBounds as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_text::TextBounds = <::bevy_text::TextBounds as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -517,12 +493,11 @@ pub(crate) fn register_text_bounds_functions(world: &mut World) { |width: f32, height: f32| { let output: Val<::bevy_text::TextBounds> = { { - let output: Val<::bevy_text::TextBounds> = ::bevy_text::TextBounds::new( - width, - height, - ) - .into(); - output + let output: ::bevy_text::TextBounds = ::bevy_text::TextBounds::new( + safe_transmute(width), + safe_transmute(height), + ); + safe_transmute(output) } }; output @@ -535,11 +510,10 @@ pub(crate) fn register_text_bounds_functions(world: &mut World) { |width: f32| { let output: Val<::bevy_text::TextBounds> = { { - let output: Val<::bevy_text::TextBounds> = ::bevy_text::TextBounds::new_horizontal( - width, - ) - .into(); - output + let output: ::bevy_text::TextBounds = ::bevy_text::TextBounds::new_horizontal( + safe_transmute(width), + ); + safe_transmute(output) } }; output @@ -552,11 +526,10 @@ pub(crate) fn register_text_bounds_functions(world: &mut World) { |height: f32| { let output: Val<::bevy_text::TextBounds> = { { - let output: Val<::bevy_text::TextBounds> = ::bevy_text::TextBounds::new_vertical( - height, - ) - .into(); - output + let output: ::bevy_text::TextBounds = ::bevy_text::TextBounds::new_vertical( + safe_transmute(height), + ); + safe_transmute(output) } }; output @@ -582,10 +555,9 @@ pub(crate) fn register_font_smoothing_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_text::FontSmoothing as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -598,11 +570,10 @@ pub(crate) fn register_font_smoothing_functions(world: &mut World) { |_self: Ref<::bevy_text::FontSmoothing>| { let output: Val<::bevy_text::FontSmoothing> = { { - let output: Val<::bevy_text::FontSmoothing> = <::bevy_text::FontSmoothing as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_text::FontSmoothing = <::bevy_text::FontSmoothing as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -620,9 +591,8 @@ pub(crate) fn register_font_smoothing_functions(world: &mut World) { { let output: bool = <::bevy_text::FontSmoothing as ::std::cmp::PartialEq< ::bevy_text::FontSmoothing, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -647,11 +617,10 @@ pub(crate) fn register_glyph_atlas_location_functions(world: &mut World) { |_self: Ref<::bevy_text::GlyphAtlasLocation>| { let output: Val<::bevy_text::GlyphAtlasLocation> = { { - let output: Val<::bevy_text::GlyphAtlasLocation> = <::bevy_text::GlyphAtlasLocation as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_text::GlyphAtlasLocation = <::bevy_text::GlyphAtlasLocation as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -676,11 +645,10 @@ pub(crate) fn register_glyph_atlas_info_functions(world: &mut World) { |_self: Ref<::bevy_text::GlyphAtlasInfo>| { let output: Val<::bevy_text::GlyphAtlasInfo> = { { - let output: Val<::bevy_text::GlyphAtlasInfo> = <::bevy_text::GlyphAtlasInfo as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_text::GlyphAtlasInfo = <::bevy_text::GlyphAtlasInfo as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -705,11 +673,10 @@ pub(crate) fn register_positioned_glyph_functions(world: &mut World) { |_self: Ref<::bevy_text::PositionedGlyph>| { let output: Val<::bevy_text::PositionedGlyph> = { { - let output: Val<::bevy_text::PositionedGlyph> = <::bevy_text::PositionedGlyph as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_text::PositionedGlyph = <::bevy_text::PositionedGlyph as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -734,11 +701,10 @@ pub(crate) fn register_computed_text_block_functions(world: &mut World) { |_self: Ref<::bevy_text::ComputedTextBlock>| { let output: Val<::bevy_text::ComputedTextBlock> = { { - let output: Val<::bevy_text::ComputedTextBlock> = <::bevy_text::ComputedTextBlock as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_text::ComputedTextBlock = <::bevy_text::ComputedTextBlock as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -752,10 +718,9 @@ pub(crate) fn register_computed_text_block_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_text::ComputedTextBlock::needs_rerender( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -780,11 +745,10 @@ pub(crate) fn register_text_entity_functions(world: &mut World) { |_self: Ref<::bevy_text::TextEntity>| { let output: Val<::bevy_text::TextEntity> = { { - let output: Val<::bevy_text::TextEntity> = <::bevy_text::TextEntity as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_text::TextEntity = <::bevy_text::TextEntity as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -809,11 +773,10 @@ pub(crate) fn register_text_layout_info_functions(world: &mut World) { |_self: Ref<::bevy_text::TextLayoutInfo>| { let output: Val<::bevy_text::TextLayoutInfo> = { { - let output: Val<::bevy_text::TextLayoutInfo> = <::bevy_text::TextLayoutInfo as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_text::TextLayoutInfo = <::bevy_text::TextLayoutInfo as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -838,11 +801,10 @@ pub(crate) fn register_line_height_functions(world: &mut World) { |_self: Ref<::bevy_text::LineHeight>| { let output: Val<::bevy_text::LineHeight> = { { - let output: Val<::bevy_text::LineHeight> = <::bevy_text::LineHeight as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_text::LineHeight = <::bevy_text::LineHeight as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -857,9 +819,8 @@ pub(crate) fn register_line_height_functions(world: &mut World) { { let output: bool = <::bevy_text::LineHeight as ::std::cmp::PartialEq< ::bevy_text::LineHeight, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -884,11 +845,10 @@ pub(crate) fn register_text_background_color_functions(world: &mut World) { |_self: Ref<::bevy_text::TextBackgroundColor>| { let output: Val<::bevy_text::TextBackgroundColor> = { { - let output: Val<::bevy_text::TextBackgroundColor> = <::bevy_text::TextBackgroundColor as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_text::TextBackgroundColor = <::bevy_text::TextBackgroundColor as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -906,9 +866,8 @@ pub(crate) fn register_text_background_color_functions(world: &mut World) { { let output: bool = <::bevy_text::TextBackgroundColor as ::std::cmp::PartialEq< ::bevy_text::TextBackgroundColor, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_time_bms_bindings/src/lib.rs b/crates/bindings/bevy_time_bms_bindings/src/lib.rs index bfeb9fd13f..457e112a27 100644 --- a/crates/bindings/bevy_time_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_time_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -24,11 +24,10 @@ pub(crate) fn register_fixed_functions(world: &mut World) { |_self: Ref<::bevy_time::Fixed>| { let output: Val<::bevy_time::Fixed> = { { - let output: Val<::bevy_time::Fixed> = <::bevy_time::Fixed as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_time::Fixed = <::bevy_time::Fixed as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -53,11 +52,10 @@ pub(crate) fn register_real_functions(world: &mut World) { |_self: Ref<::bevy_time::Real>| { let output: Val<::bevy_time::Real> = { { - let output: Val<::bevy_time::Real> = <::bevy_time::Real as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_time::Real = <::bevy_time::Real as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -83,10 +81,9 @@ pub(crate) fn register_timer_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_time::Timer as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -99,11 +96,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { |_self: Ref<::bevy_time::Timer>| { let output: Val<::bevy_time::Timer> = { { - let output: Val<::bevy_time::Timer> = <::bevy_time::Timer as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_time::Timer = <::bevy_time::Timer as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -116,11 +112,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { |_self: Ref<::bevy_time::Timer>| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = ::bevy_time::Timer::duration( - &_self, - ) - .into(); - output + let output: ::core::time::Duration = ::bevy_time::Timer::duration( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -133,11 +128,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { |_self: Ref<::bevy_time::Timer>| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = ::bevy_time::Timer::elapsed( - &_self, - ) - .into(); - output + let output: ::core::time::Duration = ::bevy_time::Timer::elapsed( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -150,9 +144,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { |_self: Ref<::bevy_time::Timer>| { let output: f32 = { { - let output: f32 = ::bevy_time::Timer::elapsed_secs(&_self) - .into(); - output + let output: f32 = ::bevy_time::Timer::elapsed_secs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -165,9 +160,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { |_self: Ref<::bevy_time::Timer>| { let output: f64 = { { - let output: f64 = ::bevy_time::Timer::elapsed_secs_f64(&_self) - .into(); - output + let output: f64 = ::bevy_time::Timer::elapsed_secs_f64( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -182,9 +178,8 @@ pub(crate) fn register_timer_functions(world: &mut World) { { let output: bool = <::bevy_time::Timer as ::core::cmp::PartialEq< ::bevy_time::Timer, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -197,8 +192,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { |mut _self: Mut<::bevy_time::Timer>| { let output: () = { { - let output: () = ::bevy_time::Timer::finish(&mut _self).into(); - output + let output: () = ::bevy_time::Timer::finish( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -211,8 +208,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { |_self: Ref<::bevy_time::Timer>| { let output: bool = { { - let output: bool = ::bevy_time::Timer::finished(&_self).into(); - output + let output: bool = ::bevy_time::Timer::finished( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -225,8 +224,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { |_self: Ref<::bevy_time::Timer>| { let output: f32 = { { - let output: f32 = ::bevy_time::Timer::fraction(&_self).into(); - output + let output: f32 = ::bevy_time::Timer::fraction( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -239,9 +240,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { |_self: Ref<::bevy_time::Timer>| { let output: f32 = { { - let output: f32 = ::bevy_time::Timer::fraction_remaining(&_self) - .into(); - output + let output: f32 = ::bevy_time::Timer::fraction_remaining( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -254,12 +256,11 @@ pub(crate) fn register_timer_functions(world: &mut World) { |duration: f32, mode: Val<::bevy_time::TimerMode>| { let output: Val<::bevy_time::Timer> = { { - let output: Val<::bevy_time::Timer> = ::bevy_time::Timer::from_seconds( - duration, - mode.into_inner(), - ) - .into(); - output + let output: ::bevy_time::Timer = ::bevy_time::Timer::from_seconds( + safe_transmute(duration), + safe_transmute(mode), + ); + safe_transmute(output) } }; output @@ -272,9 +273,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { |_self: Ref<::bevy_time::Timer>| { let output: bool = { { - let output: bool = ::bevy_time::Timer::is_finished(&_self) - .into(); - output + let output: bool = ::bevy_time::Timer::is_finished( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -287,8 +289,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { |_self: Ref<::bevy_time::Timer>| { let output: bool = { { - let output: bool = ::bevy_time::Timer::is_paused(&_self).into(); - output + let output: bool = ::bevy_time::Timer::is_paused( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -301,9 +305,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { |_self: Ref<::bevy_time::Timer>| { let output: bool = { { - let output: bool = ::bevy_time::Timer::just_finished(&_self) - .into(); - output + let output: bool = ::bevy_time::Timer::just_finished( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -316,11 +321,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { |_self: Ref<::bevy_time::Timer>| { let output: Val<::bevy_time::TimerMode> = { { - let output: Val<::bevy_time::TimerMode> = ::bevy_time::Timer::mode( - &_self, - ) - .into(); - output + let output: ::bevy_time::TimerMode = ::bevy_time::Timer::mode( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -333,12 +337,11 @@ pub(crate) fn register_timer_functions(world: &mut World) { |duration: Val<::core::time::Duration>, mode: Val<::bevy_time::TimerMode>| { let output: Val<::bevy_time::Timer> = { { - let output: Val<::bevy_time::Timer> = ::bevy_time::Timer::new( - duration.into_inner(), - mode.into_inner(), - ) - .into(); - output + let output: ::bevy_time::Timer = ::bevy_time::Timer::new( + safe_transmute(duration), + safe_transmute(mode), + ); + safe_transmute(output) } }; output @@ -351,8 +354,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { |mut _self: Mut<::bevy_time::Timer>| { let output: () = { { - let output: () = ::bevy_time::Timer::pause(&mut _self).into(); - output + let output: () = ::bevy_time::Timer::pause( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -365,8 +370,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { |_self: Ref<::bevy_time::Timer>| { let output: bool = { { - let output: bool = ::bevy_time::Timer::paused(&_self).into(); - output + let output: bool = ::bevy_time::Timer::paused( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -379,11 +386,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { |_self: Ref<::bevy_time::Timer>| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = ::bevy_time::Timer::remaining( - &_self, - ) - .into(); - output + let output: ::core::time::Duration = ::bevy_time::Timer::remaining( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -396,9 +402,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { |_self: Ref<::bevy_time::Timer>| { let output: f32 = { { - let output: f32 = ::bevy_time::Timer::remaining_secs(&_self) - .into(); - output + let output: f32 = ::bevy_time::Timer::remaining_secs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -411,8 +418,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { |mut _self: Mut<::bevy_time::Timer>| { let output: () = { { - let output: () = ::bevy_time::Timer::reset(&mut _self).into(); - output + let output: () = ::bevy_time::Timer::reset( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -426,11 +435,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_time::Timer::set_duration( - &mut _self, - duration.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(duration), + ); + safe_transmute(output) } }; output @@ -444,11 +452,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_time::Timer::set_elapsed( - &mut _self, - time.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(time), + ); + safe_transmute(output) } }; output @@ -462,11 +469,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_time::Timer::set_mode( - &mut _self, - mode.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(mode), + ); + safe_transmute(output) } }; output @@ -480,10 +486,9 @@ pub(crate) fn register_timer_functions(world: &mut World) { let output: u32 = { { let output: u32 = ::bevy_time::Timer::times_finished_this_tick( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -496,8 +501,10 @@ pub(crate) fn register_timer_functions(world: &mut World) { |mut _self: Mut<::bevy_time::Timer>| { let output: () = { { - let output: () = ::bevy_time::Timer::unpause(&mut _self).into(); - output + let output: () = ::bevy_time::Timer::unpause( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -523,10 +530,9 @@ pub(crate) fn register_timer_mode_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_time::TimerMode as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -539,11 +545,10 @@ pub(crate) fn register_timer_mode_functions(world: &mut World) { |_self: Ref<::bevy_time::TimerMode>| { let output: Val<::bevy_time::TimerMode> = { { - let output: Val<::bevy_time::TimerMode> = <::bevy_time::TimerMode as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_time::TimerMode = <::bevy_time::TimerMode as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -558,9 +563,8 @@ pub(crate) fn register_timer_mode_functions(world: &mut World) { { let output: bool = <::bevy_time::TimerMode as ::core::cmp::PartialEq< ::bevy_time::TimerMode, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -585,11 +589,10 @@ pub(crate) fn register_virtual_functions(world: &mut World) { |_self: Ref<::bevy_time::Virtual>| { let output: Val<::bevy_time::Virtual> = { { - let output: Val<::bevy_time::Virtual> = <::bevy_time::Virtual as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_time::Virtual = <::bevy_time::Virtual as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -615,10 +618,9 @@ pub(crate) fn register_stopwatch_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_time::Stopwatch as ::core::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -631,11 +633,10 @@ pub(crate) fn register_stopwatch_functions(world: &mut World) { |_self: Ref<::bevy_time::Stopwatch>| { let output: Val<::bevy_time::Stopwatch> = { { - let output: Val<::bevy_time::Stopwatch> = <::bevy_time::Stopwatch as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_time::Stopwatch = <::bevy_time::Stopwatch as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -648,11 +649,10 @@ pub(crate) fn register_stopwatch_functions(world: &mut World) { |_self: Ref<::bevy_time::Stopwatch>| { let output: Val<::core::time::Duration> = { { - let output: Val<::core::time::Duration> = ::bevy_time::Stopwatch::elapsed( - &_self, - ) - .into(); - output + let output: ::core::time::Duration = ::bevy_time::Stopwatch::elapsed( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -665,9 +665,10 @@ pub(crate) fn register_stopwatch_functions(world: &mut World) { |_self: Ref<::bevy_time::Stopwatch>| { let output: f32 = { { - let output: f32 = ::bevy_time::Stopwatch::elapsed_secs(&_self) - .into(); - output + let output: f32 = ::bevy_time::Stopwatch::elapsed_secs( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -681,10 +682,9 @@ pub(crate) fn register_stopwatch_functions(world: &mut World) { let output: f64 = { { let output: f64 = ::bevy_time::Stopwatch::elapsed_secs_f64( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -699,9 +699,8 @@ pub(crate) fn register_stopwatch_functions(world: &mut World) { { let output: bool = <::bevy_time::Stopwatch as ::core::cmp::PartialEq< ::bevy_time::Stopwatch, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -714,9 +713,10 @@ pub(crate) fn register_stopwatch_functions(world: &mut World) { |_self: Ref<::bevy_time::Stopwatch>| { let output: bool = { { - let output: bool = ::bevy_time::Stopwatch::is_paused(&_self) - .into(); - output + let output: bool = ::bevy_time::Stopwatch::is_paused( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -729,9 +729,8 @@ pub(crate) fn register_stopwatch_functions(world: &mut World) { || { let output: Val<::bevy_time::Stopwatch> = { { - let output: Val<::bevy_time::Stopwatch> = ::bevy_time::Stopwatch::new() - .into(); - output + let output: ::bevy_time::Stopwatch = ::bevy_time::Stopwatch::new(); + safe_transmute(output) } }; output @@ -744,9 +743,10 @@ pub(crate) fn register_stopwatch_functions(world: &mut World) { |mut _self: Mut<::bevy_time::Stopwatch>| { let output: () = { { - let output: () = ::bevy_time::Stopwatch::pause(&mut _self) - .into(); - output + let output: () = ::bevy_time::Stopwatch::pause( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -759,9 +759,10 @@ pub(crate) fn register_stopwatch_functions(world: &mut World) { |mut _self: Mut<::bevy_time::Stopwatch>| { let output: () = { { - let output: () = ::bevy_time::Stopwatch::reset(&mut _self) - .into(); - output + let output: () = ::bevy_time::Stopwatch::reset( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -775,11 +776,10 @@ pub(crate) fn register_stopwatch_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_time::Stopwatch::set_elapsed( - &mut _self, - time.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(time), + ); + safe_transmute(output) } }; output @@ -792,9 +792,10 @@ pub(crate) fn register_stopwatch_functions(world: &mut World) { |mut _self: Mut<::bevy_time::Stopwatch>| { let output: () = { { - let output: () = ::bevy_time::Stopwatch::unpause(&mut _self) - .into(); - output + let output: () = ::bevy_time::Stopwatch::unpause( + safe_transmute(_self), + ); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_transform_bms_bindings/src/lib.rs b/crates/bindings/bevy_transform_bms_bindings/src/lib.rs index 429839d86c..ea9cf9ec9d 100644 --- a/crates/bindings/bevy_transform_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_transform_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -22,13 +22,12 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { .register_documented( "affine", |_self: Ref<::bevy_transform::components::GlobalTransform>| { - let output: Val<::glam::Affine3A> = { + let output: Val<::bevy_math::Affine3A> = { { - let output: Val<::glam::Affine3A> = ::bevy_transform::components::GlobalTransform::affine( - &_self, - ) - .into(); - output + let output: ::bevy_math::Affine3A = ::bevy_transform::components::GlobalTransform::affine( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41,11 +40,10 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { |_self: Ref<::bevy_transform::components::GlobalTransform>| { let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::GlobalTransform::back( - &_self, - ) - .into(); - output + let output: ::bevy_math::Dir3 = ::bevy_transform::components::GlobalTransform::back( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -58,11 +56,10 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { |_self: Ref<::bevy_transform::components::GlobalTransform>| { let output: Val<::bevy_transform::components::GlobalTransform> = { { - let output: Val<::bevy_transform::components::GlobalTransform> = <::bevy_transform::components::GlobalTransform as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_transform::components::GlobalTransform = <::bevy_transform::components::GlobalTransform as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -75,11 +72,10 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { |_self: Ref<::bevy_transform::components::GlobalTransform>| { let output: Val<::bevy_transform::components::Transform> = { { - let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::GlobalTransform::compute_transform( - &_self, - ) - .into(); - output + let output: ::bevy_transform::components::Transform = ::bevy_transform::components::GlobalTransform::compute_transform( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -92,11 +88,10 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { |_self: Ref<::bevy_transform::components::GlobalTransform>| { let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::GlobalTransform::down( - &_self, - ) - .into(); - output + let output: ::bevy_math::Dir3 = ::bevy_transform::components::GlobalTransform::down( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -114,9 +109,8 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { { let output: bool = <::bevy_transform::components::GlobalTransform as ::core::cmp::PartialEq< ::bevy_transform::components::GlobalTransform, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -129,11 +123,10 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { |_self: Ref<::bevy_transform::components::GlobalTransform>| { let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::GlobalTransform::forward( - &_self, - ) - .into(); - output + let output: ::bevy_math::Dir3 = ::bevy_transform::components::GlobalTransform::forward( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -146,11 +139,10 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { |iso: Val<::bevy_math::Isometry3d>| { let output: Val<::bevy_transform::components::GlobalTransform> = { { - let output: Val<::bevy_transform::components::GlobalTransform> = ::bevy_transform::components::GlobalTransform::from_isometry( - iso.into_inner(), - ) - .into(); - output + let output: ::bevy_transform::components::GlobalTransform = ::bevy_transform::components::GlobalTransform::from_isometry( + safe_transmute(iso), + ); + safe_transmute(output) } }; output @@ -160,14 +152,13 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { ) .register_documented( "from_rotation", - |rotation: Val<::glam::Quat>| { + |rotation: Val<::bevy_math::Quat>| { let output: Val<::bevy_transform::components::GlobalTransform> = { { - let output: Val<::bevy_transform::components::GlobalTransform> = ::bevy_transform::components::GlobalTransform::from_rotation( - rotation.into_inner(), - ) - .into(); - output + let output: ::bevy_transform::components::GlobalTransform = ::bevy_transform::components::GlobalTransform::from_rotation( + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -177,14 +168,13 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { ) .register_documented( "from_scale", - |scale: Val<::glam::Vec3>| { + |scale: Val<::bevy_math::Vec3>| { let output: Val<::bevy_transform::components::GlobalTransform> = { { - let output: Val<::bevy_transform::components::GlobalTransform> = ::bevy_transform::components::GlobalTransform::from_scale( - scale.into_inner(), - ) - .into(); - output + let output: ::bevy_transform::components::GlobalTransform = ::bevy_transform::components::GlobalTransform::from_scale( + safe_transmute(scale), + ); + safe_transmute(output) } }; output @@ -194,14 +184,13 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { ) .register_documented( "from_translation", - |translation: Val<::glam::Vec3>| { + |translation: Val<::bevy_math::Vec3>| { let output: Val<::bevy_transform::components::GlobalTransform> = { { - let output: Val<::bevy_transform::components::GlobalTransform> = ::bevy_transform::components::GlobalTransform::from_translation( - translation.into_inner(), - ) - .into(); - output + let output: ::bevy_transform::components::GlobalTransform = ::bevy_transform::components::GlobalTransform::from_translation( + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -214,13 +203,12 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { |x: f32, y: f32, z: f32| { let output: Val<::bevy_transform::components::GlobalTransform> = { { - let output: Val<::bevy_transform::components::GlobalTransform> = ::bevy_transform::components::GlobalTransform::from_xyz( - x, - y, - z, - ) - .into(); - output + let output: ::bevy_transform::components::GlobalTransform = ::bevy_transform::components::GlobalTransform::from_xyz( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -233,11 +221,10 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { |_self: Ref<::bevy_transform::components::GlobalTransform>| { let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::GlobalTransform::left( - &_self, - ) - .into(); - output + let output: ::bevy_math::Dir3 = ::bevy_transform::components::GlobalTransform::left( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -249,61 +236,58 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { "mul", | _self: Val<::bevy_transform::components::GlobalTransform>, - global_transform: Val<::bevy_transform::components::GlobalTransform>| + value: Val<::bevy_math::Vec3>| { - let output: Val<::bevy_transform::components::GlobalTransform> = { + let output: Val<::bevy_math::Vec3> = { { - let output: Val<::bevy_transform::components::GlobalTransform> = <::bevy_transform::components::GlobalTransform as ::core::ops::Mul< - ::bevy_transform::components::GlobalTransform, - >>::mul(_self.into_inner(), global_transform.into_inner()) - .into(); - output + let output: ::bevy_math::Vec3 = <::bevy_transform::components::GlobalTransform as ::core::ops::Mul< + ::bevy_math::Vec3, + >>::mul(safe_transmute(_self), safe_transmute(value)); + safe_transmute(output) } }; output }, "", - &["_self", "global_transform"], + &["_self", "value"], ) .register_documented( "mul", | _self: Val<::bevy_transform::components::GlobalTransform>, - transform: Val<::bevy_transform::components::Transform>| + global_transform: Val<::bevy_transform::components::GlobalTransform>| { let output: Val<::bevy_transform::components::GlobalTransform> = { { - let output: Val<::bevy_transform::components::GlobalTransform> = <::bevy_transform::components::GlobalTransform as ::core::ops::Mul< - ::bevy_transform::components::Transform, - >>::mul(_self.into_inner(), transform.into_inner()) - .into(); - output + let output: ::bevy_transform::components::GlobalTransform = <::bevy_transform::components::GlobalTransform as ::core::ops::Mul< + ::bevy_transform::components::GlobalTransform, + >>::mul(safe_transmute(_self), safe_transmute(global_transform)); + safe_transmute(output) } }; output }, "", - &["_self", "transform"], + &["_self", "global_transform"], ) .register_documented( "mul", | _self: Val<::bevy_transform::components::GlobalTransform>, - value: Val<::glam::Vec3>| + transform: Val<::bevy_transform::components::Transform>| { - let output: Val<::glam::Vec3> = { + let output: Val<::bevy_transform::components::GlobalTransform> = { { - let output: Val<::glam::Vec3> = <::bevy_transform::components::GlobalTransform as ::core::ops::Mul< - ::glam::Vec3, - >>::mul(_self.into_inner(), value.into_inner()) - .into(); - output + let output: ::bevy_transform::components::GlobalTransform = <::bevy_transform::components::GlobalTransform as ::core::ops::Mul< + ::bevy_transform::components::Transform, + >>::mul(safe_transmute(_self), safe_transmute(transform)); + safe_transmute(output) } }; output }, "", - &["_self", "value"], + &["_self", "transform"], ) .register_documented( "mul_transform", @@ -313,12 +297,11 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { { let output: Val<::bevy_transform::components::GlobalTransform> = { { - let output: Val<::bevy_transform::components::GlobalTransform> = ::bevy_transform::components::GlobalTransform::mul_transform( - &_self, - transform.into_inner(), - ) - .into(); - output + let output: ::bevy_transform::components::GlobalTransform = ::bevy_transform::components::GlobalTransform::mul_transform( + safe_transmute(_self), + safe_transmute(transform), + ); + safe_transmute(output) } }; output @@ -330,16 +313,15 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { "radius_vec3a", | _self: Ref<::bevy_transform::components::GlobalTransform>, - extents: Val<::glam::Vec3A>| + extents: Val<::bevy_math::Vec3A>| { let output: f32 = { { let output: f32 = ::bevy_transform::components::GlobalTransform::radius_vec3a( - &_self, - extents.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(extents), + ); + safe_transmute(output) } }; output @@ -355,12 +337,11 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { { let output: Val<::bevy_transform::components::Transform> = { { - let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::GlobalTransform::reparented_to( - &_self, - &parent, - ) - .into(); - output + let output: ::bevy_transform::components::Transform = ::bevy_transform::components::GlobalTransform::reparented_to( + safe_transmute(_self), + safe_transmute(parent), + ); + safe_transmute(output) } }; output @@ -373,11 +354,10 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { |_self: Ref<::bevy_transform::components::GlobalTransform>| { let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::GlobalTransform::right( - &_self, - ) - .into(); - output + let output: ::bevy_math::Dir3 = ::bevy_transform::components::GlobalTransform::right( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -388,13 +368,12 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { .register_documented( "rotation", |_self: Ref<::bevy_transform::components::GlobalTransform>| { - let output: Val<::glam::Quat> = { + let output: Val<::bevy_math::Quat> = { { - let output: Val<::glam::Quat> = ::bevy_transform::components::GlobalTransform::rotation( - &_self, - ) - .into(); - output + let output: ::bevy_math::Quat = ::bevy_transform::components::GlobalTransform::rotation( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -405,13 +384,12 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { .register_documented( "scale", |_self: Ref<::bevy_transform::components::GlobalTransform>| { - let output: Val<::glam::Vec3> = { + let output: Val<::bevy_math::Vec3> = { { - let output: Val<::glam::Vec3> = ::bevy_transform::components::GlobalTransform::scale( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec3 = ::bevy_transform::components::GlobalTransform::scale( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -424,11 +402,10 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { |_self: Ref<::bevy_transform::components::GlobalTransform>| { let output: Val<::bevy_math::Isometry3d> = { { - let output: Val<::bevy_math::Isometry3d> = ::bevy_transform::components::GlobalTransform::to_isometry( - &_self, - ) - .into(); - output + let output: ::bevy_math::Isometry3d = ::bevy_transform::components::GlobalTransform::to_isometry( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -439,13 +416,12 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { .register_documented( "to_matrix", |_self: Ref<::bevy_transform::components::GlobalTransform>| { - let output: Val<::glam::Mat4> = { + let output: Val<::bevy_math::Mat4> = { { - let output: Val<::glam::Mat4> = ::bevy_transform::components::GlobalTransform::to_matrix( - &_self, - ) - .into(); - output + let output: ::bevy_math::Mat4 = ::bevy_transform::components::GlobalTransform::to_matrix( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -457,16 +433,15 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { "transform_point", | _self: Ref<::bevy_transform::components::GlobalTransform>, - point: Val<::glam::Vec3>| + point: Val<::bevy_math::Vec3>| { - let output: Val<::glam::Vec3> = { + let output: Val<::bevy_math::Vec3> = { { - let output: Val<::glam::Vec3> = ::bevy_transform::components::GlobalTransform::transform_point( - &_self, - point.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Vec3 = ::bevy_transform::components::GlobalTransform::transform_point( + safe_transmute(_self), + safe_transmute(point), + ); + safe_transmute(output) } }; output @@ -477,13 +452,12 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { .register_documented( "translation", |_self: Ref<::bevy_transform::components::GlobalTransform>| { - let output: Val<::glam::Vec3> = { + let output: Val<::bevy_math::Vec3> = { { - let output: Val<::glam::Vec3> = ::bevy_transform::components::GlobalTransform::translation( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec3 = ::bevy_transform::components::GlobalTransform::translation( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -494,13 +468,12 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { .register_documented( "translation_vec3a", |_self: Ref<::bevy_transform::components::GlobalTransform>| { - let output: Val<::glam::Vec3A> = { + let output: Val<::bevy_math::Vec3A> = { { - let output: Val<::glam::Vec3A> = ::bevy_transform::components::GlobalTransform::translation_vec3a( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec3A = ::bevy_transform::components::GlobalTransform::translation_vec3a( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -513,11 +486,10 @@ pub(crate) fn register_global_transform_functions(world: &mut World) { |_self: Ref<::bevy_transform::components::GlobalTransform>| { let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::GlobalTransform::up( - &_self, - ) - .into(); - output + let output: ::bevy_math::Dir3 = ::bevy_transform::components::GlobalTransform::up( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -542,11 +514,10 @@ pub(crate) fn register_transform_functions(world: &mut World) { |_self: Ref<::bevy_transform::components::Transform>| { let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::Transform::back( - &_self, - ) - .into(); - output + let output: ::bevy_math::Dir3 = ::bevy_transform::components::Transform::back( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -559,11 +530,10 @@ pub(crate) fn register_transform_functions(world: &mut World) { |_self: Ref<::bevy_transform::components::Transform>| { let output: Val<::bevy_transform::components::Transform> = { { - let output: Val<::bevy_transform::components::Transform> = <::bevy_transform::components::Transform as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_transform::components::Transform = <::bevy_transform::components::Transform as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -574,13 +544,12 @@ pub(crate) fn register_transform_functions(world: &mut World) { .register_documented( "compute_affine", |_self: Ref<::bevy_transform::components::Transform>| { - let output: Val<::glam::Affine3A> = { + let output: Val<::bevy_math::Affine3A> = { { - let output: Val<::glam::Affine3A> = ::bevy_transform::components::Transform::compute_affine( - &_self, - ) - .into(); - output + let output: ::bevy_math::Affine3A = ::bevy_transform::components::Transform::compute_affine( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -593,11 +562,10 @@ pub(crate) fn register_transform_functions(world: &mut World) { |_self: Ref<::bevy_transform::components::Transform>| { let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::Transform::down( - &_self, - ) - .into(); - output + let output: ::bevy_math::Dir3 = ::bevy_transform::components::Transform::down( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -615,9 +583,8 @@ pub(crate) fn register_transform_functions(world: &mut World) { { let output: bool = <::bevy_transform::components::Transform as ::core::cmp::PartialEq< ::bevy_transform::components::Transform, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -630,11 +597,10 @@ pub(crate) fn register_transform_functions(world: &mut World) { |_self: Ref<::bevy_transform::components::Transform>| { let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::Transform::forward( - &_self, - ) - .into(); - output + let output: ::bevy_math::Dir3 = ::bevy_transform::components::Transform::forward( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -647,11 +613,10 @@ pub(crate) fn register_transform_functions(world: &mut World) { |iso: Val<::bevy_math::Isometry3d>| { let output: Val<::bevy_transform::components::Transform> = { { - let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::from_isometry( - iso.into_inner(), - ) - .into(); - output + let output: ::bevy_transform::components::Transform = ::bevy_transform::components::Transform::from_isometry( + safe_transmute(iso), + ); + safe_transmute(output) } }; output @@ -661,14 +626,13 @@ pub(crate) fn register_transform_functions(world: &mut World) { ) .register_documented( "from_matrix", - |world_from_local: Val<::glam::Mat4>| { + |world_from_local: Val<::bevy_math::Mat4>| { let output: Val<::bevy_transform::components::Transform> = { { - let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::from_matrix( - world_from_local.into_inner(), - ) - .into(); - output + let output: ::bevy_transform::components::Transform = ::bevy_transform::components::Transform::from_matrix( + safe_transmute(world_from_local), + ); + safe_transmute(output) } }; output @@ -678,14 +642,13 @@ pub(crate) fn register_transform_functions(world: &mut World) { ) .register_documented( "from_rotation", - |rotation: Val<::glam::Quat>| { + |rotation: Val<::bevy_math::Quat>| { let output: Val<::bevy_transform::components::Transform> = { { - let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::from_rotation( - rotation.into_inner(), - ) - .into(); - output + let output: ::bevy_transform::components::Transform = ::bevy_transform::components::Transform::from_rotation( + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -695,14 +658,13 @@ pub(crate) fn register_transform_functions(world: &mut World) { ) .register_documented( "from_scale", - |scale: Val<::glam::Vec3>| { + |scale: Val<::bevy_math::Vec3>| { let output: Val<::bevy_transform::components::Transform> = { { - let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::from_scale( - scale.into_inner(), - ) - .into(); - output + let output: ::bevy_transform::components::Transform = ::bevy_transform::components::Transform::from_scale( + safe_transmute(scale), + ); + safe_transmute(output) } }; output @@ -712,14 +674,13 @@ pub(crate) fn register_transform_functions(world: &mut World) { ) .register_documented( "from_translation", - |translation: Val<::glam::Vec3>| { + |translation: Val<::bevy_math::Vec3>| { let output: Val<::bevy_transform::components::Transform> = { { - let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::from_translation( - translation.into_inner(), - ) - .into(); - output + let output: ::bevy_transform::components::Transform = ::bevy_transform::components::Transform::from_translation( + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -732,13 +693,12 @@ pub(crate) fn register_transform_functions(world: &mut World) { |x: f32, y: f32, z: f32| { let output: Val<::bevy_transform::components::Transform> = { { - let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::from_xyz( - x, - y, - z, - ) - .into(); - output + let output: ::bevy_transform::components::Transform = ::bevy_transform::components::Transform::from_xyz( + safe_transmute(x), + safe_transmute(y), + safe_transmute(z), + ); + safe_transmute(output) } }; output @@ -752,10 +712,9 @@ pub(crate) fn register_transform_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_transform::components::Transform::is_finite( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -768,11 +727,10 @@ pub(crate) fn register_transform_functions(world: &mut World) { |_self: Ref<::bevy_transform::components::Transform>| { let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::Transform::left( - &_self, - ) - .into(); - output + let output: ::bevy_math::Dir3 = ::bevy_transform::components::Transform::left( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -785,11 +743,10 @@ pub(crate) fn register_transform_functions(world: &mut World) { |_self: Ref<::bevy_transform::components::Transform>| { let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::Transform::local_x( - &_self, - ) - .into(); - output + let output: ::bevy_math::Dir3 = ::bevy_transform::components::Transform::local_x( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -802,11 +759,10 @@ pub(crate) fn register_transform_functions(world: &mut World) { |_self: Ref<::bevy_transform::components::Transform>| { let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::Transform::local_y( - &_self, - ) - .into(); - output + let output: ::bevy_math::Dir3 = ::bevy_transform::components::Transform::local_y( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -819,11 +775,10 @@ pub(crate) fn register_transform_functions(world: &mut World) { |_self: Ref<::bevy_transform::components::Transform>| { let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::Transform::local_z( - &_self, - ) - .into(); - output + let output: ::bevy_math::Dir3 = ::bevy_transform::components::Transform::local_z( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -835,61 +790,58 @@ pub(crate) fn register_transform_functions(world: &mut World) { "mul", | _self: Val<::bevy_transform::components::Transform>, - global_transform: Val<::bevy_transform::components::GlobalTransform>| + value: Val<::bevy_math::Vec3>| { - let output: Val<::bevy_transform::components::GlobalTransform> = { + let output: Val<::bevy_math::Vec3> = { { - let output: Val<::bevy_transform::components::GlobalTransform> = <::bevy_transform::components::Transform as ::core::ops::Mul< - ::bevy_transform::components::GlobalTransform, - >>::mul(_self.into_inner(), global_transform.into_inner()) - .into(); - output + let output: ::bevy_math::Vec3 = <::bevy_transform::components::Transform as ::core::ops::Mul< + ::bevy_math::Vec3, + >>::mul(safe_transmute(_self), safe_transmute(value)); + safe_transmute(output) } }; output }, "", - &["_self", "global_transform"], + &["_self", "value"], ) .register_documented( "mul", | _self: Val<::bevy_transform::components::Transform>, - transform: Val<::bevy_transform::components::Transform>| + global_transform: Val<::bevy_transform::components::GlobalTransform>| { - let output: Val<::bevy_transform::components::Transform> = { + let output: Val<::bevy_transform::components::GlobalTransform> = { { - let output: Val<::bevy_transform::components::Transform> = <::bevy_transform::components::Transform as ::core::ops::Mul< - ::bevy_transform::components::Transform, - >>::mul(_self.into_inner(), transform.into_inner()) - .into(); - output + let output: ::bevy_transform::components::GlobalTransform = <::bevy_transform::components::Transform as ::core::ops::Mul< + ::bevy_transform::components::GlobalTransform, + >>::mul(safe_transmute(_self), safe_transmute(global_transform)); + safe_transmute(output) } }; output }, "", - &["_self", "transform"], + &["_self", "global_transform"], ) .register_documented( "mul", | _self: Val<::bevy_transform::components::Transform>, - value: Val<::glam::Vec3>| + transform: Val<::bevy_transform::components::Transform>| { - let output: Val<::glam::Vec3> = { + let output: Val<::bevy_transform::components::Transform> = { { - let output: Val<::glam::Vec3> = <::bevy_transform::components::Transform as ::core::ops::Mul< - ::glam::Vec3, - >>::mul(_self.into_inner(), value.into_inner()) - .into(); - output + let output: ::bevy_transform::components::Transform = <::bevy_transform::components::Transform as ::core::ops::Mul< + ::bevy_transform::components::Transform, + >>::mul(safe_transmute(_self), safe_transmute(transform)); + safe_transmute(output) } }; output }, "", - &["_self", "value"], + &["_self", "transform"], ) .register_documented( "mul_transform", @@ -899,12 +851,11 @@ pub(crate) fn register_transform_functions(world: &mut World) { { let output: Val<::bevy_transform::components::Transform> = { { - let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::mul_transform( - &_self, - transform.into_inner(), - ) - .into(); - output + let output: ::bevy_transform::components::Transform = ::bevy_transform::components::Transform::mul_transform( + safe_transmute(_self), + safe_transmute(transform), + ); + safe_transmute(output) } }; output @@ -917,11 +868,10 @@ pub(crate) fn register_transform_functions(world: &mut World) { |_self: Ref<::bevy_transform::components::Transform>| { let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::Transform::right( - &_self, - ) - .into(); - output + let output: ::bevy_math::Dir3 = ::bevy_transform::components::Transform::right( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -933,16 +883,15 @@ pub(crate) fn register_transform_functions(world: &mut World) { "rotate", | mut _self: Mut<::bevy_transform::components::Transform>, - rotation: Val<::glam::Quat>| + rotation: Val<::bevy_math::Quat>| { let output: () = { { let output: () = ::bevy_transform::components::Transform::rotate( - &mut _self, - rotation.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -954,18 +903,17 @@ pub(crate) fn register_transform_functions(world: &mut World) { "rotate_around", | mut _self: Mut<::bevy_transform::components::Transform>, - point: Val<::glam::Vec3>, - rotation: Val<::glam::Quat>| + point: Val<::bevy_math::Vec3>, + rotation: Val<::bevy_math::Quat>| { let output: () = { { let output: () = ::bevy_transform::components::Transform::rotate_around( - &mut _self, - point.into_inner(), - rotation.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(point), + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -983,12 +931,11 @@ pub(crate) fn register_transform_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_transform::components::Transform::rotate_axis( - &mut _self, - axis.into_inner(), - angle, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(axis), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -1000,16 +947,15 @@ pub(crate) fn register_transform_functions(world: &mut World) { "rotate_local", | mut _self: Mut<::bevy_transform::components::Transform>, - rotation: Val<::glam::Quat>| + rotation: Val<::bevy_math::Quat>| { let output: () = { { let output: () = ::bevy_transform::components::Transform::rotate_local( - &mut _self, - rotation.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -1027,12 +973,11 @@ pub(crate) fn register_transform_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_transform::components::Transform::rotate_local_axis( - &mut _self, - axis.into_inner(), - angle, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(axis), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -1046,11 +991,10 @@ pub(crate) fn register_transform_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_transform::components::Transform::rotate_local_x( - &mut _self, - angle, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -1064,11 +1008,10 @@ pub(crate) fn register_transform_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_transform::components::Transform::rotate_local_y( - &mut _self, - angle, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -1082,11 +1025,10 @@ pub(crate) fn register_transform_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_transform::components::Transform::rotate_local_z( - &mut _self, - angle, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -1100,11 +1042,10 @@ pub(crate) fn register_transform_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_transform::components::Transform::rotate_x( - &mut _self, - angle, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -1118,11 +1059,10 @@ pub(crate) fn register_transform_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_transform::components::Transform::rotate_y( - &mut _self, - angle, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -1136,11 +1076,10 @@ pub(crate) fn register_transform_functions(world: &mut World) { let output: () = { { let output: () = ::bevy_transform::components::Transform::rotate_z( - &mut _self, - angle, - ) - .into(); - output + safe_transmute(_self), + safe_transmute(angle), + ); + safe_transmute(output) } }; output @@ -1153,11 +1092,10 @@ pub(crate) fn register_transform_functions(world: &mut World) { |_self: Ref<::bevy_transform::components::Transform>| { let output: Val<::bevy_math::Isometry3d> = { { - let output: Val<::bevy_math::Isometry3d> = ::bevy_transform::components::Transform::to_isometry( - &_self, - ) - .into(); - output + let output: ::bevy_math::Isometry3d = ::bevy_transform::components::Transform::to_isometry( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1168,13 +1106,12 @@ pub(crate) fn register_transform_functions(world: &mut World) { .register_documented( "to_matrix", |_self: Ref<::bevy_transform::components::Transform>| { - let output: Val<::glam::Mat4> = { + let output: Val<::bevy_math::Mat4> = { { - let output: Val<::glam::Mat4> = ::bevy_transform::components::Transform::to_matrix( - &_self, - ) - .into(); - output + let output: ::bevy_math::Mat4 = ::bevy_transform::components::Transform::to_matrix( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1186,16 +1123,15 @@ pub(crate) fn register_transform_functions(world: &mut World) { "transform_point", | _self: Ref<::bevy_transform::components::Transform>, - point: Val<::glam::Vec3>| + point: Val<::bevy_math::Vec3>| { - let output: Val<::glam::Vec3> = { + let output: Val<::bevy_math::Vec3> = { { - let output: Val<::glam::Vec3> = ::bevy_transform::components::Transform::transform_point( - &_self, - point.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Vec3 = ::bevy_transform::components::Transform::transform_point( + safe_transmute(_self), + safe_transmute(point), + ); + safe_transmute(output) } }; output @@ -1207,18 +1143,17 @@ pub(crate) fn register_transform_functions(world: &mut World) { "translate_around", | mut _self: Mut<::bevy_transform::components::Transform>, - point: Val<::glam::Vec3>, - rotation: Val<::glam::Quat>| + point: Val<::bevy_math::Vec3>, + rotation: Val<::bevy_math::Quat>| { let output: () = { { let output: () = ::bevy_transform::components::Transform::translate_around( - &mut _self, - point.into_inner(), - rotation.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(point), + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -1231,11 +1166,10 @@ pub(crate) fn register_transform_functions(world: &mut World) { |_self: Ref<::bevy_transform::components::Transform>| { let output: Val<::bevy_math::Dir3> = { { - let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::Transform::up( - &_self, - ) - .into(); - output + let output: ::bevy_math::Dir3 = ::bevy_transform::components::Transform::up( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1247,16 +1181,15 @@ pub(crate) fn register_transform_functions(world: &mut World) { "with_rotation", | _self: Val<::bevy_transform::components::Transform>, - rotation: Val<::glam::Quat>| + rotation: Val<::bevy_math::Quat>| { let output: Val<::bevy_transform::components::Transform> = { { - let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::with_rotation( - _self.into_inner(), - rotation.into_inner(), - ) - .into(); - output + let output: ::bevy_transform::components::Transform = ::bevy_transform::components::Transform::with_rotation( + safe_transmute(_self), + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -1268,16 +1201,15 @@ pub(crate) fn register_transform_functions(world: &mut World) { "with_scale", | _self: Val<::bevy_transform::components::Transform>, - scale: Val<::glam::Vec3>| + scale: Val<::bevy_math::Vec3>| { let output: Val<::bevy_transform::components::Transform> = { { - let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::with_scale( - _self.into_inner(), - scale.into_inner(), - ) - .into(); - output + let output: ::bevy_transform::components::Transform = ::bevy_transform::components::Transform::with_scale( + safe_transmute(_self), + safe_transmute(scale), + ); + safe_transmute(output) } }; output @@ -1289,16 +1221,15 @@ pub(crate) fn register_transform_functions(world: &mut World) { "with_translation", | _self: Val<::bevy_transform::components::Transform>, - translation: Val<::glam::Vec3>| + translation: Val<::bevy_math::Vec3>| { let output: Val<::bevy_transform::components::Transform> = { { - let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::with_translation( - _self.into_inner(), - translation.into_inner(), - ) - .into(); - output + let output: ::bevy_transform::components::Transform = ::bevy_transform::components::Transform::with_translation( + safe_transmute(_self), + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -1323,13 +1254,10 @@ pub(crate) fn register_transform_tree_changed_functions(world: &mut World) { |_self: Ref<::bevy_transform::components::TransformTreeChanged>| { let output: Val<::bevy_transform::components::TransformTreeChanged> = { { - let output: Val< - ::bevy_transform::components::TransformTreeChanged, - > = <::bevy_transform::components::TransformTreeChanged as ::core::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_transform::components::TransformTreeChanged = <::bevy_transform::components::TransformTreeChanged as ::core::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1347,9 +1275,8 @@ pub(crate) fn register_transform_tree_changed_functions(world: &mut World) { { let output: bool = <::bevy_transform::components::TransformTreeChanged as ::core::cmp::PartialEq< ::bevy_transform::components::TransformTreeChanged, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_ui_bms_bindings/src/lib.rs b/crates/bindings/bevy_ui_bms_bindings/src/lib.rs index 519a6de1d3..44e199fb8a 100644 --- a/crates/bindings/bevy_ui_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_ui_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -25,10 +25,9 @@ pub(crate) fn register_display_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui::Display as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41,11 +40,10 @@ pub(crate) fn register_display_functions(world: &mut World) { |_self: Ref<::bevy_ui::Display>| { let output: Val<::bevy_ui::Display> = { { - let output: Val<::bevy_ui::Display> = <::bevy_ui::Display as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::Display = <::bevy_ui::Display as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -60,9 +58,8 @@ pub(crate) fn register_display_functions(world: &mut World) { { let output: bool = <::bevy_ui::Display as ::std::cmp::PartialEq< ::bevy_ui::Display, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -87,11 +84,10 @@ pub(crate) fn register_ui_picking_camera_functions(world: &mut World) { |_self: Ref<::bevy_ui::picking_backend::UiPickingCamera>| { let output: Val<::bevy_ui::picking_backend::UiPickingCamera> = { { - let output: Val<::bevy_ui::picking_backend::UiPickingCamera> = <::bevy_ui::picking_backend::UiPickingCamera as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::picking_backend::UiPickingCamera = <::bevy_ui::picking_backend::UiPickingCamera as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -128,11 +124,10 @@ pub(crate) fn register_text_functions(world: &mut World) { |_self: Ref<::bevy_ui::widget::Text>| { let output: Val<::bevy_ui::widget::Text> = { { - let output: Val<::bevy_ui::widget::Text> = <::bevy_ui::widget::Text as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::widget::Text = <::bevy_ui::widget::Text as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -147,9 +142,8 @@ pub(crate) fn register_text_functions(world: &mut World) { { let output: bool = <::bevy_ui::widget::Text as ::std::cmp::PartialEq< ::bevy_ui::widget::Text, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -174,11 +168,10 @@ pub(crate) fn register_text_shadow_functions(world: &mut World) { |_self: Ref<::bevy_ui::widget::TextShadow>| { let output: Val<::bevy_ui::widget::TextShadow> = { { - let output: Val<::bevy_ui::widget::TextShadow> = <::bevy_ui::widget::TextShadow as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::widget::TextShadow = <::bevy_ui::widget::TextShadow as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -196,9 +189,8 @@ pub(crate) fn register_text_shadow_functions(world: &mut World) { { let output: bool = <::bevy_ui::widget::TextShadow as ::std::cmp::PartialEq< ::bevy_ui::widget::TextShadow, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -224,10 +216,9 @@ pub(crate) fn register_button_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui::widget::Button as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -240,11 +231,10 @@ pub(crate) fn register_button_functions(world: &mut World) { |_self: Ref<::bevy_ui::widget::Button>| { let output: Val<::bevy_ui::widget::Button> = { { - let output: Val<::bevy_ui::widget::Button> = <::bevy_ui::widget::Button as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::widget::Button = <::bevy_ui::widget::Button as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -262,9 +252,8 @@ pub(crate) fn register_button_functions(world: &mut World) { { let output: bool = <::bevy_ui::widget::Button as ::std::cmp::PartialEq< ::bevy_ui::widget::Button, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -289,11 +278,10 @@ pub(crate) fn register_image_node_functions(world: &mut World) { |_self: Ref<::bevy_ui::widget::ImageNode>| { let output: Val<::bevy_ui::widget::ImageNode> = { { - let output: Val<::bevy_ui::widget::ImageNode> = <::bevy_ui::widget::ImageNode as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::widget::ImageNode = <::bevy_ui::widget::ImageNode as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -306,11 +294,10 @@ pub(crate) fn register_image_node_functions(world: &mut World) { |color: Val<::bevy_color::Color>| { let output: Val<::bevy_ui::widget::ImageNode> = { { - let output: Val<::bevy_ui::widget::ImageNode> = ::bevy_ui::widget::ImageNode::solid_color( - color.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::widget::ImageNode = ::bevy_ui::widget::ImageNode::solid_color( + safe_transmute(color), + ); + safe_transmute(output) } }; output @@ -323,12 +310,11 @@ pub(crate) fn register_image_node_functions(world: &mut World) { |_self: Val<::bevy_ui::widget::ImageNode>, color: Val<::bevy_color::Color>| { let output: Val<::bevy_ui::widget::ImageNode> = { { - let output: Val<::bevy_ui::widget::ImageNode> = ::bevy_ui::widget::ImageNode::with_color( - _self.into_inner(), - color.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::widget::ImageNode = ::bevy_ui::widget::ImageNode::with_color( + safe_transmute(_self), + safe_transmute(color), + ); + safe_transmute(output) } }; output @@ -341,11 +327,10 @@ pub(crate) fn register_image_node_functions(world: &mut World) { |_self: Val<::bevy_ui::widget::ImageNode>| { let output: Val<::bevy_ui::widget::ImageNode> = { { - let output: Val<::bevy_ui::widget::ImageNode> = ::bevy_ui::widget::ImageNode::with_flip_x( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::widget::ImageNode = ::bevy_ui::widget::ImageNode::with_flip_x( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -358,11 +343,10 @@ pub(crate) fn register_image_node_functions(world: &mut World) { |_self: Val<::bevy_ui::widget::ImageNode>| { let output: Val<::bevy_ui::widget::ImageNode> = { { - let output: Val<::bevy_ui::widget::ImageNode> = ::bevy_ui::widget::ImageNode::with_flip_y( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::widget::ImageNode = ::bevy_ui::widget::ImageNode::with_flip_y( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -378,12 +362,11 @@ pub(crate) fn register_image_node_functions(world: &mut World) { { let output: Val<::bevy_ui::widget::ImageNode> = { { - let output: Val<::bevy_ui::widget::ImageNode> = ::bevy_ui::widget::ImageNode::with_mode( - _self.into_inner(), - mode.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::widget::ImageNode = ::bevy_ui::widget::ImageNode::with_mode( + safe_transmute(_self), + safe_transmute(mode), + ); + safe_transmute(output) } }; output @@ -396,12 +379,11 @@ pub(crate) fn register_image_node_functions(world: &mut World) { |_self: Val<::bevy_ui::widget::ImageNode>, rect: Val<::bevy_math::Rect>| { let output: Val<::bevy_ui::widget::ImageNode> = { { - let output: Val<::bevy_ui::widget::ImageNode> = ::bevy_ui::widget::ImageNode::with_rect( - _self.into_inner(), - rect.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::widget::ImageNode = ::bevy_ui::widget::ImageNode::with_rect( + safe_transmute(_self), + safe_transmute(rect), + ); + safe_transmute(output) } }; output @@ -426,11 +408,10 @@ pub(crate) fn register_label_functions(world: &mut World) { |_self: Ref<::bevy_ui::widget::Label>| { let output: Val<::bevy_ui::widget::Label> = { { - let output: Val<::bevy_ui::widget::Label> = <::bevy_ui::widget::Label as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::widget::Label = <::bevy_ui::widget::Label as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -455,11 +436,10 @@ pub(crate) fn register_node_image_mode_functions(world: &mut World) { |_self: Ref<::bevy_ui::widget::NodeImageMode>| { let output: Val<::bevy_ui::widget::NodeImageMode> = { { - let output: Val<::bevy_ui::widget::NodeImageMode> = <::bevy_ui::widget::NodeImageMode as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::widget::NodeImageMode = <::bevy_ui::widget::NodeImageMode as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -477,9 +457,8 @@ pub(crate) fn register_node_image_mode_functions(world: &mut World) { { let output: bool = <::bevy_ui::widget::NodeImageMode as ::std::cmp::PartialEq< ::bevy_ui::widget::NodeImageMode, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -493,10 +472,9 @@ pub(crate) fn register_node_image_mode_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_ui::widget::NodeImageMode::uses_slices( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -521,11 +499,10 @@ pub(crate) fn register_viewport_node_functions(world: &mut World) { |_self: Ref<::bevy_ui::widget::ViewportNode>| { let output: Val<::bevy_ui::widget::ViewportNode> = { { - let output: Val<::bevy_ui::widget::ViewportNode> = <::bevy_ui::widget::ViewportNode as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::widget::ViewportNode = <::bevy_ui::widget::ViewportNode as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -538,11 +515,10 @@ pub(crate) fn register_viewport_node_functions(world: &mut World) { |camera: Val<::bevy_ecs::entity::Entity>| { let output: Val<::bevy_ui::widget::ViewportNode> = { { - let output: Val<::bevy_ui::widget::ViewportNode> = ::bevy_ui::widget::ViewportNode::new( - camera.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::widget::ViewportNode = ::bevy_ui::widget::ViewportNode::new( + safe_transmute(camera), + ); + safe_transmute(output) } }; output @@ -568,10 +544,9 @@ pub(crate) fn register_interaction_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui::Interaction as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -584,11 +559,10 @@ pub(crate) fn register_interaction_functions(world: &mut World) { |_self: Ref<::bevy_ui::Interaction>| { let output: Val<::bevy_ui::Interaction> = { { - let output: Val<::bevy_ui::Interaction> = <::bevy_ui::Interaction as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::Interaction = <::bevy_ui::Interaction as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -603,9 +577,8 @@ pub(crate) fn register_interaction_functions(world: &mut World) { { let output: bool = <::bevy_ui::Interaction as ::std::cmp::PartialEq< ::bevy_ui::Interaction, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -642,11 +615,10 @@ pub(crate) fn register_computed_ui_target_camera_functions(world: &mut World) { |_self: Ref<::bevy_ui::ComputedUiTargetCamera>| { let output: Val<::bevy_ui::ComputedUiTargetCamera> = { { - let output: Val<::bevy_ui::ComputedUiTargetCamera> = <::bevy_ui::ComputedUiTargetCamera as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::ComputedUiTargetCamera = <::bevy_ui::ComputedUiTargetCamera as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -664,9 +636,8 @@ pub(crate) fn register_computed_ui_target_camera_functions(world: &mut World) { { let output: bool = <::bevy_ui::ComputedUiTargetCamera as ::std::cmp::PartialEq< ::bevy_ui::ComputedUiTargetCamera, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -691,11 +662,10 @@ pub(crate) fn register_computed_ui_render_target_info_functions(world: &mut Worl |_self: Ref<::bevy_ui::ComputedUiRenderTargetInfo>| { let output: Val<::bevy_ui::ComputedUiRenderTargetInfo> = { { - let output: Val<::bevy_ui::ComputedUiRenderTargetInfo> = <::bevy_ui::ComputedUiRenderTargetInfo as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::ComputedUiRenderTargetInfo = <::bevy_ui::ComputedUiRenderTargetInfo as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -713,9 +683,8 @@ pub(crate) fn register_computed_ui_render_target_info_functions(world: &mut Worl { let output: bool = <::bevy_ui::ComputedUiRenderTargetInfo as ::std::cmp::PartialEq< ::bevy_ui::ComputedUiRenderTargetInfo, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -726,13 +695,12 @@ pub(crate) fn register_computed_ui_render_target_info_functions(world: &mut Worl .register_documented( "logical_size", |_self: Ref<::bevy_ui::ComputedUiRenderTargetInfo>| { - let output: Val<::glam::Vec2> = { + let output: Val<::bevy_math::Vec2> = { { - let output: Val<::glam::Vec2> = ::bevy_ui::ComputedUiRenderTargetInfo::logical_size( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_ui::ComputedUiRenderTargetInfo::logical_size( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -743,13 +711,12 @@ pub(crate) fn register_computed_ui_render_target_info_functions(world: &mut Worl .register_documented( "physical_size", |_self: Ref<::bevy_ui::ComputedUiRenderTargetInfo>| { - let output: Val<::glam::UVec2> = { + let output: Val<::bevy_math::UVec2> = { { - let output: Val<::glam::UVec2> = ::bevy_ui::ComputedUiRenderTargetInfo::physical_size( - &_self, - ) - .into(); - output + let output: ::bevy_math::UVec2 = ::bevy_ui::ComputedUiRenderTargetInfo::physical_size( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -763,10 +730,9 @@ pub(crate) fn register_computed_ui_render_target_info_functions(world: &mut Worl let output: f32 = { { let output: f32 = ::bevy_ui::ComputedUiRenderTargetInfo::scale_factor( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -788,14 +754,13 @@ pub(crate) fn register_content_size_functions(world: &mut World) { >::new(world) .register_documented( "fixed_size", - |size: Val<::glam::Vec2>| { + |size: Val<::bevy_math::Vec2>| { let output: Val<::bevy_ui::ContentSize> = { { - let output: Val<::bevy_ui::ContentSize> = ::bevy_ui::ContentSize::fixed_size( - size.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::ContentSize = ::bevy_ui::ContentSize::fixed_size( + safe_transmute(size), + ); + safe_transmute(output) } }; output @@ -820,11 +785,10 @@ pub(crate) fn register_ui_global_transform_functions(world: &mut World) { |_self: Ref<::bevy_ui::UiGlobalTransform>| { let output: Val<::bevy_ui::UiGlobalTransform> = { { - let output: Val<::bevy_ui::UiGlobalTransform> = <::bevy_ui::UiGlobalTransform as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::UiGlobalTransform = <::bevy_ui::UiGlobalTransform as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -842,9 +806,8 @@ pub(crate) fn register_ui_global_transform_functions(world: &mut World) { { let output: bool = <::bevy_ui::UiGlobalTransform as ::std::cmp::PartialEq< ::bevy_ui::UiGlobalTransform, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -869,11 +832,10 @@ pub(crate) fn register_calculated_clip_functions(world: &mut World) { |_self: Ref<::bevy_ui::CalculatedClip>| { let output: Val<::bevy_ui::CalculatedClip> = { { - let output: Val<::bevy_ui::CalculatedClip> = <::bevy_ui::CalculatedClip as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::CalculatedClip = <::bevy_ui::CalculatedClip as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -898,11 +860,10 @@ pub(crate) fn register_node_functions(world: &mut World) { |_self: Ref<::bevy_ui::Node>| { let output: Val<::bevy_ui::Node> = { { - let output: Val<::bevy_ui::Node> = <::bevy_ui::Node as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::Node = <::bevy_ui::Node as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -917,9 +878,8 @@ pub(crate) fn register_node_functions(world: &mut World) { { let output: bool = <::bevy_ui::Node as ::std::cmp::PartialEq< ::bevy_ui::Node, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -945,10 +905,9 @@ pub(crate) fn register_overflow_axis_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui::OverflowAxis as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -961,11 +920,10 @@ pub(crate) fn register_overflow_axis_functions(world: &mut World) { |_self: Ref<::bevy_ui::OverflowAxis>| { let output: Val<::bevy_ui::OverflowAxis> = { { - let output: Val<::bevy_ui::OverflowAxis> = <::bevy_ui::OverflowAxis as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::OverflowAxis = <::bevy_ui::OverflowAxis as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -980,9 +938,8 @@ pub(crate) fn register_overflow_axis_functions(world: &mut World) { { let output: bool = <::bevy_ui::OverflowAxis as ::std::cmp::PartialEq< ::bevy_ui::OverflowAxis, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -995,9 +952,10 @@ pub(crate) fn register_overflow_axis_functions(world: &mut World) { |_self: Ref<::bevy_ui::OverflowAxis>| { let output: bool = { { - let output: bool = ::bevy_ui::OverflowAxis::is_visible(&_self) - .into(); - output + let output: bool = ::bevy_ui::OverflowAxis::is_visible( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1023,10 +981,9 @@ pub(crate) fn register_ui_target_camera_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui::UiTargetCamera as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1039,11 +996,10 @@ pub(crate) fn register_ui_target_camera_functions(world: &mut World) { |_self: Ref<::bevy_ui::UiTargetCamera>| { let output: Val<::bevy_ui::UiTargetCamera> = { { - let output: Val<::bevy_ui::UiTargetCamera> = <::bevy_ui::UiTargetCamera as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::UiTargetCamera = <::bevy_ui::UiTargetCamera as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1056,11 +1012,10 @@ pub(crate) fn register_ui_target_camera_functions(world: &mut World) { |_self: Ref<::bevy_ui::UiTargetCamera>| { let output: Val<::bevy_ecs::entity::Entity> = { { - let output: Val<::bevy_ecs::entity::Entity> = ::bevy_ui::UiTargetCamera::entity( - &_self, - ) - .into(); - output + let output: ::bevy_ecs::entity::Entity = ::bevy_ui::UiTargetCamera::entity( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1078,9 +1033,8 @@ pub(crate) fn register_ui_target_camera_functions(world: &mut World) { { let output: bool = <::bevy_ui::UiTargetCamera as ::std::cmp::PartialEq< ::bevy_ui::UiTargetCamera, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1103,13 +1057,12 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { .register_documented( "border", |_self: Ref<::bevy_ui::ComputedNode>| { - let output: Val<::bevy_sprite::BorderRect> = { + let output: Val<::bevy_ui::prelude::BorderRect> = { { - let output: Val<::bevy_sprite::BorderRect> = ::bevy_ui::ComputedNode::border( - &_self, - ) - .into(); - output + let output: ::bevy_ui::prelude::BorderRect = ::bevy_ui::ComputedNode::border( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1122,11 +1075,10 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { |_self: Ref<::bevy_ui::ComputedNode>| { let output: Val<::bevy_ui::ResolvedBorderRadius> = { { - let output: Val<::bevy_ui::ResolvedBorderRadius> = ::bevy_ui::ComputedNode::border_radius( - &_self, - ) - .into(); - output + let output: ::bevy_ui::ResolvedBorderRadius = ::bevy_ui::ComputedNode::border_radius( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1139,11 +1091,10 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { |_self: Ref<::bevy_ui::ComputedNode>| { let output: Val<::bevy_ui::ComputedNode> = { { - let output: Val<::bevy_ui::ComputedNode> = <::bevy_ui::ComputedNode as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::ComputedNode = <::bevy_ui::ComputedNode as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1156,17 +1107,16 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { | _self: Ref<::bevy_ui::ComputedNode>, transform: Val<::bevy_ui::UiGlobalTransform>, - point: Val<::glam::Vec2>| + point: Val<::bevy_math::Vec2>| { let output: bool = { { let output: bool = ::bevy_ui::ComputedNode::contains_point( - &_self, - transform.into_inner(), - point.into_inner(), - ) - .into(); - output + safe_transmute(_self), + safe_transmute(transform), + safe_transmute(point), + ); + safe_transmute(output) } }; output @@ -1177,13 +1127,12 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { .register_documented( "content_inset", |_self: Ref<::bevy_ui::ComputedNode>| { - let output: Val<::bevy_sprite::BorderRect> = { + let output: Val<::bevy_ui::prelude::BorderRect> = { { - let output: Val<::bevy_sprite::BorderRect> = ::bevy_ui::ComputedNode::content_inset( - &_self, - ) - .into(); - output + let output: ::bevy_ui::prelude::BorderRect = ::bevy_ui::ComputedNode::content_inset( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1194,13 +1143,12 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { .register_documented( "content_size", |_self: Ref<::bevy_ui::ComputedNode>| { - let output: Val<::glam::Vec2> = { + let output: Val<::bevy_math::Vec2> = { { - let output: Val<::glam::Vec2> = ::bevy_ui::ComputedNode::content_size( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_ui::ComputedNode::content_size( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1215,9 +1163,8 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { { let output: bool = <::bevy_ui::ComputedNode as ::std::cmp::PartialEq< ::bevy_ui::ComputedNode, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1230,11 +1177,10 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { |_self: Ref<::bevy_ui::ComputedNode>| { let output: Val<::bevy_ui::ResolvedBorderRadius> = { { - let output: Val<::bevy_ui::ResolvedBorderRadius> = ::bevy_ui::ComputedNode::inner_radius( - &_self, - ) - .into(); - output + let output: ::bevy_ui::ResolvedBorderRadius = ::bevy_ui::ComputedNode::inner_radius( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1248,10 +1194,9 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { let output: f32 = { { let output: f32 = ::bevy_ui::ComputedNode::inverse_scale_factor( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1264,9 +1209,10 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { |_self: Ref<::bevy_ui::ComputedNode>| { let output: bool = { { - let output: bool = ::bevy_ui::ComputedNode::is_empty(&_self) - .into(); - output + let output: bool = ::bevy_ui::ComputedNode::is_empty( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1279,9 +1225,10 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { |_self: Ref<::bevy_ui::ComputedNode>| { let output: f32 = { { - let output: f32 = ::bevy_ui::ComputedNode::outline_offset(&_self) - .into(); - output + let output: f32 = ::bevy_ui::ComputedNode::outline_offset( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1294,11 +1241,10 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { |_self: Ref<::bevy_ui::ComputedNode>| { let output: Val<::bevy_ui::ResolvedBorderRadius> = { { - let output: Val<::bevy_ui::ResolvedBorderRadius> = ::bevy_ui::ComputedNode::outline_radius( - &_self, - ) - .into(); - output + let output: ::bevy_ui::ResolvedBorderRadius = ::bevy_ui::ComputedNode::outline_radius( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1311,9 +1257,10 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { |_self: Ref<::bevy_ui::ComputedNode>| { let output: f32 = { { - let output: f32 = ::bevy_ui::ComputedNode::outline_width(&_self) - .into(); - output + let output: f32 = ::bevy_ui::ComputedNode::outline_width( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1324,13 +1271,12 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { .register_documented( "outlined_node_size", |_self: Ref<::bevy_ui::ComputedNode>| { - let output: Val<::glam::Vec2> = { + let output: Val<::bevy_math::Vec2> = { { - let output: Val<::glam::Vec2> = ::bevy_ui::ComputedNode::outlined_node_size( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_ui::ComputedNode::outlined_node_size( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1341,13 +1287,12 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { .register_documented( "padding", |_self: Ref<::bevy_ui::ComputedNode>| { - let output: Val<::bevy_sprite::BorderRect> = { + let output: Val<::bevy_ui::prelude::BorderRect> = { { - let output: Val<::bevy_sprite::BorderRect> = ::bevy_ui::ComputedNode::padding( - &_self, - ) - .into(); - output + let output: ::bevy_ui::prelude::BorderRect = ::bevy_ui::ComputedNode::padding( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1364,13 +1309,12 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { { let output: Val<::bevy_math::Rect> = { { - let output: Val<::bevy_math::Rect> = ::bevy_ui::ComputedNode::resolve_clip_rect( - &_self, - overflow.into_inner(), - overflow_clip_margin.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Rect = ::bevy_ui::ComputedNode::resolve_clip_rect( + safe_transmute(_self), + safe_transmute(overflow), + safe_transmute(overflow_clip_margin), + ); + safe_transmute(output) } }; output @@ -1381,13 +1325,12 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { .register_documented( "size", |_self: Ref<::bevy_ui::ComputedNode>| { - let output: Val<::glam::Vec2> = { + let output: Val<::bevy_math::Vec2> = { { - let output: Val<::glam::Vec2> = ::bevy_ui::ComputedNode::size( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_ui::ComputedNode::size( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1400,9 +1343,10 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { |_self: Ref<::bevy_ui::ComputedNode>| { let output: u32 = { { - let output: u32 = ::bevy_ui::ComputedNode::stack_index(&_self) - .into(); - output + let output: u32 = ::bevy_ui::ComputedNode::stack_index( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1413,13 +1357,12 @@ pub(crate) fn register_computed_node_functions(world: &mut World) { .register_documented( "unrounded_size", |_self: Ref<::bevy_ui::ComputedNode>| { - let output: Val<::glam::Vec2> = { + let output: Val<::bevy_math::Vec2> = { { - let output: Val<::glam::Vec2> = ::bevy_ui::ComputedNode::unrounded_size( - &_self, - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_ui::ComputedNode::unrounded_size( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1445,10 +1388,9 @@ pub(crate) fn register_overflow_clip_box_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui::OverflowClipBox as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1461,11 +1403,10 @@ pub(crate) fn register_overflow_clip_box_functions(world: &mut World) { |_self: Ref<::bevy_ui::OverflowClipBox>| { let output: Val<::bevy_ui::OverflowClipBox> = { { - let output: Val<::bevy_ui::OverflowClipBox> = <::bevy_ui::OverflowClipBox as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::OverflowClipBox = <::bevy_ui::OverflowClipBox as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1483,9 +1424,8 @@ pub(crate) fn register_overflow_clip_box_functions(world: &mut World) { { let output: bool = <::bevy_ui::OverflowClipBox as ::std::cmp::PartialEq< ::bevy_ui::OverflowClipBox, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1511,10 +1451,9 @@ pub(crate) fn register_focus_policy_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui::FocusPolicy as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1527,11 +1466,10 @@ pub(crate) fn register_focus_policy_functions(world: &mut World) { |_self: Ref<::bevy_ui::FocusPolicy>| { let output: Val<::bevy_ui::FocusPolicy> = { { - let output: Val<::bevy_ui::FocusPolicy> = <::bevy_ui::FocusPolicy as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::FocusPolicy = <::bevy_ui::FocusPolicy as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1546,9 +1484,8 @@ pub(crate) fn register_focus_policy_functions(world: &mut World) { { let output: bool = <::bevy_ui::FocusPolicy as ::std::cmp::PartialEq< ::bevy_ui::FocusPolicy, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1573,11 +1510,10 @@ pub(crate) fn register_image_node_size_functions(world: &mut World) { |_self: Ref<::bevy_ui::widget::ImageNodeSize>| { let output: Val<::bevy_ui::widget::ImageNodeSize> = { { - let output: Val<::bevy_ui::widget::ImageNodeSize> = <::bevy_ui::widget::ImageNodeSize as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::widget::ImageNodeSize = <::bevy_ui::widget::ImageNodeSize as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1588,13 +1524,12 @@ pub(crate) fn register_image_node_size_functions(world: &mut World) { .register_documented( "size", |_self: Ref<::bevy_ui::widget::ImageNodeSize>| { - let output: Val<::glam::UVec2> = { + let output: Val<::bevy_math::UVec2> = { { - let output: Val<::glam::UVec2> = ::bevy_ui::widget::ImageNodeSize::size( - &_self, - ) - .into(); - output + let output: ::bevy_math::UVec2 = ::bevy_ui::widget::ImageNodeSize::size( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1619,11 +1554,10 @@ pub(crate) fn register_text_node_flags_functions(world: &mut World) { |_self: Ref<::bevy_ui::widget::TextNodeFlags>| { let output: Val<::bevy_ui::widget::TextNodeFlags> = { { - let output: Val<::bevy_ui::widget::TextNodeFlags> = <::bevy_ui::widget::TextNodeFlags as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::widget::TextNodeFlags = <::bevy_ui::widget::TextNodeFlags as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1645,14 +1579,13 @@ pub(crate) fn register_ui_position_functions(world: &mut World) { >::new(world) .register_documented( "anchor", - |anchor: Val<::glam::Vec2>| { + |anchor: Val<::bevy_math::Vec2>| { let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::anchor( - anchor.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiPosition = ::bevy_ui::UiPosition::anchor( + safe_transmute(anchor), + ); + safe_transmute(output) } }; output @@ -1669,13 +1602,12 @@ pub(crate) fn register_ui_position_functions(world: &mut World) { { let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::at( - _self.into_inner(), - x.into_inner(), - y.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiPosition = ::bevy_ui::UiPosition::at( + safe_transmute(_self), + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -1688,13 +1620,12 @@ pub(crate) fn register_ui_position_functions(world: &mut World) { |_self: Val<::bevy_ui::UiPosition>, x: f32, y: f32| { let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::at_percent( - _self.into_inner(), - x, - y, - ) - .into(); - output + let output: ::bevy_ui::UiPosition = ::bevy_ui::UiPosition::at_percent( + safe_transmute(_self), + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -1707,13 +1638,12 @@ pub(crate) fn register_ui_position_functions(world: &mut World) { |_self: Val<::bevy_ui::UiPosition>, x: f32, y: f32| { let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::at_px( - _self.into_inner(), - x, - y, - ) - .into(); - output + let output: ::bevy_ui::UiPosition = ::bevy_ui::UiPosition::at_px( + safe_transmute(_self), + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -1726,12 +1656,11 @@ pub(crate) fn register_ui_position_functions(world: &mut World) { |_self: Val<::bevy_ui::UiPosition>, x: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::at_x( - _self.into_inner(), - x.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiPosition = ::bevy_ui::UiPosition::at_x( + safe_transmute(_self), + safe_transmute(x), + ); + safe_transmute(output) } }; output @@ -1744,12 +1673,11 @@ pub(crate) fn register_ui_position_functions(world: &mut World) { |_self: Val<::bevy_ui::UiPosition>, y: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::at_y( - _self.into_inner(), - y.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiPosition = ::bevy_ui::UiPosition::at_y( + safe_transmute(_self), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -1762,12 +1690,11 @@ pub(crate) fn register_ui_position_functions(world: &mut World) { |x: Val<::bevy_ui::Val>, y: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::bottom( - x.into_inner(), - y.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiPosition = ::bevy_ui::UiPosition::bottom( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -1780,12 +1707,11 @@ pub(crate) fn register_ui_position_functions(world: &mut World) { |x: Val<::bevy_ui::Val>, y: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::bottom_left( - x.into_inner(), - y.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiPosition = ::bevy_ui::UiPosition::bottom_left( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -1798,12 +1724,11 @@ pub(crate) fn register_ui_position_functions(world: &mut World) { |x: Val<::bevy_ui::Val>, y: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::bottom_right( - x.into_inner(), - y.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiPosition = ::bevy_ui::UiPosition::bottom_right( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -1816,12 +1741,11 @@ pub(crate) fn register_ui_position_functions(world: &mut World) { |x: Val<::bevy_ui::Val>, y: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::center( - x.into_inner(), - y.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiPosition = ::bevy_ui::UiPosition::center( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -1834,11 +1758,10 @@ pub(crate) fn register_ui_position_functions(world: &mut World) { |_self: Ref<::bevy_ui::UiPosition>| { let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::UiPosition> = <::bevy_ui::UiPosition as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::UiPosition = <::bevy_ui::UiPosition as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -1853,9 +1776,8 @@ pub(crate) fn register_ui_position_functions(world: &mut World) { { let output: bool = <::bevy_ui::UiPosition as ::std::cmp::PartialEq< ::bevy_ui::UiPosition, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -1868,12 +1790,11 @@ pub(crate) fn register_ui_position_functions(world: &mut World) { |x: Val<::bevy_ui::Val>, y: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::left( - x.into_inner(), - y.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiPosition = ::bevy_ui::UiPosition::left( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -1883,16 +1804,19 @@ pub(crate) fn register_ui_position_functions(world: &mut World) { ) .register_documented( "new", - |anchor: Val<::glam::Vec2>, x: Val<::bevy_ui::Val>, y: Val<::bevy_ui::Val>| { + | + anchor: Val<::bevy_math::Vec2>, + x: Val<::bevy_ui::Val>, + y: Val<::bevy_ui::Val>| + { let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::new( - anchor.into_inner(), - x.into_inner(), - y.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiPosition = ::bevy_ui::UiPosition::new( + safe_transmute(anchor), + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -1905,19 +1829,18 @@ pub(crate) fn register_ui_position_functions(world: &mut World) { | _self: Val<::bevy_ui::UiPosition>, scale_factor: f32, - physical_size: Val<::glam::Vec2>, - physical_target_size: Val<::glam::Vec2>| + physical_size: Val<::bevy_math::Vec2>, + physical_target_size: Val<::bevy_math::Vec2>| { - let output: Val<::glam::Vec2> = { + let output: Val<::bevy_math::Vec2> = { { - let output: Val<::glam::Vec2> = ::bevy_ui::UiPosition::resolve( - _self.into_inner(), - scale_factor, - physical_size.into_inner(), - physical_target_size.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_ui::UiPosition::resolve( + safe_transmute(_self), + safe_transmute(scale_factor), + safe_transmute(physical_size), + safe_transmute(physical_target_size), + ); + safe_transmute(output) } }; output @@ -1930,12 +1853,11 @@ pub(crate) fn register_ui_position_functions(world: &mut World) { |x: Val<::bevy_ui::Val>, y: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::right( - x.into_inner(), - y.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiPosition = ::bevy_ui::UiPosition::right( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -1948,12 +1870,11 @@ pub(crate) fn register_ui_position_functions(world: &mut World) { |x: Val<::bevy_ui::Val>, y: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::top( - x.into_inner(), - y.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiPosition = ::bevy_ui::UiPosition::top( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -1966,12 +1887,11 @@ pub(crate) fn register_ui_position_functions(world: &mut World) { |x: Val<::bevy_ui::Val>, y: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::top_left( - x.into_inner(), - y.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiPosition = ::bevy_ui::UiPosition::top_left( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -1984,12 +1904,11 @@ pub(crate) fn register_ui_position_functions(world: &mut World) { |x: Val<::bevy_ui::Val>, y: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::top_right( - x.into_inner(), - y.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiPosition = ::bevy_ui::UiPosition::top_right( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -1999,15 +1918,14 @@ pub(crate) fn register_ui_position_functions(world: &mut World) { ) .register_documented( "with_anchor", - |_self: Val<::bevy_ui::UiPosition>, anchor: Val<::glam::Vec2>| { + |_self: Val<::bevy_ui::UiPosition>, anchor: Val<::bevy_math::Vec2>| { let output: Val<::bevy_ui::UiPosition> = { { - let output: Val<::bevy_ui::UiPosition> = ::bevy_ui::UiPosition::with_anchor( - _self.into_inner(), - anchor.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiPosition = ::bevy_ui::UiPosition::with_anchor( + safe_transmute(_self), + safe_transmute(anchor), + ); + safe_transmute(output) } }; output @@ -2032,11 +1950,10 @@ pub(crate) fn register_val_functions(world: &mut World) { |_self: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::UiRect> = ::bevy_ui::Val::all( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiRect = ::bevy_ui::Val::all( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2049,11 +1966,10 @@ pub(crate) fn register_val_functions(world: &mut World) { |_self: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::UiRect> = ::bevy_ui::Val::bottom( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiRect = ::bevy_ui::Val::bottom( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2066,11 +1982,10 @@ pub(crate) fn register_val_functions(world: &mut World) { |_self: Ref<::bevy_ui::Val>| { let output: Val<::bevy_ui::Val> = { { - let output: Val<::bevy_ui::Val> = <::bevy_ui::Val as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::Val = <::bevy_ui::Val as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2083,11 +1998,10 @@ pub(crate) fn register_val_functions(world: &mut World) { |_self: Val<::bevy_ui::Val>, rhs: f32| { let output: Val<::bevy_ui::Val> = { { - let output: Val<::bevy_ui::Val> = <::bevy_ui::Val as ::std::ops::Div< + let output: ::bevy_ui::Val = <::bevy_ui::Val as ::std::ops::Div< f32, - >>::div(_self.into_inner(), rhs) - .into(); - output + >>::div(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -2102,9 +2016,8 @@ pub(crate) fn register_val_functions(world: &mut World) { { let output: bool = <::bevy_ui::Val as ::std::cmp::PartialEq< ::bevy_ui::Val, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2117,11 +2030,10 @@ pub(crate) fn register_val_functions(world: &mut World) { |_self: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::UiRect> = ::bevy_ui::Val::horizontal( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiRect = ::bevy_ui::Val::horizontal( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2134,11 +2046,10 @@ pub(crate) fn register_val_functions(world: &mut World) { |_self: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::UiRect> = ::bevy_ui::Val::left( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiRect = ::bevy_ui::Val::left( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2151,11 +2062,10 @@ pub(crate) fn register_val_functions(world: &mut World) { |_self: Val<::bevy_ui::Val>, rhs: f32| { let output: Val<::bevy_ui::Val> = { { - let output: Val<::bevy_ui::Val> = <::bevy_ui::Val as ::std::ops::Mul< + let output: ::bevy_ui::Val = <::bevy_ui::Val as ::std::ops::Mul< f32, - >>::mul(_self.into_inner(), rhs) - .into(); - output + >>::mul(safe_transmute(_self), safe_transmute(rhs)); + safe_transmute(output) } }; output @@ -2168,11 +2078,10 @@ pub(crate) fn register_val_functions(world: &mut World) { |_self: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::Val> = { { - let output: Val<::bevy_ui::Val> = <::bevy_ui::Val as ::std::ops::Neg>::neg( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::Val = <::bevy_ui::Val as ::std::ops::Neg>::neg( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2185,11 +2094,10 @@ pub(crate) fn register_val_functions(world: &mut World) { |_self: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::UiRect> = ::bevy_ui::Val::right( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiRect = ::bevy_ui::Val::right( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2202,11 +2110,10 @@ pub(crate) fn register_val_functions(world: &mut World) { |_self: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::UiRect> = ::bevy_ui::Val::top( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiRect = ::bevy_ui::Val::top( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2219,11 +2126,10 @@ pub(crate) fn register_val_functions(world: &mut World) { |_self: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::UiRect> = ::bevy_ui::Val::vertical( - _self.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiRect = ::bevy_ui::Val::vertical( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2248,11 +2154,10 @@ pub(crate) fn register_color_stop_functions(world: &mut World) { |_self: Ref<::bevy_ui::ColorStop>| { let output: Val<::bevy_ui::ColorStop> = { { - let output: Val<::bevy_ui::ColorStop> = <::bevy_ui::ColorStop as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::ColorStop = <::bevy_ui::ColorStop as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2267,9 +2172,8 @@ pub(crate) fn register_color_stop_functions(world: &mut World) { { let output: bool = <::bevy_ui::ColorStop as ::std::cmp::PartialEq< ::bevy_ui::ColorStop, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2282,12 +2186,11 @@ pub(crate) fn register_color_stop_functions(world: &mut World) { |_self: Val<::bevy_ui::ColorStop>, hint: f32| { let output: Val<::bevy_ui::ColorStop> = { { - let output: Val<::bevy_ui::ColorStop> = ::bevy_ui::ColorStop::with_hint( - _self.into_inner(), - hint, - ) - .into(); - output + let output: ::bevy_ui::ColorStop = ::bevy_ui::ColorStop::with_hint( + safe_transmute(_self), + safe_transmute(hint), + ); + safe_transmute(output) } }; output @@ -2312,11 +2215,10 @@ pub(crate) fn register_angular_color_stop_functions(world: &mut World) { |_self: Ref<::bevy_ui::AngularColorStop>| { let output: Val<::bevy_ui::AngularColorStop> = { { - let output: Val<::bevy_ui::AngularColorStop> = <::bevy_ui::AngularColorStop as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::AngularColorStop = <::bevy_ui::AngularColorStop as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2334,9 +2236,8 @@ pub(crate) fn register_angular_color_stop_functions(world: &mut World) { { let output: bool = <::bevy_ui::AngularColorStop as ::std::cmp::PartialEq< ::bevy_ui::AngularColorStop, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2349,12 +2250,11 @@ pub(crate) fn register_angular_color_stop_functions(world: &mut World) { |_self: Val<::bevy_ui::AngularColorStop>, hint: f32| { let output: Val<::bevy_ui::AngularColorStop> = { { - let output: Val<::bevy_ui::AngularColorStop> = ::bevy_ui::AngularColorStop::with_hint( - _self.into_inner(), - hint, - ) - .into(); - output + let output: ::bevy_ui::AngularColorStop = ::bevy_ui::AngularColorStop::with_hint( + safe_transmute(_self), + safe_transmute(hint), + ); + safe_transmute(output) } }; output @@ -2379,11 +2279,10 @@ pub(crate) fn register_linear_gradient_functions(world: &mut World) { |_self: Ref<::bevy_ui::LinearGradient>| { let output: Val<::bevy_ui::LinearGradient> = { { - let output: Val<::bevy_ui::LinearGradient> = <::bevy_ui::LinearGradient as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::LinearGradient = <::bevy_ui::LinearGradient as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2401,9 +2300,8 @@ pub(crate) fn register_linear_gradient_functions(world: &mut World) { { let output: bool = <::bevy_ui::LinearGradient as ::std::cmp::PartialEq< ::bevy_ui::LinearGradient, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2419,12 +2317,11 @@ pub(crate) fn register_linear_gradient_functions(world: &mut World) { { let output: Val<::bevy_ui::LinearGradient> = { { - let output: Val<::bevy_ui::LinearGradient> = ::bevy_ui::LinearGradient::in_color_space( - _self.into_inner(), - color_space.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::LinearGradient = ::bevy_ui::LinearGradient::in_color_space( + safe_transmute(_self), + safe_transmute(color_space), + ); + safe_transmute(output) } }; output @@ -2450,10 +2347,9 @@ pub(crate) fn register_interpolation_color_space_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui::InterpolationColorSpace as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2466,11 +2362,10 @@ pub(crate) fn register_interpolation_color_space_functions(world: &mut World) { |_self: Ref<::bevy_ui::InterpolationColorSpace>| { let output: Val<::bevy_ui::InterpolationColorSpace> = { { - let output: Val<::bevy_ui::InterpolationColorSpace> = <::bevy_ui::InterpolationColorSpace as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::InterpolationColorSpace = <::bevy_ui::InterpolationColorSpace as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2488,9 +2383,8 @@ pub(crate) fn register_interpolation_color_space_functions(world: &mut World) { { let output: bool = <::bevy_ui::InterpolationColorSpace as ::std::cmp::PartialEq< ::bevy_ui::InterpolationColorSpace, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2515,11 +2409,10 @@ pub(crate) fn register_radial_gradient_functions(world: &mut World) { |_self: Ref<::bevy_ui::RadialGradient>| { let output: Val<::bevy_ui::RadialGradient> = { { - let output: Val<::bevy_ui::RadialGradient> = <::bevy_ui::RadialGradient as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::RadialGradient = <::bevy_ui::RadialGradient as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2537,9 +2430,8 @@ pub(crate) fn register_radial_gradient_functions(world: &mut World) { { let output: bool = <::bevy_ui::RadialGradient as ::std::cmp::PartialEq< ::bevy_ui::RadialGradient, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2555,12 +2447,11 @@ pub(crate) fn register_radial_gradient_functions(world: &mut World) { { let output: Val<::bevy_ui::RadialGradient> = { { - let output: Val<::bevy_ui::RadialGradient> = ::bevy_ui::RadialGradient::in_color_space( - _self.into_inner(), - color_space.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::RadialGradient = ::bevy_ui::RadialGradient::in_color_space( + safe_transmute(_self), + safe_transmute(color_space), + ); + safe_transmute(output) } }; output @@ -2585,11 +2476,10 @@ pub(crate) fn register_radial_gradient_shape_functions(world: &mut World) { |_self: Ref<::bevy_ui::RadialGradientShape>| { let output: Val<::bevy_ui::RadialGradientShape> = { { - let output: Val<::bevy_ui::RadialGradientShape> = <::bevy_ui::RadialGradientShape as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::RadialGradientShape = <::bevy_ui::RadialGradientShape as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2607,9 +2497,8 @@ pub(crate) fn register_radial_gradient_shape_functions(world: &mut World) { { let output: bool = <::bevy_ui::RadialGradientShape as ::std::cmp::PartialEq< ::bevy_ui::RadialGradientShape, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2621,22 +2510,21 @@ pub(crate) fn register_radial_gradient_shape_functions(world: &mut World) { "resolve", | _self: Val<::bevy_ui::RadialGradientShape>, - position: Val<::glam::Vec2>, + position: Val<::bevy_math::Vec2>, scale_factor: f32, - physical_size: Val<::glam::Vec2>, - physical_target_size: Val<::glam::Vec2>| + physical_size: Val<::bevy_math::Vec2>, + physical_target_size: Val<::bevy_math::Vec2>| { - let output: Val<::glam::Vec2> = { + let output: Val<::bevy_math::Vec2> = { { - let output: Val<::glam::Vec2> = ::bevy_ui::RadialGradientShape::resolve( - _self.into_inner(), - position.into_inner(), - scale_factor, - physical_size.into_inner(), - physical_target_size.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_ui::RadialGradientShape::resolve( + safe_transmute(_self), + safe_transmute(position), + safe_transmute(scale_factor), + safe_transmute(physical_size), + safe_transmute(physical_target_size), + ); + safe_transmute(output) } }; output @@ -2667,11 +2555,10 @@ pub(crate) fn register_conic_gradient_functions(world: &mut World) { |_self: Ref<::bevy_ui::ConicGradient>| { let output: Val<::bevy_ui::ConicGradient> = { { - let output: Val<::bevy_ui::ConicGradient> = <::bevy_ui::ConicGradient as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::ConicGradient = <::bevy_ui::ConicGradient as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2686,9 +2573,8 @@ pub(crate) fn register_conic_gradient_functions(world: &mut World) { { let output: bool = <::bevy_ui::ConicGradient as ::std::cmp::PartialEq< ::bevy_ui::ConicGradient, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2704,12 +2590,11 @@ pub(crate) fn register_conic_gradient_functions(world: &mut World) { { let output: Val<::bevy_ui::ConicGradient> = { { - let output: Val<::bevy_ui::ConicGradient> = ::bevy_ui::ConicGradient::in_color_space( - _self.into_inner(), - color_space.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::ConicGradient = ::bevy_ui::ConicGradient::in_color_space( + safe_transmute(_self), + safe_transmute(color_space), + ); + safe_transmute(output) } }; output @@ -2722,12 +2607,11 @@ pub(crate) fn register_conic_gradient_functions(world: &mut World) { |_self: Val<::bevy_ui::ConicGradient>, position: Val<::bevy_ui::UiPosition>| { let output: Val<::bevy_ui::ConicGradient> = { { - let output: Val<::bevy_ui::ConicGradient> = ::bevy_ui::ConicGradient::with_position( - _self.into_inner(), - position.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::ConicGradient = ::bevy_ui::ConicGradient::with_position( + safe_transmute(_self), + safe_transmute(position), + ); + safe_transmute(output) } }; output @@ -2740,12 +2624,11 @@ pub(crate) fn register_conic_gradient_functions(world: &mut World) { |_self: Val<::bevy_ui::ConicGradient>, start: f32| { let output: Val<::bevy_ui::ConicGradient> = { { - let output: Val<::bevy_ui::ConicGradient> = ::bevy_ui::ConicGradient::with_start( - _self.into_inner(), - start, - ) - .into(); - output + let output: ::bevy_ui::ConicGradient = ::bevy_ui::ConicGradient::with_start( + safe_transmute(_self), + safe_transmute(start), + ); + safe_transmute(output) } }; output @@ -2770,11 +2653,10 @@ pub(crate) fn register_gradient_functions(world: &mut World) { |_self: Ref<::bevy_ui::Gradient>| { let output: Val<::bevy_ui::Gradient> = { { - let output: Val<::bevy_ui::Gradient> = <::bevy_ui::Gradient as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::Gradient = <::bevy_ui::Gradient as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2789,9 +2671,8 @@ pub(crate) fn register_gradient_functions(world: &mut World) { { let output: bool = <::bevy_ui::Gradient as ::std::cmp::PartialEq< ::bevy_ui::Gradient, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2804,8 +2685,10 @@ pub(crate) fn register_gradient_functions(world: &mut World) { |_self: Ref<::bevy_ui::Gradient>| { let output: bool = { { - let output: bool = ::bevy_ui::Gradient::is_empty(&_self).into(); - output + let output: bool = ::bevy_ui::Gradient::is_empty( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2830,11 +2713,10 @@ pub(crate) fn register_background_gradient_functions(world: &mut World) { |_self: Ref<::bevy_ui::BackgroundGradient>| { let output: Val<::bevy_ui::BackgroundGradient> = { { - let output: Val<::bevy_ui::BackgroundGradient> = <::bevy_ui::BackgroundGradient as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::BackgroundGradient = <::bevy_ui::BackgroundGradient as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2852,9 +2734,8 @@ pub(crate) fn register_background_gradient_functions(world: &mut World) { { let output: bool = <::bevy_ui::BackgroundGradient as ::std::cmp::PartialEq< ::bevy_ui::BackgroundGradient, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2879,11 +2760,10 @@ pub(crate) fn register_border_gradient_functions(world: &mut World) { |_self: Ref<::bevy_ui::BorderGradient>| { let output: Val<::bevy_ui::BorderGradient> = { { - let output: Val<::bevy_ui::BorderGradient> = <::bevy_ui::BorderGradient as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::BorderGradient = <::bevy_ui::BorderGradient as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2901,9 +2781,8 @@ pub(crate) fn register_border_gradient_functions(world: &mut World) { { let output: bool = <::bevy_ui::BorderGradient as ::std::cmp::PartialEq< ::bevy_ui::BorderGradient, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2928,11 +2807,10 @@ pub(crate) fn register_val_2_functions(world: &mut World) { |_self: Ref<::bevy_ui::Val2>| { let output: Val<::bevy_ui::Val2> = { { - let output: Val<::bevy_ui::Val2> = <::bevy_ui::Val2 as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::Val2 = <::bevy_ui::Val2 as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -2947,9 +2825,8 @@ pub(crate) fn register_val_2_functions(world: &mut World) { { let output: bool = <::bevy_ui::Val2 as ::std::cmp::PartialEq< ::bevy_ui::Val2, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -2962,12 +2839,11 @@ pub(crate) fn register_val_2_functions(world: &mut World) { |x: Val<::bevy_ui::Val>, y: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::Val2> = { { - let output: Val<::bevy_ui::Val2> = ::bevy_ui::Val2::new( - x.into_inner(), - y.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::Val2 = ::bevy_ui::Val2::new( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -2980,9 +2856,11 @@ pub(crate) fn register_val_2_functions(world: &mut World) { |x: f32, y: f32| { let output: Val<::bevy_ui::Val2> = { { - let output: Val<::bevy_ui::Val2> = ::bevy_ui::Val2::percent(x, y) - .into(); - output + let output: ::bevy_ui::Val2 = ::bevy_ui::Val2::percent( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -2995,9 +2873,11 @@ pub(crate) fn register_val_2_functions(world: &mut World) { |x: f32, y: f32| { let output: Val<::bevy_ui::Val2> = { { - let output: Val<::bevy_ui::Val2> = ::bevy_ui::Val2::px(x, y) - .into(); - output + let output: ::bevy_ui::Val2 = ::bevy_ui::Val2::px( + safe_transmute(x), + safe_transmute(y), + ); + safe_transmute(output) } }; output @@ -3010,19 +2890,18 @@ pub(crate) fn register_val_2_functions(world: &mut World) { | _self: Ref<::bevy_ui::Val2>, scale_factor: f32, - base_size: Val<::glam::Vec2>, - viewport_size: Val<::glam::Vec2>| + base_size: Val<::bevy_math::Vec2>, + viewport_size: Val<::bevy_math::Vec2>| { - let output: Val<::glam::Vec2> = { + let output: Val<::bevy_math::Vec2> = { { - let output: Val<::glam::Vec2> = ::bevy_ui::Val2::resolve( - &_self, - scale_factor, - base_size.into_inner(), - viewport_size.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Vec2 = ::bevy_ui::Val2::resolve( + safe_transmute(_self), + safe_transmute(scale_factor), + safe_transmute(base_size), + safe_transmute(viewport_size), + ); + safe_transmute(output) } }; output @@ -3047,11 +2926,10 @@ pub(crate) fn register_ui_transform_functions(world: &mut World) { |_self: Ref<::bevy_ui::UiTransform>| { let output: Val<::bevy_ui::UiTransform> = { { - let output: Val<::bevy_ui::UiTransform> = <::bevy_ui::UiTransform as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::UiTransform = <::bevy_ui::UiTransform as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3064,19 +2942,18 @@ pub(crate) fn register_ui_transform_functions(world: &mut World) { | _self: Ref<::bevy_ui::UiTransform>, scale_factor: f32, - base_size: Val<::glam::Vec2>, - target_size: Val<::glam::Vec2>| + base_size: Val<::bevy_math::Vec2>, + target_size: Val<::bevy_math::Vec2>| { - let output: Val<::glam::Affine2> = { + let output: Val<::bevy_math::Affine2> = { { - let output: Val<::glam::Affine2> = ::bevy_ui::UiTransform::compute_affine( - &_self, - scale_factor, - base_size.into_inner(), - target_size.into_inner(), - ) - .into(); - output + let output: ::bevy_math::Affine2 = ::bevy_ui::UiTransform::compute_affine( + safe_transmute(_self), + safe_transmute(scale_factor), + safe_transmute(base_size), + safe_transmute(target_size), + ); + safe_transmute(output) } }; output @@ -3091,9 +2968,8 @@ pub(crate) fn register_ui_transform_functions(world: &mut World) { { let output: bool = <::bevy_ui::UiTransform as ::std::cmp::PartialEq< ::bevy_ui::UiTransform, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -3106,11 +2982,10 @@ pub(crate) fn register_ui_transform_functions(world: &mut World) { |rotation: Val<::bevy_math::Rot2>| { let output: Val<::bevy_ui::UiTransform> = { { - let output: Val<::bevy_ui::UiTransform> = ::bevy_ui::UiTransform::from_rotation( - rotation.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiTransform = ::bevy_ui::UiTransform::from_rotation( + safe_transmute(rotation), + ); + safe_transmute(output) } }; output @@ -3120,14 +2995,13 @@ pub(crate) fn register_ui_transform_functions(world: &mut World) { ) .register_documented( "from_scale", - |scale: Val<::glam::Vec2>| { + |scale: Val<::bevy_math::Vec2>| { let output: Val<::bevy_ui::UiTransform> = { { - let output: Val<::bevy_ui::UiTransform> = ::bevy_ui::UiTransform::from_scale( - scale.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiTransform = ::bevy_ui::UiTransform::from_scale( + safe_transmute(scale), + ); + safe_transmute(output) } }; output @@ -3140,11 +3014,10 @@ pub(crate) fn register_ui_transform_functions(world: &mut World) { |translation: Val<::bevy_ui::Val2>| { let output: Val<::bevy_ui::UiTransform> = { { - let output: Val<::bevy_ui::UiTransform> = ::bevy_ui::UiTransform::from_translation( - translation.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiTransform = ::bevy_ui::UiTransform::from_translation( + safe_transmute(translation), + ); + safe_transmute(output) } }; output @@ -3169,11 +3042,10 @@ pub(crate) fn register_relative_cursor_position_functions(world: &mut World) { |_self: Ref<::bevy_ui::RelativeCursorPosition>| { let output: Val<::bevy_ui::RelativeCursorPosition> = { { - let output: Val<::bevy_ui::RelativeCursorPosition> = <::bevy_ui::RelativeCursorPosition as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::RelativeCursorPosition = <::bevy_ui::RelativeCursorPosition as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3187,10 +3059,9 @@ pub(crate) fn register_relative_cursor_position_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_ui::RelativeCursorPosition::cursor_over( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3208,9 +3079,8 @@ pub(crate) fn register_relative_cursor_position_functions(world: &mut World) { { let output: bool = <::bevy_ui::RelativeCursorPosition as ::std::cmp::PartialEq< ::bevy_ui::RelativeCursorPosition, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -3235,11 +3105,10 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { |value: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::all( - value.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiRect = ::bevy_ui::UiRect::all( + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -3252,12 +3121,11 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { |horizontal: Val<::bevy_ui::Val>, vertical: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::axes( - horizontal.into_inner(), - vertical.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiRect = ::bevy_ui::UiRect::axes( + safe_transmute(horizontal), + safe_transmute(vertical), + ); + safe_transmute(output) } }; output @@ -3270,11 +3138,10 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { |bottom: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::bottom( - bottom.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiRect = ::bevy_ui::UiRect::bottom( + safe_transmute(bottom), + ); + safe_transmute(output) } }; output @@ -3287,11 +3154,10 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { |_self: Ref<::bevy_ui::UiRect>| { let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::UiRect> = <::bevy_ui::UiRect as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::UiRect = <::bevy_ui::UiRect as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3306,9 +3172,8 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { { let output: bool = <::bevy_ui::UiRect as ::std::cmp::PartialEq< ::bevy_ui::UiRect, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -3321,11 +3186,10 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { |value: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::horizontal( - value.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiRect = ::bevy_ui::UiRect::horizontal( + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -3338,11 +3202,10 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { |left: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::left( - left.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiRect = ::bevy_ui::UiRect::left( + safe_transmute(left), + ); + safe_transmute(output) } }; output @@ -3360,14 +3223,13 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { { let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::new( - left.into_inner(), - right.into_inner(), - top.into_inner(), - bottom.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiRect = ::bevy_ui::UiRect::new( + safe_transmute(left), + safe_transmute(right), + safe_transmute(top), + safe_transmute(bottom), + ); + safe_transmute(output) } }; output @@ -3380,14 +3242,13 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { |left: f32, right: f32, top: f32, bottom: f32| { let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::percent( - left, - right, - top, - bottom, - ) - .into(); - output + let output: ::bevy_ui::UiRect = ::bevy_ui::UiRect::percent( + safe_transmute(left), + safe_transmute(right), + safe_transmute(top), + safe_transmute(bottom), + ); + safe_transmute(output) } }; output @@ -3400,14 +3261,13 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { |left: f32, right: f32, top: f32, bottom: f32| { let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::px( - left, - right, - top, - bottom, - ) - .into(); - output + let output: ::bevy_ui::UiRect = ::bevy_ui::UiRect::px( + safe_transmute(left), + safe_transmute(right), + safe_transmute(top), + safe_transmute(bottom), + ); + safe_transmute(output) } }; output @@ -3420,11 +3280,10 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { |right: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::right( - right.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiRect = ::bevy_ui::UiRect::right( + safe_transmute(right), + ); + safe_transmute(output) } }; output @@ -3437,11 +3296,10 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { |top: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::top( - top.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiRect = ::bevy_ui::UiRect::top( + safe_transmute(top), + ); + safe_transmute(output) } }; output @@ -3454,11 +3312,10 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { |value: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::vertical( - value.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiRect = ::bevy_ui::UiRect::vertical( + safe_transmute(value), + ); + safe_transmute(output) } }; output @@ -3471,12 +3328,11 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { |_self: Val<::bevy_ui::UiRect>, bottom: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::with_bottom( - _self.into_inner(), - bottom.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiRect = ::bevy_ui::UiRect::with_bottom( + safe_transmute(_self), + safe_transmute(bottom), + ); + safe_transmute(output) } }; output @@ -3489,12 +3345,11 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { |_self: Val<::bevy_ui::UiRect>, left: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::with_left( - _self.into_inner(), - left.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiRect = ::bevy_ui::UiRect::with_left( + safe_transmute(_self), + safe_transmute(left), + ); + safe_transmute(output) } }; output @@ -3507,12 +3362,11 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { |_self: Val<::bevy_ui::UiRect>, right: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::with_right( - _self.into_inner(), - right.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiRect = ::bevy_ui::UiRect::with_right( + safe_transmute(_self), + safe_transmute(right), + ); + safe_transmute(output) } }; output @@ -3525,12 +3379,11 @@ pub(crate) fn register_ui_rect_functions(world: &mut World) { |_self: Val<::bevy_ui::UiRect>, top: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::UiRect> = { { - let output: Val<::bevy_ui::UiRect> = ::bevy_ui::UiRect::with_top( - _self.into_inner(), - top.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::UiRect = ::bevy_ui::UiRect::with_top( + safe_transmute(_self), + safe_transmute(top), + ); + safe_transmute(output) } }; output @@ -3555,11 +3408,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { |radius: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::all( - radius.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::BorderRadius = ::bevy_ui::BorderRadius::all( + safe_transmute(radius), + ); + safe_transmute(output) } }; output @@ -3572,11 +3424,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { |radius: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::bottom( - radius.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::BorderRadius = ::bevy_ui::BorderRadius::bottom( + safe_transmute(radius), + ); + safe_transmute(output) } }; output @@ -3589,11 +3440,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { |radius: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::bottom_left( - radius.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::BorderRadius = ::bevy_ui::BorderRadius::bottom_left( + safe_transmute(radius), + ); + safe_transmute(output) } }; output @@ -3606,11 +3456,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { |radius: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::bottom_right( - radius.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::BorderRadius = ::bevy_ui::BorderRadius::bottom_right( + safe_transmute(radius), + ); + safe_transmute(output) } }; output @@ -3623,11 +3472,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { |_self: Ref<::bevy_ui::BorderRadius>| { let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::BorderRadius> = <::bevy_ui::BorderRadius as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::BorderRadius = <::bevy_ui::BorderRadius as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -3642,9 +3490,8 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { { let output: bool = <::bevy_ui::BorderRadius as ::std::cmp::PartialEq< ::bevy_ui::BorderRadius, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -3657,11 +3504,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { |radius: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::left( - radius.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::BorderRadius = ::bevy_ui::BorderRadius::left( + safe_transmute(radius), + ); + safe_transmute(output) } }; output @@ -3679,14 +3525,13 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { { let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::new( - top_left.into_inner(), - top_right.into_inner(), - bottom_right.into_inner(), - bottom_left.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::BorderRadius = ::bevy_ui::BorderRadius::new( + safe_transmute(top_left), + safe_transmute(top_right), + safe_transmute(bottom_right), + safe_transmute(bottom_left), + ); + safe_transmute(output) } }; output @@ -3699,14 +3544,13 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { |top_left: f32, top_right: f32, bottom_right: f32, bottom_left: f32| { let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::percent( - top_left, - top_right, - bottom_right, - bottom_left, - ) - .into(); - output + let output: ::bevy_ui::BorderRadius = ::bevy_ui::BorderRadius::percent( + safe_transmute(top_left), + safe_transmute(top_right), + safe_transmute(bottom_right), + safe_transmute(bottom_left), + ); + safe_transmute(output) } }; output @@ -3719,14 +3563,13 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { |top_left: f32, top_right: f32, bottom_right: f32, bottom_left: f32| { let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::px( - top_left, - top_right, - bottom_right, - bottom_left, - ) - .into(); - output + let output: ::bevy_ui::BorderRadius = ::bevy_ui::BorderRadius::px( + safe_transmute(top_left), + safe_transmute(top_right), + safe_transmute(bottom_right), + safe_transmute(bottom_left), + ); + safe_transmute(output) } }; output @@ -3739,19 +3582,18 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { | _self: Ref<::bevy_ui::BorderRadius>, scale_factor: f32, - node_size: Val<::glam::Vec2>, - viewport_size: Val<::glam::Vec2>| + node_size: Val<::bevy_math::Vec2>, + viewport_size: Val<::bevy_math::Vec2>| { let output: Val<::bevy_ui::ResolvedBorderRadius> = { { - let output: Val<::bevy_ui::ResolvedBorderRadius> = ::bevy_ui::BorderRadius::resolve( - &_self, - scale_factor, - node_size.into_inner(), - viewport_size.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::ResolvedBorderRadius = ::bevy_ui::BorderRadius::resolve( + safe_transmute(_self), + safe_transmute(scale_factor), + safe_transmute(node_size), + safe_transmute(viewport_size), + ); + safe_transmute(output) } }; output @@ -3765,18 +3607,17 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { radius: Val<::bevy_ui::Val>, scale_factor: f32, min_length: f32, - viewport_size: Val<::glam::Vec2>| + viewport_size: Val<::bevy_math::Vec2>| { let output: f32 = { { let output: f32 = ::bevy_ui::BorderRadius::resolve_single_corner( - radius.into_inner(), - scale_factor, - min_length, - viewport_size.into_inner(), - ) - .into(); - output + safe_transmute(radius), + safe_transmute(scale_factor), + safe_transmute(min_length), + safe_transmute(viewport_size), + ); + safe_transmute(output) } }; output @@ -3789,11 +3630,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { |radius: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::right( - radius.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::BorderRadius = ::bevy_ui::BorderRadius::right( + safe_transmute(radius), + ); + safe_transmute(output) } }; output @@ -3806,11 +3646,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { |radius: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::top( - radius.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::BorderRadius = ::bevy_ui::BorderRadius::top( + safe_transmute(radius), + ); + safe_transmute(output) } }; output @@ -3823,11 +3662,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { |radius: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::top_left( - radius.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::BorderRadius = ::bevy_ui::BorderRadius::top_left( + safe_transmute(radius), + ); + safe_transmute(output) } }; output @@ -3840,11 +3678,10 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { |radius: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::top_right( - radius.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::BorderRadius = ::bevy_ui::BorderRadius::top_right( + safe_transmute(radius), + ); + safe_transmute(output) } }; output @@ -3857,12 +3694,11 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { |_self: Val<::bevy_ui::BorderRadius>, radius: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::with_bottom( - _self.into_inner(), - radius.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::BorderRadius = ::bevy_ui::BorderRadius::with_bottom( + safe_transmute(_self), + safe_transmute(radius), + ); + safe_transmute(output) } }; output @@ -3875,12 +3711,11 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { |_self: Val<::bevy_ui::BorderRadius>, radius: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::with_bottom_left( - _self.into_inner(), - radius.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::BorderRadius = ::bevy_ui::BorderRadius::with_bottom_left( + safe_transmute(_self), + safe_transmute(radius), + ); + safe_transmute(output) } }; output @@ -3893,12 +3728,11 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { |_self: Val<::bevy_ui::BorderRadius>, radius: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::with_bottom_right( - _self.into_inner(), - radius.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::BorderRadius = ::bevy_ui::BorderRadius::with_bottom_right( + safe_transmute(_self), + safe_transmute(radius), + ); + safe_transmute(output) } }; output @@ -3911,12 +3745,11 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { |_self: Val<::bevy_ui::BorderRadius>, radius: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::with_left( - _self.into_inner(), - radius.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::BorderRadius = ::bevy_ui::BorderRadius::with_left( + safe_transmute(_self), + safe_transmute(radius), + ); + safe_transmute(output) } }; output @@ -3929,12 +3762,11 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { |_self: Val<::bevy_ui::BorderRadius>, radius: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::with_right( - _self.into_inner(), - radius.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::BorderRadius = ::bevy_ui::BorderRadius::with_right( + safe_transmute(_self), + safe_transmute(radius), + ); + safe_transmute(output) } }; output @@ -3947,12 +3779,11 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { |_self: Val<::bevy_ui::BorderRadius>, radius: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::with_top( - _self.into_inner(), - radius.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::BorderRadius = ::bevy_ui::BorderRadius::with_top( + safe_transmute(_self), + safe_transmute(radius), + ); + safe_transmute(output) } }; output @@ -3965,12 +3796,11 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { |_self: Val<::bevy_ui::BorderRadius>, radius: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::with_top_left( - _self.into_inner(), - radius.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::BorderRadius = ::bevy_ui::BorderRadius::with_top_left( + safe_transmute(_self), + safe_transmute(radius), + ); + safe_transmute(output) } }; output @@ -3983,12 +3813,11 @@ pub(crate) fn register_border_radius_functions(world: &mut World) { |_self: Val<::bevy_ui::BorderRadius>, radius: Val<::bevy_ui::Val>| { let output: Val<::bevy_ui::BorderRadius> = { { - let output: Val<::bevy_ui::BorderRadius> = ::bevy_ui::BorderRadius::with_top_right( - _self.into_inner(), - radius.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::BorderRadius = ::bevy_ui::BorderRadius::with_top_right( + safe_transmute(_self), + safe_transmute(radius), + ); + safe_transmute(output) } }; output @@ -4013,11 +3842,10 @@ pub(crate) fn register_layout_config_functions(world: &mut World) { |_self: Ref<::bevy_ui::LayoutConfig>| { let output: Val<::bevy_ui::LayoutConfig> = { { - let output: Val<::bevy_ui::LayoutConfig> = <::bevy_ui::LayoutConfig as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::LayoutConfig = <::bevy_ui::LayoutConfig as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4032,9 +3860,8 @@ pub(crate) fn register_layout_config_functions(world: &mut World) { { let output: bool = <::bevy_ui::LayoutConfig as ::std::cmp::PartialEq< ::bevy_ui::LayoutConfig, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -4059,11 +3886,10 @@ pub(crate) fn register_outline_functions(world: &mut World) { |_self: Ref<::bevy_ui::Outline>| { let output: Val<::bevy_ui::Outline> = { { - let output: Val<::bevy_ui::Outline> = <::bevy_ui::Outline as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::Outline = <::bevy_ui::Outline as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4078,9 +3904,8 @@ pub(crate) fn register_outline_functions(world: &mut World) { { let output: bool = <::bevy_ui::Outline as ::std::cmp::PartialEq< ::bevy_ui::Outline, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -4097,13 +3922,12 @@ pub(crate) fn register_outline_functions(world: &mut World) { { let output: Val<::bevy_ui::Outline> = { { - let output: Val<::bevy_ui::Outline> = ::bevy_ui::Outline::new( - width.into_inner(), - offset.into_inner(), - color.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::Outline = ::bevy_ui::Outline::new( + safe_transmute(width), + safe_transmute(offset), + safe_transmute(color), + ); + safe_transmute(output) } }; output @@ -4128,11 +3952,10 @@ pub(crate) fn register_scroll_position_functions(world: &mut World) { |_self: Ref<::bevy_ui::ScrollPosition>| { let output: Val<::bevy_ui::ScrollPosition> = { { - let output: Val<::bevy_ui::ScrollPosition> = <::bevy_ui::ScrollPosition as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::ScrollPosition = <::bevy_ui::ScrollPosition as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4158,10 +3981,9 @@ pub(crate) fn register_position_type_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui::PositionType as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4174,11 +3996,10 @@ pub(crate) fn register_position_type_functions(world: &mut World) { |_self: Ref<::bevy_ui::PositionType>| { let output: Val<::bevy_ui::PositionType> = { { - let output: Val<::bevy_ui::PositionType> = <::bevy_ui::PositionType as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::PositionType = <::bevy_ui::PositionType as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4193,9 +4014,8 @@ pub(crate) fn register_position_type_functions(world: &mut World) { { let output: bool = <::bevy_ui::PositionType as ::std::cmp::PartialEq< ::bevy_ui::PositionType, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -4221,10 +4041,9 @@ pub(crate) fn register_align_self_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui::AlignSelf as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4237,11 +4056,10 @@ pub(crate) fn register_align_self_functions(world: &mut World) { |_self: Ref<::bevy_ui::AlignSelf>| { let output: Val<::bevy_ui::AlignSelf> = { { - let output: Val<::bevy_ui::AlignSelf> = <::bevy_ui::AlignSelf as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::AlignSelf = <::bevy_ui::AlignSelf as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4256,9 +4074,8 @@ pub(crate) fn register_align_self_functions(world: &mut World) { { let output: bool = <::bevy_ui::AlignSelf as ::std::cmp::PartialEq< ::bevy_ui::AlignSelf, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -4283,11 +4100,10 @@ pub(crate) fn register_repeated_grid_track_functions(world: &mut World) { |_self: Ref<::bevy_ui::RepeatedGridTrack>| { let output: Val<::bevy_ui::RepeatedGridTrack> = { { - let output: Val<::bevy_ui::RepeatedGridTrack> = <::bevy_ui::RepeatedGridTrack as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::RepeatedGridTrack = <::bevy_ui::RepeatedGridTrack as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4305,9 +4121,8 @@ pub(crate) fn register_repeated_grid_track_functions(world: &mut World) { { let output: bool = <::bevy_ui::RepeatedGridTrack as ::std::cmp::PartialEq< ::bevy_ui::RepeatedGridTrack, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -4333,10 +4148,9 @@ pub(crate) fn register_align_content_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui::AlignContent as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4349,11 +4163,10 @@ pub(crate) fn register_align_content_functions(world: &mut World) { |_self: Ref<::bevy_ui::AlignContent>| { let output: Val<::bevy_ui::AlignContent> = { { - let output: Val<::bevy_ui::AlignContent> = <::bevy_ui::AlignContent as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::AlignContent = <::bevy_ui::AlignContent as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4368,9 +4181,8 @@ pub(crate) fn register_align_content_functions(world: &mut World) { { let output: bool = <::bevy_ui::AlignContent as ::std::cmp::PartialEq< ::bevy_ui::AlignContent, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -4396,10 +4208,9 @@ pub(crate) fn register_align_items_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui::AlignItems as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4412,11 +4223,10 @@ pub(crate) fn register_align_items_functions(world: &mut World) { |_self: Ref<::bevy_ui::AlignItems>| { let output: Val<::bevy_ui::AlignItems> = { { - let output: Val<::bevy_ui::AlignItems> = <::bevy_ui::AlignItems as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::AlignItems = <::bevy_ui::AlignItems as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4431,9 +4241,8 @@ pub(crate) fn register_align_items_functions(world: &mut World) { { let output: bool = <::bevy_ui::AlignItems as ::std::cmp::PartialEq< ::bevy_ui::AlignItems, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -4459,10 +4268,9 @@ pub(crate) fn register_box_sizing_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui::BoxSizing as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4475,11 +4283,10 @@ pub(crate) fn register_box_sizing_functions(world: &mut World) { |_self: Ref<::bevy_ui::BoxSizing>| { let output: Val<::bevy_ui::BoxSizing> = { { - let output: Val<::bevy_ui::BoxSizing> = <::bevy_ui::BoxSizing as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::BoxSizing = <::bevy_ui::BoxSizing as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4494,9 +4301,8 @@ pub(crate) fn register_box_sizing_functions(world: &mut World) { { let output: bool = <::bevy_ui::BoxSizing as ::std::cmp::PartialEq< ::bevy_ui::BoxSizing, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -4522,10 +4328,9 @@ pub(crate) fn register_flex_direction_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui::FlexDirection as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4538,11 +4343,10 @@ pub(crate) fn register_flex_direction_functions(world: &mut World) { |_self: Ref<::bevy_ui::FlexDirection>| { let output: Val<::bevy_ui::FlexDirection> = { { - let output: Val<::bevy_ui::FlexDirection> = <::bevy_ui::FlexDirection as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::FlexDirection = <::bevy_ui::FlexDirection as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4557,9 +4361,8 @@ pub(crate) fn register_flex_direction_functions(world: &mut World) { { let output: bool = <::bevy_ui::FlexDirection as ::std::cmp::PartialEq< ::bevy_ui::FlexDirection, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -4585,10 +4388,9 @@ pub(crate) fn register_flex_wrap_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui::FlexWrap as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4601,11 +4403,10 @@ pub(crate) fn register_flex_wrap_functions(world: &mut World) { |_self: Ref<::bevy_ui::FlexWrap>| { let output: Val<::bevy_ui::FlexWrap> = { { - let output: Val<::bevy_ui::FlexWrap> = <::bevy_ui::FlexWrap as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::FlexWrap = <::bevy_ui::FlexWrap as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4620,9 +4421,8 @@ pub(crate) fn register_flex_wrap_functions(world: &mut World) { { let output: bool = <::bevy_ui::FlexWrap as ::std::cmp::PartialEq< ::bevy_ui::FlexWrap, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -4648,10 +4448,9 @@ pub(crate) fn register_grid_auto_flow_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui::GridAutoFlow as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4664,11 +4463,10 @@ pub(crate) fn register_grid_auto_flow_functions(world: &mut World) { |_self: Ref<::bevy_ui::GridAutoFlow>| { let output: Val<::bevy_ui::GridAutoFlow> = { { - let output: Val<::bevy_ui::GridAutoFlow> = <::bevy_ui::GridAutoFlow as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::GridAutoFlow = <::bevy_ui::GridAutoFlow as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4683,9 +4481,8 @@ pub(crate) fn register_grid_auto_flow_functions(world: &mut World) { { let output: bool = <::bevy_ui::GridAutoFlow as ::std::cmp::PartialEq< ::bevy_ui::GridAutoFlow, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -4711,10 +4508,9 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui::GridPlacement as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4727,9 +4523,8 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { || { let output: Val<::bevy_ui::GridPlacement> = { { - let output: Val<::bevy_ui::GridPlacement> = ::bevy_ui::GridPlacement::auto() - .into(); - output + let output: ::bevy_ui::GridPlacement = ::bevy_ui::GridPlacement::auto(); + safe_transmute(output) } }; output @@ -4742,11 +4537,10 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { |_self: Ref<::bevy_ui::GridPlacement>| { let output: Val<::bevy_ui::GridPlacement> = { { - let output: Val<::bevy_ui::GridPlacement> = <::bevy_ui::GridPlacement as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::GridPlacement = <::bevy_ui::GridPlacement as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4759,11 +4553,10 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { |end: i16| { let output: Val<::bevy_ui::GridPlacement> = { { - let output: Val<::bevy_ui::GridPlacement> = ::bevy_ui::GridPlacement::end( - end, - ) - .into(); - output + let output: ::bevy_ui::GridPlacement = ::bevy_ui::GridPlacement::end( + safe_transmute(end), + ); + safe_transmute(output) } }; output @@ -4776,12 +4569,11 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { |end: i16, span: u16| { let output: Val<::bevy_ui::GridPlacement> = { { - let output: Val<::bevy_ui::GridPlacement> = ::bevy_ui::GridPlacement::end_span( - end, - span, - ) - .into(); - output + let output: ::bevy_ui::GridPlacement = ::bevy_ui::GridPlacement::end_span( + safe_transmute(end), + safe_transmute(span), + ); + safe_transmute(output) } }; output @@ -4796,9 +4588,8 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { { let output: bool = <::bevy_ui::GridPlacement as ::std::cmp::PartialEq< ::bevy_ui::GridPlacement, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -4812,10 +4603,9 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { let output: ::std::option::Option = { { let output: ::std::option::Option = ::bevy_ui::GridPlacement::get_end( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4829,10 +4619,9 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { let output: ::std::option::Option = { { let output: ::std::option::Option = ::bevy_ui::GridPlacement::get_span( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4846,10 +4635,9 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { let output: ::std::option::Option = { { let output: ::std::option::Option = ::bevy_ui::GridPlacement::get_start( - _self.into_inner(), - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -4862,12 +4650,11 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { |_self: Val<::bevy_ui::GridPlacement>, end: i16| { let output: Val<::bevy_ui::GridPlacement> = { { - let output: Val<::bevy_ui::GridPlacement> = ::bevy_ui::GridPlacement::set_end( - _self.into_inner(), - end, - ) - .into(); - output + let output: ::bevy_ui::GridPlacement = ::bevy_ui::GridPlacement::set_end( + safe_transmute(_self), + safe_transmute(end), + ); + safe_transmute(output) } }; output @@ -4880,12 +4667,11 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { |_self: Val<::bevy_ui::GridPlacement>, span: u16| { let output: Val<::bevy_ui::GridPlacement> = { { - let output: Val<::bevy_ui::GridPlacement> = ::bevy_ui::GridPlacement::set_span( - _self.into_inner(), - span, - ) - .into(); - output + let output: ::bevy_ui::GridPlacement = ::bevy_ui::GridPlacement::set_span( + safe_transmute(_self), + safe_transmute(span), + ); + safe_transmute(output) } }; output @@ -4898,12 +4684,11 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { |_self: Val<::bevy_ui::GridPlacement>, start: i16| { let output: Val<::bevy_ui::GridPlacement> = { { - let output: Val<::bevy_ui::GridPlacement> = ::bevy_ui::GridPlacement::set_start( - _self.into_inner(), - start, - ) - .into(); - output + let output: ::bevy_ui::GridPlacement = ::bevy_ui::GridPlacement::set_start( + safe_transmute(_self), + safe_transmute(start), + ); + safe_transmute(output) } }; output @@ -4916,11 +4701,10 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { |span: u16| { let output: Val<::bevy_ui::GridPlacement> = { { - let output: Val<::bevy_ui::GridPlacement> = ::bevy_ui::GridPlacement::span( - span, - ) - .into(); - output + let output: ::bevy_ui::GridPlacement = ::bevy_ui::GridPlacement::span( + safe_transmute(span), + ); + safe_transmute(output) } }; output @@ -4933,11 +4717,10 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { |start: i16| { let output: Val<::bevy_ui::GridPlacement> = { { - let output: Val<::bevy_ui::GridPlacement> = ::bevy_ui::GridPlacement::start( - start, - ) - .into(); - output + let output: ::bevy_ui::GridPlacement = ::bevy_ui::GridPlacement::start( + safe_transmute(start), + ); + safe_transmute(output) } }; output @@ -4950,12 +4733,11 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { |start: i16, end: i16| { let output: Val<::bevy_ui::GridPlacement> = { { - let output: Val<::bevy_ui::GridPlacement> = ::bevy_ui::GridPlacement::start_end( - start, - end, - ) - .into(); - output + let output: ::bevy_ui::GridPlacement = ::bevy_ui::GridPlacement::start_end( + safe_transmute(start), + safe_transmute(end), + ); + safe_transmute(output) } }; output @@ -4968,12 +4750,11 @@ pub(crate) fn register_grid_placement_functions(world: &mut World) { |start: i16, span: u16| { let output: Val<::bevy_ui::GridPlacement> = { { - let output: Val<::bevy_ui::GridPlacement> = ::bevy_ui::GridPlacement::start_span( - start, - span, - ) - .into(); - output + let output: ::bevy_ui::GridPlacement = ::bevy_ui::GridPlacement::start_span( + safe_transmute(start), + safe_transmute(span), + ); + safe_transmute(output) } }; output @@ -4998,11 +4779,10 @@ pub(crate) fn register_grid_track_functions(world: &mut World) { |_self: Ref<::bevy_ui::GridTrack>| { let output: Val<::bevy_ui::GridTrack> = { { - let output: Val<::bevy_ui::GridTrack> = <::bevy_ui::GridTrack as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::GridTrack = <::bevy_ui::GridTrack as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5017,9 +4797,8 @@ pub(crate) fn register_grid_track_functions(world: &mut World) { { let output: bool = <::bevy_ui::GridTrack as ::std::cmp::PartialEq< ::bevy_ui::GridTrack, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -5044,11 +4823,10 @@ pub(crate) fn register_grid_track_repetition_functions(world: &mut World) { |_self: Ref<::bevy_ui::GridTrackRepetition>| { let output: Val<::bevy_ui::GridTrackRepetition> = { { - let output: Val<::bevy_ui::GridTrackRepetition> = <::bevy_ui::GridTrackRepetition as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::GridTrackRepetition = <::bevy_ui::GridTrackRepetition as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5066,9 +4844,8 @@ pub(crate) fn register_grid_track_repetition_functions(world: &mut World) { { let output: bool = <::bevy_ui::GridTrackRepetition as ::std::cmp::PartialEq< ::bevy_ui::GridTrackRepetition, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -5094,10 +4871,9 @@ pub(crate) fn register_justify_content_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui::JustifyContent as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5110,11 +4886,10 @@ pub(crate) fn register_justify_content_functions(world: &mut World) { |_self: Ref<::bevy_ui::JustifyContent>| { let output: Val<::bevy_ui::JustifyContent> = { { - let output: Val<::bevy_ui::JustifyContent> = <::bevy_ui::JustifyContent as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::JustifyContent = <::bevy_ui::JustifyContent as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5132,9 +4907,8 @@ pub(crate) fn register_justify_content_functions(world: &mut World) { { let output: bool = <::bevy_ui::JustifyContent as ::std::cmp::PartialEq< ::bevy_ui::JustifyContent, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -5160,10 +4934,9 @@ pub(crate) fn register_justify_items_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui::JustifyItems as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5176,11 +4949,10 @@ pub(crate) fn register_justify_items_functions(world: &mut World) { |_self: Ref<::bevy_ui::JustifyItems>| { let output: Val<::bevy_ui::JustifyItems> = { { - let output: Val<::bevy_ui::JustifyItems> = <::bevy_ui::JustifyItems as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::JustifyItems = <::bevy_ui::JustifyItems as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5195,9 +4967,8 @@ pub(crate) fn register_justify_items_functions(world: &mut World) { { let output: bool = <::bevy_ui::JustifyItems as ::std::cmp::PartialEq< ::bevy_ui::JustifyItems, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -5223,10 +4994,9 @@ pub(crate) fn register_justify_self_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui::JustifySelf as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5239,11 +5009,10 @@ pub(crate) fn register_justify_self_functions(world: &mut World) { |_self: Ref<::bevy_ui::JustifySelf>| { let output: Val<::bevy_ui::JustifySelf> = { { - let output: Val<::bevy_ui::JustifySelf> = <::bevy_ui::JustifySelf as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::JustifySelf = <::bevy_ui::JustifySelf as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5258,9 +5027,8 @@ pub(crate) fn register_justify_self_functions(world: &mut World) { { let output: bool = <::bevy_ui::JustifySelf as ::std::cmp::PartialEq< ::bevy_ui::JustifySelf, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -5285,11 +5053,10 @@ pub(crate) fn register_max_track_sizing_function_functions(world: &mut World) { |_self: Ref<::bevy_ui::MaxTrackSizingFunction>| { let output: Val<::bevy_ui::MaxTrackSizingFunction> = { { - let output: Val<::bevy_ui::MaxTrackSizingFunction> = <::bevy_ui::MaxTrackSizingFunction as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::MaxTrackSizingFunction = <::bevy_ui::MaxTrackSizingFunction as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5307,9 +5074,8 @@ pub(crate) fn register_max_track_sizing_function_functions(world: &mut World) { { let output: bool = <::bevy_ui::MaxTrackSizingFunction as ::std::cmp::PartialEq< ::bevy_ui::MaxTrackSizingFunction, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -5334,11 +5100,10 @@ pub(crate) fn register_min_track_sizing_function_functions(world: &mut World) { |_self: Ref<::bevy_ui::MinTrackSizingFunction>| { let output: Val<::bevy_ui::MinTrackSizingFunction> = { { - let output: Val<::bevy_ui::MinTrackSizingFunction> = <::bevy_ui::MinTrackSizingFunction as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::MinTrackSizingFunction = <::bevy_ui::MinTrackSizingFunction as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5356,9 +5121,8 @@ pub(crate) fn register_min_track_sizing_function_functions(world: &mut World) { { let output: bool = <::bevy_ui::MinTrackSizingFunction as ::std::cmp::PartialEq< ::bevy_ui::MinTrackSizingFunction, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -5384,10 +5148,9 @@ pub(crate) fn register_overflow_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui::Overflow as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5400,9 +5163,8 @@ pub(crate) fn register_overflow_functions(world: &mut World) { || { let output: Val<::bevy_ui::Overflow> = { { - let output: Val<::bevy_ui::Overflow> = ::bevy_ui::Overflow::clip() - .into(); - output + let output: ::bevy_ui::Overflow = ::bevy_ui::Overflow::clip(); + safe_transmute(output) } }; output @@ -5415,9 +5177,8 @@ pub(crate) fn register_overflow_functions(world: &mut World) { || { let output: Val<::bevy_ui::Overflow> = { { - let output: Val<::bevy_ui::Overflow> = ::bevy_ui::Overflow::clip_x() - .into(); - output + let output: ::bevy_ui::Overflow = ::bevy_ui::Overflow::clip_x(); + safe_transmute(output) } }; output @@ -5430,9 +5191,8 @@ pub(crate) fn register_overflow_functions(world: &mut World) { || { let output: Val<::bevy_ui::Overflow> = { { - let output: Val<::bevy_ui::Overflow> = ::bevy_ui::Overflow::clip_y() - .into(); - output + let output: ::bevy_ui::Overflow = ::bevy_ui::Overflow::clip_y(); + safe_transmute(output) } }; output @@ -5445,11 +5205,10 @@ pub(crate) fn register_overflow_functions(world: &mut World) { |_self: Ref<::bevy_ui::Overflow>| { let output: Val<::bevy_ui::Overflow> = { { - let output: Val<::bevy_ui::Overflow> = <::bevy_ui::Overflow as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::Overflow = <::bevy_ui::Overflow as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5464,9 +5223,8 @@ pub(crate) fn register_overflow_functions(world: &mut World) { { let output: bool = <::bevy_ui::Overflow as ::std::cmp::PartialEq< ::bevy_ui::Overflow, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -5479,9 +5237,8 @@ pub(crate) fn register_overflow_functions(world: &mut World) { || { let output: Val<::bevy_ui::Overflow> = { { - let output: Val<::bevy_ui::Overflow> = ::bevy_ui::Overflow::hidden() - .into(); - output + let output: ::bevy_ui::Overflow = ::bevy_ui::Overflow::hidden(); + safe_transmute(output) } }; output @@ -5494,9 +5251,8 @@ pub(crate) fn register_overflow_functions(world: &mut World) { || { let output: Val<::bevy_ui::Overflow> = { { - let output: Val<::bevy_ui::Overflow> = ::bevy_ui::Overflow::hidden_x() - .into(); - output + let output: ::bevy_ui::Overflow = ::bevy_ui::Overflow::hidden_x(); + safe_transmute(output) } }; output @@ -5509,9 +5265,8 @@ pub(crate) fn register_overflow_functions(world: &mut World) { || { let output: Val<::bevy_ui::Overflow> = { { - let output: Val<::bevy_ui::Overflow> = ::bevy_ui::Overflow::hidden_y() - .into(); - output + let output: ::bevy_ui::Overflow = ::bevy_ui::Overflow::hidden_y(); + safe_transmute(output) } }; output @@ -5524,9 +5279,10 @@ pub(crate) fn register_overflow_functions(world: &mut World) { |_self: Ref<::bevy_ui::Overflow>| { let output: bool = { { - let output: bool = ::bevy_ui::Overflow::is_visible(&_self) - .into(); - output + let output: bool = ::bevy_ui::Overflow::is_visible( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5539,9 +5295,8 @@ pub(crate) fn register_overflow_functions(world: &mut World) { || { let output: Val<::bevy_ui::Overflow> = { { - let output: Val<::bevy_ui::Overflow> = ::bevy_ui::Overflow::scroll() - .into(); - output + let output: ::bevy_ui::Overflow = ::bevy_ui::Overflow::scroll(); + safe_transmute(output) } }; output @@ -5554,9 +5309,8 @@ pub(crate) fn register_overflow_functions(world: &mut World) { || { let output: Val<::bevy_ui::Overflow> = { { - let output: Val<::bevy_ui::Overflow> = ::bevy_ui::Overflow::scroll_x() - .into(); - output + let output: ::bevy_ui::Overflow = ::bevy_ui::Overflow::scroll_x(); + safe_transmute(output) } }; output @@ -5569,9 +5323,8 @@ pub(crate) fn register_overflow_functions(world: &mut World) { || { let output: Val<::bevy_ui::Overflow> = { { - let output: Val<::bevy_ui::Overflow> = ::bevy_ui::Overflow::scroll_y() - .into(); - output + let output: ::bevy_ui::Overflow = ::bevy_ui::Overflow::scroll_y(); + safe_transmute(output) } }; output @@ -5584,9 +5337,8 @@ pub(crate) fn register_overflow_functions(world: &mut World) { || { let output: Val<::bevy_ui::Overflow> = { { - let output: Val<::bevy_ui::Overflow> = ::bevy_ui::Overflow::visible() - .into(); - output + let output: ::bevy_ui::Overflow = ::bevy_ui::Overflow::visible(); + safe_transmute(output) } }; output @@ -5611,9 +5363,8 @@ pub(crate) fn register_overflow_clip_margin_functions(world: &mut World) { || { let output: Val<::bevy_ui::OverflowClipMargin> = { { - let output: Val<::bevy_ui::OverflowClipMargin> = ::bevy_ui::OverflowClipMargin::border_box() - .into(); - output + let output: ::bevy_ui::OverflowClipMargin = ::bevy_ui::OverflowClipMargin::border_box(); + safe_transmute(output) } }; output @@ -5626,11 +5377,10 @@ pub(crate) fn register_overflow_clip_margin_functions(world: &mut World) { |_self: Ref<::bevy_ui::OverflowClipMargin>| { let output: Val<::bevy_ui::OverflowClipMargin> = { { - let output: Val<::bevy_ui::OverflowClipMargin> = <::bevy_ui::OverflowClipMargin as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::OverflowClipMargin = <::bevy_ui::OverflowClipMargin as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5643,9 +5393,8 @@ pub(crate) fn register_overflow_clip_margin_functions(world: &mut World) { || { let output: Val<::bevy_ui::OverflowClipMargin> = { { - let output: Val<::bevy_ui::OverflowClipMargin> = ::bevy_ui::OverflowClipMargin::content_box() - .into(); - output + let output: ::bevy_ui::OverflowClipMargin = ::bevy_ui::OverflowClipMargin::content_box(); + safe_transmute(output) } }; output @@ -5663,9 +5412,8 @@ pub(crate) fn register_overflow_clip_margin_functions(world: &mut World) { { let output: bool = <::bevy_ui::OverflowClipMargin as ::std::cmp::PartialEq< ::bevy_ui::OverflowClipMargin, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -5678,9 +5426,8 @@ pub(crate) fn register_overflow_clip_margin_functions(world: &mut World) { || { let output: Val<::bevy_ui::OverflowClipMargin> = { { - let output: Val<::bevy_ui::OverflowClipMargin> = ::bevy_ui::OverflowClipMargin::padding_box() - .into(); - output + let output: ::bevy_ui::OverflowClipMargin = ::bevy_ui::OverflowClipMargin::padding_box(); + safe_transmute(output) } }; output @@ -5693,12 +5440,11 @@ pub(crate) fn register_overflow_clip_margin_functions(world: &mut World) { |_self: Val<::bevy_ui::OverflowClipMargin>, margin: f32| { let output: Val<::bevy_ui::OverflowClipMargin> = { { - let output: Val<::bevy_ui::OverflowClipMargin> = ::bevy_ui::OverflowClipMargin::with_margin( - _self.into_inner(), - margin, - ) - .into(); - output + let output: ::bevy_ui::OverflowClipMargin = ::bevy_ui::OverflowClipMargin::with_margin( + safe_transmute(_self), + safe_transmute(margin), + ); + safe_transmute(output) } }; output @@ -5724,10 +5470,9 @@ pub(crate) fn register_global_z_index_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui::GlobalZIndex as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5740,11 +5485,10 @@ pub(crate) fn register_global_z_index_functions(world: &mut World) { |_self: Ref<::bevy_ui::GlobalZIndex>| { let output: Val<::bevy_ui::GlobalZIndex> = { { - let output: Val<::bevy_ui::GlobalZIndex> = <::bevy_ui::GlobalZIndex as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::GlobalZIndex = <::bevy_ui::GlobalZIndex as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5759,9 +5503,8 @@ pub(crate) fn register_global_z_index_functions(world: &mut World) { { let output: bool = <::bevy_ui::GlobalZIndex as ::std::cmp::PartialEq< ::bevy_ui::GlobalZIndex, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -5787,10 +5530,9 @@ pub(crate) fn register_z_index_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui::ZIndex as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5803,11 +5545,10 @@ pub(crate) fn register_z_index_functions(world: &mut World) { |_self: Ref<::bevy_ui::ZIndex>| { let output: Val<::bevy_ui::ZIndex> = { { - let output: Val<::bevy_ui::ZIndex> = <::bevy_ui::ZIndex as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::ZIndex = <::bevy_ui::ZIndex as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5822,9 +5563,8 @@ pub(crate) fn register_z_index_functions(world: &mut World) { { let output: bool = <::bevy_ui::ZIndex as ::std::cmp::PartialEq< ::bevy_ui::ZIndex, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -5849,11 +5589,10 @@ pub(crate) fn register_resolved_border_radius_functions(world: &mut World) { |_self: Ref<::bevy_ui::ResolvedBorderRadius>| { let output: Val<::bevy_ui::ResolvedBorderRadius> = { { - let output: Val<::bevy_ui::ResolvedBorderRadius> = <::bevy_ui::ResolvedBorderRadius as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::ResolvedBorderRadius = <::bevy_ui::ResolvedBorderRadius as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5871,9 +5610,8 @@ pub(crate) fn register_resolved_border_radius_functions(world: &mut World) { { let output: bool = <::bevy_ui::ResolvedBorderRadius as ::std::cmp::PartialEq< ::bevy_ui::ResolvedBorderRadius, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -5898,11 +5636,10 @@ pub(crate) fn register_background_color_functions(world: &mut World) { |_self: Ref<::bevy_ui::BackgroundColor>| { let output: Val<::bevy_ui::BackgroundColor> = { { - let output: Val<::bevy_ui::BackgroundColor> = <::bevy_ui::BackgroundColor as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::BackgroundColor = <::bevy_ui::BackgroundColor as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5920,9 +5657,8 @@ pub(crate) fn register_background_color_functions(world: &mut World) { { let output: bool = <::bevy_ui::BackgroundColor as ::std::cmp::PartialEq< ::bevy_ui::BackgroundColor, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -5947,11 +5683,10 @@ pub(crate) fn register_border_color_functions(world: &mut World) { |_self: Ref<::bevy_ui::BorderColor>| { let output: Val<::bevy_ui::BorderColor> = { { - let output: Val<::bevy_ui::BorderColor> = <::bevy_ui::BorderColor as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::BorderColor = <::bevy_ui::BorderColor as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -5966,9 +5701,8 @@ pub(crate) fn register_border_color_functions(world: &mut World) { { let output: bool = <::bevy_ui::BorderColor as ::std::cmp::PartialEq< ::bevy_ui::BorderColor, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -5982,10 +5716,9 @@ pub(crate) fn register_border_color_functions(world: &mut World) { let output: bool = { { let output: bool = ::bevy_ui::BorderColor::is_fully_transparent( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6010,11 +5743,10 @@ pub(crate) fn register_box_shadow_functions(world: &mut World) { |_self: Ref<::bevy_ui::BoxShadow>| { let output: Val<::bevy_ui::BoxShadow> = { { - let output: Val<::bevy_ui::BoxShadow> = <::bevy_ui::BoxShadow as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::BoxShadow = <::bevy_ui::BoxShadow as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6029,9 +5761,8 @@ pub(crate) fn register_box_shadow_functions(world: &mut World) { { let output: bool = <::bevy_ui::BoxShadow as ::std::cmp::PartialEq< ::bevy_ui::BoxShadow, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -6050,15 +5781,14 @@ pub(crate) fn register_box_shadow_functions(world: &mut World) { { let output: Val<::bevy_ui::BoxShadow> = { { - let output: Val<::bevy_ui::BoxShadow> = ::bevy_ui::BoxShadow::new( - color.into_inner(), - x_offset.into_inner(), - y_offset.into_inner(), - spread_radius.into_inner(), - blur_radius.into_inner(), - ) - .into(); - output + let output: ::bevy_ui::BoxShadow = ::bevy_ui::BoxShadow::new( + safe_transmute(color), + safe_transmute(x_offset), + safe_transmute(y_offset), + safe_transmute(spread_radius), + safe_transmute(blur_radius), + ); + safe_transmute(output) } }; output @@ -6083,11 +5813,10 @@ pub(crate) fn register_shadow_style_functions(world: &mut World) { |_self: Ref<::bevy_ui::ShadowStyle>| { let output: Val<::bevy_ui::ShadowStyle> = { { - let output: Val<::bevy_ui::ShadowStyle> = <::bevy_ui::ShadowStyle as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui::ShadowStyle = <::bevy_ui::ShadowStyle as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -6102,9 +5831,8 @@ pub(crate) fn register_shadow_style_functions(world: &mut World) { { let output: bool = <::bevy_ui::ShadowStyle as ::std::cmp::PartialEq< ::bevy_ui::ShadowStyle, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output diff --git a/crates/bindings/bevy_ui_render_bms_bindings/src/lib.rs b/crates/bindings/bevy_ui_render_bms_bindings/src/lib.rs index d2db5cee1f..ddb13f9d92 100644 --- a/crates/bindings/bevy_ui_render_bms_bindings/src/lib.rs +++ b/crates/bindings/bevy_ui_render_bms_bindings/src/lib.rs @@ -8,7 +8,7 @@ use bevy_mod_scripting_bindings::{ ReflectReference, function::{ from::{Ref, Mut, Val}, - namespace::NamespaceBuilder, + namespace::NamespaceBuilder, glue::safe_transmute, }, }; use bevy_ecs::prelude::*; @@ -25,10 +25,9 @@ pub(crate) fn register_box_shadow_samples_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui_render::BoxShadowSamples as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -41,11 +40,10 @@ pub(crate) fn register_box_shadow_samples_functions(world: &mut World) { |_self: Ref<::bevy_ui_render::BoxShadowSamples>| { let output: Val<::bevy_ui_render::BoxShadowSamples> = { { - let output: Val<::bevy_ui_render::BoxShadowSamples> = <::bevy_ui_render::BoxShadowSamples as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui_render::BoxShadowSamples = <::bevy_ui_render::BoxShadowSamples as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -63,9 +61,8 @@ pub(crate) fn register_box_shadow_samples_functions(world: &mut World) { { let output: bool = <::bevy_ui_render::BoxShadowSamples as ::std::cmp::PartialEq< ::bevy_ui_render::BoxShadowSamples, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output @@ -91,10 +88,9 @@ pub(crate) fn register_ui_anti_alias_functions(world: &mut World) { let output: () = { { let output: () = <::bevy_ui_render::UiAntiAlias as ::std::cmp::Eq>::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -107,11 +103,10 @@ pub(crate) fn register_ui_anti_alias_functions(world: &mut World) { |_self: Ref<::bevy_ui_render::UiAntiAlias>| { let output: Val<::bevy_ui_render::UiAntiAlias> = { { - let output: Val<::bevy_ui_render::UiAntiAlias> = <::bevy_ui_render::UiAntiAlias as ::std::clone::Clone>::clone( - &_self, - ) - .into(); - output + let output: ::bevy_ui_render::UiAntiAlias = <::bevy_ui_render::UiAntiAlias as ::std::clone::Clone>::clone( + safe_transmute(_self), + ); + safe_transmute(output) } }; output @@ -129,9 +124,8 @@ pub(crate) fn register_ui_anti_alias_functions(world: &mut World) { { let output: bool = <::bevy_ui_render::UiAntiAlias as ::std::cmp::PartialEq< ::bevy_ui_render::UiAntiAlias, - >>::eq(&_self, &other) - .into(); - output + >>::eq(safe_transmute(_self), safe_transmute(other)); + safe_transmute(output) } }; output