From e8da279b6653a02a67563b5a673939fbbb6b3050 Mon Sep 17 00:00:00 2001 From: makspll Date: Thu, 6 Nov 2025 22:23:27 +0000 Subject: [PATCH 01/20] 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/20] 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/20] 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/20] 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/20] 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/20] 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/20] 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/20] 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/20] 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/20] 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/20] 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/20] 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/20] 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/20] 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/20] 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/20] 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/20] 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/20] 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/20] 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/20] 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}