From 8d9cf760e819656a6814c84cd801b033d7e78436 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Mon, 13 Jan 2025 22:40:21 +0000 Subject: [PATCH] chore(codegen): update bevy bindings --- .../src/bevy_bindings/bevy_core.rs | 20 +- .../src/bevy_bindings/bevy_ecs.rs | 148 +- .../src/bevy_bindings/bevy_hierarchy.rs | 44 +- .../src/bevy_bindings/bevy_input.rs | 740 +- .../src/bevy_bindings/bevy_math.rs | 2082 +- .../src/bevy_bindings/bevy_reflect.rs | 18100 ++++++++-------- .../src/bevy_bindings/bevy_time.rs | 196 +- .../src/bevy_bindings/bevy_transform.rs | 192 +- 8 files changed, 10761 insertions(+), 10761 deletions(-) diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_core.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_core.rs index 40d8b76363..d63e530405 100644 --- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_core.rs +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_core.rs @@ -20,6 +20,16 @@ impl ::bevy::app::Plugin for BevyCoreScriptingPlugin { fn build(&self, app: &mut ::bevy::prelude::App) { let mut world = app.world_mut(); NamespaceBuilder::<::bevy::core::prelude::Name>::new(world) + .register( + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) + .into(); + output + }, + ) .register( "eq", | @@ -32,16 +42,6 @@ impl ::bevy::app::Plugin for BevyCoreScriptingPlugin { .into(); output }, - ) - .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); - output - }, ); } } diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_ecs.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_ecs.rs index 6187685017..7a024becf5 100644 --- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_ecs.rs +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_ecs.rs @@ -20,21 +20,24 @@ impl ::bevy::app::Plugin for BevyEcsScriptingPlugin { let mut world = app.world_mut(); NamespaceBuilder::<::bevy::ecs::entity::Entity>::new(world) .register( - "from_raw", - |index: u32| { - let output: Val = bevy::ecs::entity::Entity::from_raw( - index, + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, ) .into(); output }, ) .register( - "to_bits", - |_self: Val| { - let output: u64 = bevy::ecs::entity::Entity::to_bits( - _self.into_inner(), - ) + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) .into(); output }, @@ -50,10 +53,10 @@ impl ::bevy::app::Plugin for BevyEcsScriptingPlugin { }, ) .register( - "index", - |_self: Val| { - let output: u32 = bevy::ecs::entity::Entity::index( - _self.into_inner(), + "from_raw", + |index: u32| { + let output: Val = bevy::ecs::entity::Entity::from_raw( + index, ) .into(); output @@ -70,24 +73,21 @@ impl ::bevy::app::Plugin for BevyEcsScriptingPlugin { }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, + "index", + |_self: Val| { + let output: u32 = bevy::ecs::entity::Entity::index( + _self.into_inner(), ) .into(); output }, ) .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) + "to_bits", + |_self: Val| { + let output: u64 = bevy::ecs::entity::Entity::to_bits( + _self.into_inner(), + ) .into(); output }, @@ -107,6 +107,16 @@ impl ::bevy::app::Plugin for BevyEcsScriptingPlugin { output }, ) + .register( + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) + .into(); + output + }, + ) .register( "eq", | @@ -121,10 +131,10 @@ impl ::bevy::app::Plugin for BevyEcsScriptingPlugin { }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, + "index", + |_self: Val| { + let output: usize = bevy::ecs::component::ComponentId::index( + _self.into_inner(), ) .into(); output @@ -139,22 +149,22 @@ impl ::bevy::app::Plugin for BevyEcsScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::ecs::component::Tick>::new(world) .register( - "index", - |_self: Val| { - let output: usize = bevy::ecs::component::ComponentId::index( - _self.into_inner(), + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( + &_self, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::ecs::component::Tick>::new(world) + ) .register( - "assert_receiver_is_total_eq", + "clone", |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( + let output: Val = ::clone( &_self, ) .into(); @@ -174,16 +184,6 @@ impl ::bevy::app::Plugin for BevyEcsScriptingPlugin { output }, ) - .register( - "new", - |tick: u32| { - let output: Val = bevy::ecs::component::Tick::new( - tick, - ) - .into(); - output - }, - ) .register( "get", |_self: Val| { @@ -192,14 +192,6 @@ impl ::bevy::app::Plugin for BevyEcsScriptingPlugin { output }, ) - .register( - "set", - |mut _self: Mut, tick: u32| { - let output: () = bevy::ecs::component::Tick::set(&mut _self, tick) - .into(); - output - }, - ) .register( "is_newer_than", | @@ -217,14 +209,22 @@ impl ::bevy::app::Plugin for BevyEcsScriptingPlugin { }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, + "new", + |tick: u32| { + let output: Val = bevy::ecs::component::Tick::new( + tick, ) .into(); output }, + ) + .register( + "set", + |mut _self: Mut, tick: u32| { + let output: () = bevy::ecs::component::Tick::set(&mut _self, tick) + .into(); + output + }, ); NamespaceBuilder::<::bevy::ecs::component::ComponentTicks>::new(world) .register( @@ -294,6 +294,16 @@ impl ::bevy::app::Plugin for BevyEcsScriptingPlugin { }, ); NamespaceBuilder::<::bevy::ecs::identifier::Identifier>::new(world) + .register( + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) + .into(); + output + }, + ) .register( "eq", | @@ -308,10 +318,10 @@ impl ::bevy::app::Plugin for BevyEcsScriptingPlugin { }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, + "from_bits", + |value: u64| { + let output: Val = bevy::ecs::identifier::Identifier::from_bits( + value, ) .into(); output @@ -346,16 +356,6 @@ impl ::bevy::app::Plugin for BevyEcsScriptingPlugin { .into(); output }, - ) - .register( - "from_bits", - |value: u64| { - let output: Val = bevy::ecs::identifier::Identifier::from_bits( - value, - ) - .into(); - output - }, ); NamespaceBuilder::<::bevy::ecs::entity::EntityHash>::new(world) .register( diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_hierarchy.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_hierarchy.rs index a47dda82c9..d3795e583b 100644 --- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_hierarchy.rs +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_hierarchy.rs @@ -38,6 +38,16 @@ impl ::bevy::app::Plugin for BevyHierarchyScriptingPlugin { }, ); NamespaceBuilder::<::bevy::hierarchy::prelude::Parent>::new(world) + .register( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + }, + ) .register( "eq", | @@ -50,30 +60,17 @@ impl ::bevy::app::Plugin for BevyHierarchyScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::hierarchy::HierarchyEvent>::new(world) .register( "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( &_self, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::hierarchy::HierarchyEvent>::new(world) - .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) - .into(); - output - }, ) .register( "clone", @@ -86,11 +83,14 @@ impl ::bevy::app::Plugin for BevyHierarchyScriptingPlugin { }, ) .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, - ) + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) .into(); output }, diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_input.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_input.rs index f26675ec8f..0cc7e22b21 100644 --- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_input.rs +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_input.rs @@ -23,20 +23,28 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { let mut world = app.world_mut(); NamespaceBuilder::<::bevy::input::gamepad::Gamepad>::new(world) .register( - "vendor_id", - |_self: Ref| { - let output: std::option::Option = bevy::input::gamepad::Gamepad::vendor_id( + "just_pressed", + | + _self: Ref, + button_type: Val| + { + let output: bool = bevy::input::gamepad::Gamepad::just_pressed( &_self, + button_type.into_inner(), ) .into(); output }, ) .register( - "product_id", - |_self: Ref| { - let output: std::option::Option = bevy::input::gamepad::Gamepad::product_id( + "just_released", + | + _self: Ref, + button_type: Val| + { + let output: bool = bevy::input::gamepad::Gamepad::just_released( &_self, + button_type.into_inner(), ) .into(); output @@ -57,28 +65,20 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { }, ) .register( - "just_pressed", - | - _self: Ref, - button_type: Val| - { - let output: bool = bevy::input::gamepad::Gamepad::just_pressed( + "product_id", + |_self: Ref| { + let output: std::option::Option = bevy::input::gamepad::Gamepad::product_id( &_self, - button_type.into_inner(), ) .into(); output }, ) .register( - "just_released", - | - _self: Ref, - button_type: Val| - { - let output: bool = bevy::input::gamepad::Gamepad::just_released( + "vendor_id", + |_self: Ref| { + let output: std::option::Option = bevy::input::gamepad::Gamepad::vendor_id( &_self, - button_type.into_inner(), ) .into(); output @@ -86,9 +86,9 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { ); NamespaceBuilder::<::bevy::input::gamepad::GamepadAxis>::new(world) .register( - "clone", + "assert_receiver_is_total_eq", |_self: Ref| { - let output: Val = ::clone( + let output: () = ::assert_receiver_is_total_eq( &_self, ) .into(); @@ -96,9 +96,9 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { }, ) .register( - "assert_receiver_is_total_eq", + "clone", |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( + let output: Val = ::clone( &_self, ) .into(); @@ -119,19 +119,6 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { }, ); NamespaceBuilder::<::bevy::input::gamepad::GamepadButton>::new(world) - .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) - .into(); - output - }, - ) .register( "assert_receiver_is_total_eq", |_self: Ref| { @@ -151,6 +138,19 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, + ) + .register( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) + .into(); + output + }, ); NamespaceBuilder::<::bevy::input::gamepad::GamepadSettings>::new(world) .register( @@ -165,14 +165,11 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { ); NamespaceBuilder::<::bevy::input::keyboard::KeyCode>::new(world) .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( + &_self, + ) .into(); output }, @@ -188,20 +185,23 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { }, ) .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, - ) + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) .into(); output }, ); NamespaceBuilder::<::bevy::input::mouse::MouseButton>::new(world) .register( - "clone", + "assert_receiver_is_total_eq", |_self: Ref| { - let output: Val = ::clone( + let output: () = ::assert_receiver_is_total_eq( &_self, ) .into(); @@ -209,9 +209,9 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { }, ) .register( - "assert_receiver_is_total_eq", + "clone", |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( + let output: Val = ::clone( &_self, ) .into(); @@ -256,6 +256,16 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { }, ); NamespaceBuilder::<::bevy::input::keyboard::KeyboardFocusLost>::new(world) + .register( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + }, + ) .register( "clone", |_self: Ref| { @@ -278,18 +288,28 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::input::keyboard::KeyboardInput>::new(world) .register( "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( &_self, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::input::keyboard::KeyboardInput>::new(world) + ) + .register( + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) + .into(); + output + }, + ) .register( "eq", | @@ -302,28 +322,18 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, - ) - .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - }, - ) + ); + NamespaceBuilder::<::bevy::input::mouse::AccumulatedMouseMotion>::new(world) .register( "clone", - |_self: Ref| { - let output: Val = ::clone( + |_self: Ref| { + let output: Val = ::clone( &_self, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::input::mouse::AccumulatedMouseMotion>::new(world) + ) .register( "eq", | @@ -336,18 +346,18 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::input::mouse::AccumulatedMouseScroll>::new(world) .register( "clone", - |_self: Ref| { - let output: Val = ::clone( + |_self: Ref| { + let output: Val = ::clone( &_self, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::input::mouse::AccumulatedMouseScroll>::new(world) + ) .register( "eq", | @@ -360,22 +370,12 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, - ) - .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); - output - }, ); NamespaceBuilder::<::bevy::input::mouse::MouseButtonInput>::new(world) .register( - "clone", + "assert_receiver_is_total_eq", |_self: Ref| { - let output: Val = ::clone( + let output: () = ::assert_receiver_is_total_eq( &_self, ) .into(); @@ -383,9 +383,9 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { }, ) .register( - "assert_receiver_is_total_eq", + "clone", |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( + let output: Val = ::clone( &_self, ) .into(); @@ -406,6 +406,16 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { }, ); NamespaceBuilder::<::bevy::input::mouse::MouseMotion>::new(world) + .register( + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) + .into(); + output + }, + ) .register( "eq", | @@ -418,16 +428,6 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, - ) - .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); - output - }, ); NamespaceBuilder::<::bevy::input::mouse::MouseWheel>::new(world) .register( @@ -454,6 +454,16 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { }, ); NamespaceBuilder::<::bevy::input::gamepad::GamepadAxisChangedEvent>::new(world) + .register( + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) + .into(); + output + }, + ) .register( "eq", | @@ -466,18 +476,18 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::input::gamepad::GamepadButtonChangedEvent>::new(world) .register( "clone", - |_self: Ref| { - let output: Val = ::clone( + |_self: Ref| { + let output: Val = ::clone( &_self, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::input::gamepad::GamepadButtonChangedEvent>::new(world) + ) .register( "eq", | @@ -490,20 +500,20 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::< + ::bevy::input::gamepad::GamepadButtonStateChangedEvent, + >::new(world) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( &_self, ) .into(); output }, - ); - NamespaceBuilder::< - ::bevy::input::gamepad::GamepadButtonStateChangedEvent, - >::new(world) + ) .register( "clone", |_self: Ref| { @@ -528,18 +538,18 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::input::gamepad::GamepadConnection>::new(world) .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( + "clone", + |_self: Ref| { + let output: Val = ::clone( &_self, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::input::gamepad::GamepadConnection>::new(world) + ) .register( "eq", | @@ -552,16 +562,6 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, - ) - .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); - output - }, ); NamespaceBuilder::<::bevy::input::gamepad::GamepadConnectionEvent>::new(world) .register( @@ -574,19 +574,6 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { output }, ) - .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) - .into(); - output - }, - ) .register( "connected", |_self: Ref| { @@ -606,21 +593,21 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, - ); - NamespaceBuilder::<::bevy::input::gamepad::GamepadEvent>::new(world) + ) .register( "eq", | - _self: Ref, - other: Ref| + _self: Ref, + other: Ref| { - let output: bool = >::eq(&_self, &other) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::input::gamepad::GamepadEvent>::new(world) .register( "clone", |_self: Ref| { @@ -630,25 +617,25 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, - ); - NamespaceBuilder::<::bevy::input::gamepad::GamepadInput>::new(world) + ) .register( "eq", | - _self: Ref, - other: Ref| + _self: Ref, + other: Ref| { - let output: bool = >::eq(&_self, &other) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::input::gamepad::GamepadInput>::new(world) .register( - "clone", + "assert_receiver_is_total_eq", |_self: Ref| { - let output: Val = ::clone( + let output: () = ::assert_receiver_is_total_eq( &_self, ) .into(); @@ -656,14 +643,27 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { }, ) .register( - "assert_receiver_is_total_eq", + "clone", |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( + let output: Val = ::clone( &_self, ) .into(); output }, + ) + .register( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) + .into(); + output + }, ); NamespaceBuilder::<::bevy::input::gamepad::GamepadRumbleRequest>::new(world) .register( @@ -679,6 +679,16 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { NamespaceBuilder::< ::bevy::input::gamepad::RawGamepadAxisChangedEvent, >::new(world) + .register( + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) + .into(); + output + }, + ) .register( "eq", | @@ -691,20 +701,22 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::< + ::bevy::input::gamepad::RawGamepadButtonChangedEvent, + >::new(world) .register( "clone", - |_self: Ref| { - let output: Val = ::clone( + |_self: Ref| { + let output: Val< + bevy::input::gamepad::RawGamepadButtonChangedEvent, + > = ::clone( &_self, ) .into(); output }, - ); - NamespaceBuilder::< - ::bevy::input::gamepad::RawGamepadButtonChangedEvent, - >::new(world) + ) .register( "eq", | @@ -717,20 +729,18 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::input::gamepad::RawGamepadEvent>::new(world) .register( "clone", - |_self: Ref| { - let output: Val< - bevy::input::gamepad::RawGamepadButtonChangedEvent, - > = ::clone( + |_self: Ref| { + let output: Val = ::clone( &_self, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::input::gamepad::RawGamepadEvent>::new(world) + ) .register( "eq", | @@ -743,18 +753,18 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::input::gestures::PinchGesture>::new(world) .register( "clone", - |_self: Ref| { - let output: Val = ::clone( + |_self: Ref| { + let output: Val = ::clone( &_self, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::input::gestures::PinchGesture>::new(world) + ) .register( "eq", | @@ -767,18 +777,18 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::input::gestures::RotationGesture>::new(world) .register( "clone", - |_self: Ref| { - let output: Val = ::clone( + |_self: Ref| { + let output: Val = ::clone( &_self, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::input::gestures::RotationGesture>::new(world) + ) .register( "eq", | @@ -791,16 +801,6 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, - ) - .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); - output - }, ); NamespaceBuilder::<::bevy::input::gestures::DoubleTapGesture>::new(world) .register( @@ -827,6 +827,16 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { }, ); NamespaceBuilder::<::bevy::input::gestures::PanGesture>::new(world) + .register( + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) + .into(); + output + }, + ) .register( "eq", | @@ -839,18 +849,28 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, + ); + NamespaceBuilder::<::bevy::input::ButtonState>::new(world) + .register( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + }, ) .register( "clone", - |_self: Ref| { - let output: Val = ::clone( + |_self: Ref| { + let output: Val = ::clone( &_self, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::input::ButtonState>::new(world) + ) .register( "eq", | @@ -864,16 +884,6 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { output }, ) - .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); - output - }, - ) .register( "is_pressed", |_self: Ref| { @@ -881,16 +891,6 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, - ) - .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - }, ); NamespaceBuilder::<::bevy::input::gamepad::ButtonSettings>::new(world) .register( @@ -903,6 +903,19 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { output }, ) + .register( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) + .into(); + output + }, + ) .register( "is_pressed", |_self: Ref, value: f32| { @@ -936,21 +949,21 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { }, ) .register( - "set_press_threshold", - |mut _self: Mut, value: f32| { - let output: f32 = bevy::input::gamepad::ButtonSettings::set_press_threshold( - &mut _self, - value, + "release_threshold", + |_self: Ref| { + let output: f32 = bevy::input::gamepad::ButtonSettings::release_threshold( + &_self, ) .into(); output }, ) .register( - "release_threshold", - |_self: Ref| { - let output: f32 = bevy::input::gamepad::ButtonSettings::release_threshold( - &_self, + "set_press_threshold", + |mut _self: Mut, value: f32| { + let output: f32 = bevy::input::gamepad::ButtonSettings::set_press_threshold( + &mut _self, + value, ) .into(); output @@ -966,25 +979,23 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::input::gamepad::AxisSettings>::new(world) .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) + "clamp", + |_self: Ref, new_value: f32| { + let output: f32 = bevy::input::gamepad::AxisSettings::clamp( + &_self, + new_value, + ) .into(); output }, - ); - NamespaceBuilder::<::bevy::input::gamepad::AxisSettings>::new(world) + ) .register( - "livezone_upperbound", + "clone", |_self: Ref| { - let output: f32 = bevy::input::gamepad::AxisSettings::livezone_upperbound( + let output: Val = ::clone( &_self, ) .into(); @@ -992,11 +1003,10 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { }, ) .register( - "set_livezone_upperbound", - |mut _self: Mut, value: f32| { - let output: f32 = bevy::input::gamepad::AxisSettings::set_livezone_upperbound( - &mut _self, - value, + "deadzone_lowerbound", + |_self: Ref| { + let output: f32 = bevy::input::gamepad::AxisSettings::deadzone_lowerbound( + &_self, ) .into(); output @@ -1013,41 +1023,48 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { }, ) .register( - "set_deadzone_upperbound", - |mut _self: Mut, value: f32| { - let output: f32 = bevy::input::gamepad::AxisSettings::set_deadzone_upperbound( - &mut _self, - value, - ) + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "livezone_lowerbound", - |_self: Ref| { - let output: f32 = bevy::input::gamepad::AxisSettings::livezone_lowerbound( + "filter", + | + _self: Ref, + new_value: f32, + old_value: std::option::Option| + { + let output: std::option::Option = bevy::input::gamepad::AxisSettings::filter( &_self, + new_value, + old_value, ) .into(); output }, ) .register( - "set_livezone_lowerbound", - |mut _self: Mut, value: f32| { - let output: f32 = bevy::input::gamepad::AxisSettings::set_livezone_lowerbound( - &mut _self, - value, + "livezone_lowerbound", + |_self: Ref| { + let output: f32 = bevy::input::gamepad::AxisSettings::livezone_lowerbound( + &_self, ) .into(); output }, ) .register( - "deadzone_lowerbound", + "livezone_upperbound", |_self: Ref| { - let output: f32 = bevy::input::gamepad::AxisSettings::deadzone_lowerbound( + let output: f32 = bevy::input::gamepad::AxisSettings::livezone_upperbound( &_self, ) .into(); @@ -1066,19 +1083,20 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { }, ) .register( - "threshold", - |_self: Ref| { - let output: f32 = bevy::input::gamepad::AxisSettings::threshold( - &_self, + "set_deadzone_upperbound", + |mut _self: Mut, value: f32| { + let output: f32 = bevy::input::gamepad::AxisSettings::set_deadzone_upperbound( + &mut _self, + value, ) .into(); output }, ) .register( - "set_threshold", + "set_livezone_lowerbound", |mut _self: Mut, value: f32| { - let output: f32 = bevy::input::gamepad::AxisSettings::set_threshold( + let output: f32 = bevy::input::gamepad::AxisSettings::set_livezone_lowerbound( &mut _self, value, ) @@ -1087,49 +1105,31 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { }, ) .register( - "clamp", - |_self: Ref, new_value: f32| { - let output: f32 = bevy::input::gamepad::AxisSettings::clamp( - &_self, - new_value, + "set_livezone_upperbound", + |mut _self: Mut, value: f32| { + let output: f32 = bevy::input::gamepad::AxisSettings::set_livezone_upperbound( + &mut _self, + value, ) .into(); output }, ) .register( - "filter", - | - _self: Ref, - new_value: f32, - old_value: std::option::Option| - { - let output: std::option::Option = bevy::input::gamepad::AxisSettings::filter( - &_self, - new_value, - old_value, + "set_threshold", + |mut _self: Mut, value: f32| { + let output: f32 = bevy::input::gamepad::AxisSettings::set_threshold( + &mut _self, + value, ) .into(); output }, ) .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) - .into(); - output - }, - ) - .register( - "clone", + "threshold", |_self: Ref| { - let output: Val = ::clone( + let output: f32 = bevy::input::gamepad::AxisSettings::threshold( &_self, ) .into(); @@ -1175,11 +1175,14 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { }, ) .register( - "weak_motor", - |intensity: f32| { - let output: Val = bevy::input::gamepad::GamepadRumbleIntensity::weak_motor( - intensity, - ) + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) .into(); output }, @@ -1195,19 +1198,26 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { }, ) .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) + "weak_motor", + |intensity: f32| { + let output: Val = bevy::input::gamepad::GamepadRumbleIntensity::weak_motor( + intensity, + ) .into(); output }, ); NamespaceBuilder::<::bevy::input::keyboard::Key>::new(world) + .register( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( + &_self, + ) + .into(); + output + }, + ) .register( "clone", |_self: Ref| { @@ -1230,31 +1240,8 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, - ) - .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - }, ); NamespaceBuilder::<::bevy::input::keyboard::NativeKeyCode>::new(world) - .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) - .into(); - output - }, - ) .register( "assert_receiver_is_total_eq", |_self: Ref| { @@ -1274,21 +1261,21 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, - ); - NamespaceBuilder::<::bevy::input::keyboard::NativeKey>::new(world) + ) .register( "eq", | - _self: Ref, - other: Ref| + _self: Ref, + other: Ref| { - let output: bool = >::eq(&_self, &other) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::input::keyboard::NativeKey>::new(world) .register( "assert_receiver_is_total_eq", |_self: Ref| { @@ -1308,12 +1295,25 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, + ) + .register( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) + .into(); + output + }, ); NamespaceBuilder::<::bevy::input::mouse::MouseScrollUnit>::new(world) .register( - "clone", + "assert_receiver_is_total_eq", |_self: Ref| { - let output: Val = ::clone( + let output: () = ::assert_receiver_is_total_eq( &_self, ) .into(); @@ -1321,9 +1321,9 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { }, ) .register( - "assert_receiver_is_total_eq", + "clone", |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( + let output: Val = ::clone( &_self, ) .into(); @@ -1345,14 +1345,11 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { ); NamespaceBuilder::<::bevy::input::touch::TouchPhase>::new(world) .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( + &_self, + ) .into(); output }, @@ -1368,16 +1365,29 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { }, ) .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, - ) + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) .into(); output }, ); NamespaceBuilder::<::bevy::input::touch::ForceTouch>::new(world) + .register( + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) + .into(); + output + }, + ) .register( "eq", | @@ -1390,16 +1400,6 @@ impl ::bevy::app::Plugin for BevyInputScriptingPlugin { .into(); output }, - ) - .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); - output - }, ); } } diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_math.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_math.rs index 6558273b9a..c737c60758 100644 --- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_math.rs +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_math.rs @@ -19,19 +19,6 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { fn build(&self, app: &mut ::bevy::prelude::App) { let mut world = app.world_mut(); NamespaceBuilder::<::bevy::math::AspectRatio>::new(world) - .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) - .into(); - output - }, - ) .register( "clone", |_self: Ref| { @@ -43,9 +30,15 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "ratio", - |_self: Ref| { - let output: f32 = bevy::math::AspectRatio::ratio(&_self).into(); + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) + .into(); output }, ) @@ -81,6 +74,13 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { let output: bool = bevy::math::AspectRatio::is_square(&_self).into(); output }, + ) + .register( + "ratio", + |_self: Ref| { + let output: f32 = bevy::math::AspectRatio::ratio(&_self).into(); + output + }, ); NamespaceBuilder::<::bevy::math::CompassOctant>::new(world) .register( @@ -93,6 +93,16 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { output }, ) + .register( + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) + .into(); + output + }, + ) .register( "eq", | @@ -105,18 +115,18 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::CompassQuadrant>::new(world) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( &_self, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::CompassQuadrant>::new(world) + ) .register( "clone", |_self: Ref| { @@ -139,18 +149,28 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::Isometry2d>::new(world) .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( + "clone", + |_self: Ref| { + let output: Val = ::clone( &_self, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::Isometry2d>::new(world) + ) + .register( + "eq", + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) + .into(); + output + }, + ) .register( "from_rotation", |rotation: Val| { @@ -203,16 +223,6 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { output }, ) - .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); - output - }, - ) .register( "mul", | @@ -225,28 +235,8 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .into(); output }, - ) - .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) - .into(); - output - }, ); NamespaceBuilder::<::bevy::math::Isometry3d>::new(world) - .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) - .into(); - output - }, - ) .register( "clone", |_self: Ref| { @@ -258,24 +248,11 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "mul", - | - _self: Val, - rhs: Val| - { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output - }, - ) - .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = , other: Ref| { + let output: bool = >::mul(_self.into_inner(), rhs.into_inner()) + >>::eq(&_self, &other) .into(); output }, @@ -312,6 +289,29 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .into(); output }, + ) + .register( + "mul", + | + _self: Val, + rhs: Val| + { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + .into(); + output + }, + ) + .register( + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + .into(); + output + }, ); NamespaceBuilder::<::bevy::math::Ray2d>::new(world) .register( @@ -357,52 +357,31 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { ); NamespaceBuilder::<::bevy::math::Rot2>::new(world) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output - }, - ) - .register( - "radians", - |radians: f32| { - let output: Val = bevy::math::Rot2::radians( - radians, - ) - .into(); - output - }, - ) - .register( - "degrees", - |degrees: f32| { - let output: Val = bevy::math::Rot2::degrees( - degrees, + "angle_between", + |_self: Val, other: Val| { + let output: f32 = bevy::math::Rot2::angle_between( + _self.into_inner(), + other.into_inner(), ) .into(); output }, ) .register( - "turn_fraction", - |fraction: f32| { - let output: Val = bevy::math::Rot2::turn_fraction( - fraction, + "angle_to", + |_self: Val, other: Val| { + let output: f32 = bevy::math::Rot2::angle_to( + _self.into_inner(), + other.into_inner(), ) .into(); output }, ) .register( - "from_sin_cos", - |sin: f32, cos: f32| { - let output: Val = bevy::math::Rot2::from_sin_cos( - sin, - cos, - ) + "as_degrees", + |_self: Val| { + let output: f32 = bevy::math::Rot2::as_degrees(_self.into_inner()) .into(); output }, @@ -415,14 +394,6 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { output }, ) - .register( - "as_degrees", - |_self: Val| { - let output: f32 = bevy::math::Rot2::as_degrees(_self.into_inner()) - .into(); - output - }, - ) .register( "as_turn_fraction", |_self: Val| { @@ -434,55 +405,60 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "sin_cos", - |_self: Val| { - let output: (f32, f32) = bevy::math::Rot2::sin_cos( - _self.into_inner(), + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, ) .into(); output }, ) .register( - "length", - |_self: Val| { - let output: f32 = bevy::math::Rot2::length(_self.into_inner()) + "degrees", + |degrees: f32| { + let output: Val = bevy::math::Rot2::degrees( + degrees, + ) .into(); output }, ) .register( - "length_squared", - |_self: Val| { - let output: f32 = bevy::math::Rot2::length_squared( - _self.into_inner(), - ) + "eq", + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "length_recip", + "fast_renormalize", |_self: Val| { - let output: f32 = bevy::math::Rot2::length_recip(_self.into_inner()) + let output: Val = bevy::math::Rot2::fast_renormalize( + _self.into_inner(), + ) .into(); output }, ) .register( - "normalize", - |_self: Val| { - let output: Val = bevy::math::Rot2::normalize( - _self.into_inner(), + "from_sin_cos", + |sin: f32, cos: f32| { + let output: Val = bevy::math::Rot2::from_sin_cos( + sin, + cos, ) .into(); output }, ) .register( - "fast_renormalize", + "inverse", |_self: Val| { - let output: Val = bevy::math::Rot2::fast_renormalize( + let output: Val = bevy::math::Rot2::inverse( _self.into_inner(), ) .into(); @@ -506,9 +482,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "is_normalized", + "is_near_identity", |_self: Val| { - let output: bool = bevy::math::Rot2::is_normalized( + let output: bool = bevy::math::Rot2::is_near_identity( _self.into_inner(), ) .into(); @@ -516,9 +492,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "is_near_identity", + "is_normalized", |_self: Val| { - let output: bool = bevy::math::Rot2::is_near_identity( + let output: bool = bevy::math::Rot2::is_normalized( _self.into_inner(), ) .into(); @@ -526,37 +502,54 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "angle_between", - |_self: Val, other: Val| { - let output: f32 = bevy::math::Rot2::angle_between( - _self.into_inner(), - other.into_inner(), - ) + "length", + |_self: Val| { + let output: f32 = bevy::math::Rot2::length(_self.into_inner()) .into(); output }, ) .register( - "angle_to", - |_self: Val, other: Val| { - let output: f32 = bevy::math::Rot2::angle_to( - _self.into_inner(), - other.into_inner(), - ) + "length_recip", + |_self: Val| { + let output: f32 = bevy::math::Rot2::length_recip(_self.into_inner()) .into(); output }, ) .register( - "inverse", + "length_squared", |_self: Val| { - let output: Val = bevy::math::Rot2::inverse( + let output: f32 = bevy::math::Rot2::length_squared( _self.into_inner(), ) .into(); output }, ) + .register( + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + .into(); + output + }, + ) + .register( + "mul", + | + _self: Val, + direction: Val| + { + let output: Val = >::mul(_self.into_inner(), direction.into_inner()) + .into(); + output + }, + ) .register( "nlerp", |_self: Val, end: Val, s: f32| { @@ -570,56 +563,63 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "slerp", - |_self: Val, end: Val, s: f32| { - let output: Val = bevy::math::Rot2::slerp( + "normalize", + |_self: Val| { + let output: Val = bevy::math::Rot2::normalize( _self.into_inner(), - end.into_inner(), - s, ) .into(); output }, ) .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) + "radians", + |radians: f32| { + let output: Val = bevy::math::Rot2::radians( + radians, + ) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, + "sin_cos", + |_self: Val| { + let output: (f32, f32) = bevy::math::Rot2::sin_cos( + _self.into_inner(), ) .into(); output }, ) .register( - "mul", - | - _self: Val, - direction: Val| - { - let output: Val = >::mul(_self.into_inner(), direction.into_inner()) + "slerp", + |_self: Val, end: Val, s: f32| { + let output: Val = bevy::math::Rot2::slerp( + _self.into_inner(), + end.into_inner(), + s, + ) + .into(); + output + }, + ) + .register( + "turn_fraction", + |fraction: f32| { + let output: Val = bevy::math::Rot2::turn_fraction( + fraction, + ) .into(); output }, ); NamespaceBuilder::<::bevy::math::prelude::Dir2>::new(world) .register( - "neg", - |_self: Val| { - let output: Val = ::neg( - _self.into_inner(), + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, ) .into(); output @@ -638,6 +638,16 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { output }, ) + .register( + "fast_renormalize", + |_self: Val| { + let output: Val = bevy::math::prelude::Dir2::fast_renormalize( + _self.into_inner(), + ) + .into(); + output + }, + ) .register( "from_xy_unchecked", |x: f32, y: f32| { @@ -650,28 +660,22 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "slerp", - | - _self: Val, - rhs: Val, - s: f32| - { - let output: Val = bevy::math::prelude::Dir2::slerp( + "neg", + |_self: Val| { + let output: Val = ::neg( _self.into_inner(), - rhs.into_inner(), - s, ) .into(); output }, ) .register( - "rotation_to", + "rotation_from", | _self: Val, other: Val| { - let output: Val = bevy::math::prelude::Dir2::rotation_to( + let output: Val = bevy::math::prelude::Dir2::rotation_from( _self.into_inner(), other.into_inner(), ) @@ -680,23 +684,19 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "rotation_from", - | - _self: Val, - other: Val| - { - let output: Val = bevy::math::prelude::Dir2::rotation_from( + "rotation_from_x", + |_self: Val| { + let output: Val = bevy::math::prelude::Dir2::rotation_from_x( _self.into_inner(), - other.into_inner(), ) .into(); output }, ) .register( - "rotation_from_x", + "rotation_from_y", |_self: Val| { - let output: Val = bevy::math::prelude::Dir2::rotation_from_x( + let output: Val = bevy::math::prelude::Dir2::rotation_from_y( _self.into_inner(), ) .into(); @@ -704,19 +704,23 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "rotation_to_x", - |_self: Val| { - let output: Val = bevy::math::prelude::Dir2::rotation_to_x( + "rotation_to", + | + _self: Val, + other: Val| + { + let output: Val = bevy::math::prelude::Dir2::rotation_to( _self.into_inner(), + other.into_inner(), ) .into(); output }, ) .register( - "rotation_from_y", + "rotation_to_x", |_self: Val| { - let output: Val = bevy::math::prelude::Dir2::rotation_from_y( + let output: Val = bevy::math::prelude::Dir2::rotation_to_x( _self.into_inner(), ) .into(); @@ -734,26 +738,32 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "fast_renormalize", - |_self: Val| { - let output: Val = bevy::math::prelude::Dir2::fast_renormalize( + "slerp", + | + _self: Val, + rhs: Val, + s: f32| + { + let output: Val = bevy::math::prelude::Dir2::slerp( _self.into_inner(), + rhs.into_inner(), + s, ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::prelude::Dir3>::new(world) .register( "clone", - |_self: Ref| { - let output: Val = ::clone( + |_self: Ref| { + let output: Val = ::clone( &_self, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::prelude::Dir3>::new(world) + ) .register( "eq", | @@ -767,6 +777,16 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { output }, ) + .register( + "fast_renormalize", + |_self: Val| { + let output: Val = bevy::math::prelude::Dir3::fast_renormalize( + _self.into_inner(), + ) + .into(); + output + }, + ) .register( "from_xyz_unchecked", |x: f32, y: f32, z: f32| { @@ -779,6 +799,16 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { output }, ) + .register( + "neg", + |_self: Val| { + let output: Val = ::neg( + _self.into_inner(), + ) + .into(); + output + }, + ) .register( "slerp", | @@ -794,36 +824,6 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .into(); output }, - ) - .register( - "fast_renormalize", - |_self: Val| { - let output: Val = bevy::math::prelude::Dir3::fast_renormalize( - _self.into_inner(), - ) - .into(); - output - }, - ) - .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); - output - }, - ) - .register( - "neg", - |_self: Val| { - let output: Val = ::neg( - _self.into_inner(), - ) - .into(); - output - }, ); NamespaceBuilder::<::bevy::math::prelude::Dir3A>::new(world) .register( @@ -849,6 +849,16 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { output }, ) + .register( + "fast_renormalize", + |_self: Val| { + let output: Val = bevy::math::prelude::Dir3A::fast_renormalize( + _self.into_inner(), + ) + .into(); + output + }, + ) .register( "from_xyz_unchecked", |x: f32, y: f32, z: f32| { @@ -861,6 +871,16 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { output }, ) + .register( + "neg", + |_self: Val| { + let output: Val = ::neg( + _self.into_inner(), + ) + .into(); + output + }, + ) .register( "slerp", | @@ -876,53 +896,58 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::prelude::IRect>::new(world) .register( - "fast_renormalize", - |_self: Val| { - let output: Val = bevy::math::prelude::Dir3A::fast_renormalize( - _self.into_inner(), + "as_rect", + |_self: Ref| { + let output: Val = bevy::math::prelude::IRect::as_rect( + &_self, ) .into(); output }, ) .register( - "neg", - |_self: Val| { - let output: Val = ::neg( - _self.into_inner(), + "as_urect", + |_self: Ref| { + let output: Val = bevy::math::prelude::IRect::as_urect( + &_self, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::prelude::IRect>::new(world) + ) .register( - "new", - |x0: i32, y0: i32, x1: i32, y1: i32| { - let output: Val = bevy::math::prelude::IRect::new( - x0, - y0, - x1, - y1, + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( + &_self, ) .into(); output }, ) .register( - "is_empty", + "clone", |_self: Ref| { - let output: bool = bevy::math::prelude::IRect::is_empty(&_self) + let output: Val = ::clone( + &_self, + ) .into(); output }, ) .register( - "width", - |_self: Ref| { - let output: i32 = bevy::math::prelude::IRect::width(&_self).into(); + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) + .into(); output }, ) @@ -934,14 +959,11 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "union", - | - _self: Ref, - other: Val| - { - let output: Val = bevy::math::prelude::IRect::union( + "inflate", + |_self: Ref, expansion: i32| { + let output: Val = bevy::math::prelude::IRect::inflate( &_self, - other.into_inner(), + expansion, ) .into(); output @@ -962,50 +984,52 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "inflate", - |_self: Ref, expansion: i32| { - let output: Val = bevy::math::prelude::IRect::inflate( - &_self, - expansion, - ) + "is_empty", + |_self: Ref| { + let output: bool = bevy::math::prelude::IRect::is_empty(&_self) .into(); output }, ) .register( - "as_rect", - |_self: Ref| { - let output: Val = bevy::math::prelude::IRect::as_rect( - &_self, + "new", + |x0: i32, y0: i32, x1: i32, y1: i32| { + let output: Val = bevy::math::prelude::IRect::new( + x0, + y0, + x1, + y1, ) .into(); output }, ) .register( - "as_urect", - |_self: Ref| { - let output: Val = bevy::math::prelude::IRect::as_urect( + "union", + | + _self: Ref, + other: Val| + { + let output: Val = bevy::math::prelude::IRect::union( &_self, + other.into_inner(), ) .into(); output }, ) .register( - "clone", + "width", |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); + let output: i32 = bevy::math::prelude::IRect::width(&_self).into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::prelude::Rect>::new(world) .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( + "as_irect", + |_self: Ref| { + let output: Val = bevy::math::prelude::Rect::as_irect( &_self, ) .into(); @@ -1013,44 +1037,35 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) - .into(); - output - }, - ); - NamespaceBuilder::<::bevy::math::prelude::Rect>::new(world) - .register( - "new", - |x0: f32, y0: f32, x1: f32, y1: f32| { - let output: Val = bevy::math::prelude::Rect::new( - x0, - y0, - x1, - y1, + "as_urect", + |_self: Ref| { + let output: Val = bevy::math::prelude::Rect::as_urect( + &_self, ) .into(); output }, ) .register( - "is_empty", + "clone", |_self: Ref| { - let output: bool = bevy::math::prelude::Rect::is_empty(&_self) + let output: Val = ::clone( + &_self, + ) .into(); output }, ) .register( - "width", - |_self: Ref| { - let output: f32 = bevy::math::prelude::Rect::width(&_self).into(); + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) + .into(); output }, ) @@ -1062,14 +1077,11 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "union", - | - _self: Ref, - other: Val| - { - let output: Val = bevy::math::prelude::Rect::union( + "inflate", + |_self: Ref, expansion: f32| { + let output: Val = bevy::math::prelude::Rect::inflate( &_self, - other.into_inner(), + expansion, ) .into(); output @@ -1090,11 +1102,21 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "inflate", - |_self: Ref, expansion: f32| { - let output: Val = bevy::math::prelude::Rect::inflate( - &_self, - expansion, + "is_empty", + |_self: Ref| { + let output: bool = bevy::math::prelude::Rect::is_empty(&_self) + .into(); + output + }, + ) + .register( + "new", + |x0: f32, y0: f32, x1: f32, y1: f32| { + let output: Val = bevy::math::prelude::Rect::new( + x0, + y0, + x1, + y1, ) .into(); output @@ -1115,29 +1137,31 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "as_irect", - |_self: Ref| { - let output: Val = bevy::math::prelude::Rect::as_irect( + "union", + | + _self: Ref, + other: Val| + { + let output: Val = bevy::math::prelude::Rect::union( &_self, + other.into_inner(), ) .into(); output }, ) .register( - "as_urect", + "width", |_self: Ref| { - let output: Val = bevy::math::prelude::Rect::as_urect( - &_self, - ) - .into(); + let output: f32 = bevy::math::prelude::Rect::width(&_self).into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::prelude::URect>::new(world) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( + "as_irect", + |_self: Ref| { + let output: Val = bevy::math::prelude::URect::as_irect( &_self, ) .into(); @@ -1145,23 +1169,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) - .into(); - output - }, - ); - NamespaceBuilder::<::bevy::math::prelude::URect>::new(world) - .register( - "clone", + "as_rect", |_self: Ref| { - let output: Val = ::clone( + let output: Val = bevy::math::prelude::URect::as_rect( &_self, ) .into(); @@ -1169,30 +1179,35 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "new", - |x0: u32, y0: u32, x1: u32, y1: u32| { - let output: Val = bevy::math::prelude::URect::new( - x0, - y0, - x1, - y1, + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( + &_self, ) .into(); output }, ) .register( - "is_empty", + "clone", |_self: Ref| { - let output: bool = bevy::math::prelude::URect::is_empty(&_self) + let output: Val = ::clone( + &_self, + ) .into(); output }, ) .register( - "width", - |_self: Ref| { - let output: u32 = bevy::math::prelude::URect::width(&_self).into(); + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) + .into(); output }, ) @@ -1204,14 +1219,11 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "union", - | - _self: Ref, - other: Val| - { - let output: Val = bevy::math::prelude::URect::union( + "inflate", + |_self: Ref, expansion: i32| { + let output: Val = bevy::math::prelude::URect::inflate( &_self, - other.into_inner(), + expansion, ) .into(); output @@ -1232,65 +1244,53 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "inflate", - |_self: Ref, expansion: i32| { - let output: Val = bevy::math::prelude::URect::inflate( - &_self, - expansion, - ) - .into(); - output - }, - ) - .register( - "as_rect", + "is_empty", |_self: Ref| { - let output: Val = bevy::math::prelude::URect::as_rect( - &_self, - ) + let output: bool = bevy::math::prelude::URect::is_empty(&_self) .into(); output }, ) .register( - "as_irect", - |_self: Ref| { - let output: Val = bevy::math::prelude::URect::as_irect( - &_self, + "new", + |x0: u32, y0: u32, x1: u32, y1: u32| { + let output: Val = bevy::math::prelude::URect::new( + x0, + y0, + x1, + y1, ) .into(); output }, ) .register( - "eq", + "union", | _self: Ref, - other: Ref| + other: Val| { - let output: bool = >::eq(&_self, &other) + let output: Val = bevy::math::prelude::URect::union( + &_self, + other.into_inner(), + ) .into(); output }, ) .register( - "assert_receiver_is_total_eq", + "width", |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, - ) - .into(); + let output: u32 = bevy::math::prelude::URect::width(&_self).into(); output }, ); NamespaceBuilder::<::bevy::math::Affine3>::new(world); NamespaceBuilder::<::bevy::math::bounding::Aabb2d>::new(world) .register( - "clone", + "bounding_circle", |_self: Ref| { - let output: Val = ::clone( + let output: Val = bevy::math::bounding::Aabb2d::bounding_circle( &_self, ) .into(); @@ -1298,9 +1298,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "bounding_circle", + "clone", |_self: Ref| { - let output: Val = bevy::math::bounding::Aabb2d::bounding_circle( + let output: Val = ::clone( &_self, ) .into(); @@ -1309,9 +1309,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { ); NamespaceBuilder::<::bevy::math::bounding::BoundingCircle>::new(world) .register( - "radius", + "aabb_2d", |_self: Ref| { - let output: f32 = bevy::math::bounding::BoundingCircle::radius( + let output: Val = bevy::math::bounding::BoundingCircle::aabb_2d( &_self, ) .into(); @@ -1319,9 +1319,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "aabb_2d", + "clone", |_self: Ref| { - let output: Val = bevy::math::bounding::BoundingCircle::aabb_2d( + let output: Val = ::clone( &_self, ) .into(); @@ -1329,9 +1329,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "clone", + "radius", |_self: Ref| { - let output: Val = ::clone( + let output: f32 = bevy::math::bounding::BoundingCircle::radius( &_self, ) .into(); @@ -1339,6 +1339,24 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ); NamespaceBuilder::<::bevy::math::primitives::Circle>::new(world) + .register( + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) + .into(); + output + }, + ) + .register( + "diameter", + |_self: Ref| { + let output: f32 = bevy::math::primitives::Circle::diameter(&_self) + .into(); + output + }, + ) .register( "eq", | @@ -1361,26 +1379,39 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .into(); output }, + ); + NamespaceBuilder::<::bevy::math::primitives::Annulus>::new(world) + .register( + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) + .into(); + output + }, ) .register( "diameter", - |_self: Ref| { - let output: f32 = bevy::math::primitives::Circle::diameter(&_self) + |_self: Ref| { + let output: f32 = bevy::math::primitives::Annulus::diameter(&_self) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::primitives::Annulus>::new(world) + ) .register( "new", |inner_radius: f32, outer_radius: f32| { @@ -1393,45 +1424,38 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "diameter", + "thickness", |_self: Ref| { - let output: f32 = bevy::math::primitives::Annulus::diameter(&_self) + let output: f32 = bevy::math::primitives::Annulus::thickness(&_self) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::primitives::Arc2d>::new(world) .register( - "thickness", - |_self: Ref| { - let output: f32 = bevy::math::primitives::Annulus::thickness(&_self) + "angle", + |_self: Ref| { + let output: f32 = bevy::math::primitives::Arc2d::angle(&_self) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) + "apothem", + |_self: Ref| { + let output: f32 = bevy::math::primitives::Arc2d::apothem(&_self) .into(); output }, ) .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) + "chord_length", + |_self: Ref| { + let output: f32 = bevy::math::primitives::Arc2d::chord_length(&_self) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::primitives::Arc2d>::new(world) + ) .register( "clone", |_self: Ref| { @@ -1443,20 +1467,22 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "new", - |radius: f32, half_angle: f32| { - let output: Val = bevy::math::primitives::Arc2d::new( - radius, - half_angle, - ) + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "from_radians", + "from_degrees", |radius: f32, angle: f32| { - let output: Val = bevy::math::primitives::Arc2d::from_radians( + let output: Val = bevy::math::primitives::Arc2d::from_degrees( radius, angle, ) @@ -1465,9 +1491,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "from_degrees", + "from_radians", |radius: f32, angle: f32| { - let output: Val = bevy::math::primitives::Arc2d::from_degrees( + let output: Val = bevy::math::primitives::Arc2d::from_radians( radius, angle, ) @@ -1486,22 +1512,6 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { output }, ) - .register( - "angle", - |_self: Ref| { - let output: f32 = bevy::math::primitives::Arc2d::angle(&_self) - .into(); - output - }, - ) - .register( - "length", - |_self: Ref| { - let output: f32 = bevy::math::primitives::Arc2d::length(&_self) - .into(); - output - }, - ) .register( "half_chord_length", |_self: Ref| { @@ -1513,59 +1523,59 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "chord_length", + "is_major", |_self: Ref| { - let output: f32 = bevy::math::primitives::Arc2d::chord_length(&_self) + let output: bool = bevy::math::primitives::Arc2d::is_major(&_self) .into(); output }, ) .register( - "apothem", + "is_minor", |_self: Ref| { - let output: f32 = bevy::math::primitives::Arc2d::apothem(&_self) + let output: bool = bevy::math::primitives::Arc2d::is_minor(&_self) .into(); output }, ) .register( - "sagitta", + "length", |_self: Ref| { - let output: f32 = bevy::math::primitives::Arc2d::sagitta(&_self) + let output: f32 = bevy::math::primitives::Arc2d::length(&_self) .into(); output }, ) .register( - "is_minor", - |_self: Ref| { - let output: bool = bevy::math::primitives::Arc2d::is_minor(&_self) + "new", + |radius: f32, half_angle: f32| { + let output: Val = bevy::math::primitives::Arc2d::new( + radius, + half_angle, + ) .into(); output }, ) .register( - "is_major", + "sagitta", |_self: Ref| { - let output: bool = bevy::math::primitives::Arc2d::is_major(&_self) + let output: f32 = bevy::math::primitives::Arc2d::sagitta(&_self) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::primitives::Capsule2d>::new(world) .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::primitives::Capsule2d>::new(world) + ) .register( "eq", | @@ -1579,16 +1589,6 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { output }, ) - .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); - output - }, - ) .register( "new", |radius: f32, length: f32| { @@ -1612,14 +1612,41 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { ); NamespaceBuilder::<::bevy::math::primitives::CircularSector>::new(world) .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) + "angle", + |_self: Ref| { + let output: f32 = bevy::math::primitives::CircularSector::angle( + &_self, + ) + .into(); + output + }, + ) + .register( + "apothem", + |_self: Ref| { + let output: f32 = bevy::math::primitives::CircularSector::apothem( + &_self, + ) + .into(); + output + }, + ) + .register( + "arc_length", + |_self: Ref| { + let output: f32 = bevy::math::primitives::CircularSector::arc_length( + &_self, + ) + .into(); + output + }, + ) + .register( + "chord_length", + |_self: Ref| { + let output: f32 = bevy::math::primitives::CircularSector::chord_length( + &_self, + ) .into(); output }, @@ -1635,20 +1662,22 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "new", - |radius: f32, angle: f32| { - let output: Val = bevy::math::primitives::CircularSector::new( - radius, - angle, - ) + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "from_radians", + "from_degrees", |radius: f32, angle: f32| { - let output: Val = bevy::math::primitives::CircularSector::from_radians( + let output: Val = bevy::math::primitives::CircularSector::from_degrees( radius, angle, ) @@ -1657,9 +1686,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "from_degrees", + "from_radians", |radius: f32, angle: f32| { - let output: Val = bevy::math::primitives::CircularSector::from_degrees( + let output: Val = bevy::math::primitives::CircularSector::from_radians( radius, angle, ) @@ -1689,15 +1718,26 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "angle", + "half_chord_length", |_self: Ref| { - let output: f32 = bevy::math::primitives::CircularSector::angle( + let output: f32 = bevy::math::primitives::CircularSector::half_chord_length( &_self, ) .into(); output }, ) + .register( + "new", + |radius: f32, angle: f32| { + let output: Val = bevy::math::primitives::CircularSector::new( + radius, + angle, + ) + .into(); + output + }, + ) .register( "radius", |_self: Ref| { @@ -1709,9 +1749,20 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "arc_length", + "sagitta", |_self: Ref| { - let output: f32 = bevy::math::primitives::CircularSector::arc_length( + let output: f32 = bevy::math::primitives::CircularSector::sagitta( + &_self, + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::CircularSegment>::new(world) + .register( + "angle", + |_self: Ref| { + let output: f32 = bevy::math::primitives::CircularSegment::angle( &_self, ) .into(); @@ -1719,9 +1770,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "half_chord_length", - |_self: Ref| { - let output: f32 = bevy::math::primitives::CircularSector::half_chord_length( + "apothem", + |_self: Ref| { + let output: f32 = bevy::math::primitives::CircularSegment::apothem( &_self, ) .into(); @@ -1729,9 +1780,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "chord_length", - |_self: Ref| { - let output: f32 = bevy::math::primitives::CircularSector::chord_length( + "arc_length", + |_self: Ref| { + let output: f32 = bevy::math::primitives::CircularSegment::arc_length( &_self, ) .into(); @@ -1739,9 +1790,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "apothem", - |_self: Ref| { - let output: f32 = bevy::math::primitives::CircularSector::apothem( + "chord_length", + |_self: Ref| { + let output: f32 = bevy::math::primitives::CircularSegment::chord_length( &_self, ) .into(); @@ -1749,16 +1800,15 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "sagitta", - |_self: Ref| { - let output: f32 = bevy::math::primitives::CircularSector::sagitta( + "clone", + |_self: Ref| { + let output: Val = ::clone( &_self, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::primitives::CircularSegment>::new(world) + ) .register( "eq", | @@ -1773,9 +1823,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "new", + "from_degrees", |radius: f32, angle: f32| { - let output: Val = bevy::math::primitives::CircularSegment::new( + let output: Val = bevy::math::primitives::CircularSegment::from_degrees( radius, angle, ) @@ -1794,17 +1844,6 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { output }, ) - .register( - "from_degrees", - |radius: f32, angle: f32| { - let output: Val = bevy::math::primitives::CircularSegment::from_degrees( - radius, - angle, - ) - .into(); - output - }, - ) .register( "from_turns", |radius: f32, fraction: f32| { @@ -1827,9 +1866,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "angle", + "half_chord_length", |_self: Ref| { - let output: f32 = bevy::math::primitives::CircularSegment::angle( + let output: f32 = bevy::math::primitives::CircularSegment::half_chord_length( &_self, ) .into(); @@ -1837,19 +1876,20 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "radius", - |_self: Ref| { - let output: f32 = bevy::math::primitives::CircularSegment::radius( - &_self, + "new", + |radius: f32, angle: f32| { + let output: Val = bevy::math::primitives::CircularSegment::new( + radius, + angle, ) .into(); output }, ) .register( - "arc_length", + "radius", |_self: Ref| { - let output: f32 = bevy::math::primitives::CircularSegment::arc_length( + let output: f32 = bevy::math::primitives::CircularSegment::radius( &_self, ) .into(); @@ -1857,19 +1897,20 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "half_chord_length", + "sagitta", |_self: Ref| { - let output: f32 = bevy::math::primitives::CircularSegment::half_chord_length( + let output: f32 = bevy::math::primitives::CircularSegment::sagitta( &_self, ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::primitives::Ellipse>::new(world) .register( - "chord_length", - |_self: Ref| { - let output: f32 = bevy::math::primitives::CircularSegment::chord_length( + "clone", + |_self: Ref| { + let output: Val = ::clone( &_self, ) .into(); @@ -1877,9 +1918,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "apothem", - |_self: Ref| { - let output: f32 = bevy::math::primitives::CircularSegment::apothem( + "eccentricity", + |_self: Ref| { + let output: f32 = bevy::math::primitives::Ellipse::eccentricity( &_self, ) .into(); @@ -1887,26 +1928,28 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "sagitta", - |_self: Ref| { - let output: f32 = bevy::math::primitives::CircularSegment::sagitta( - &_self, - ) + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( + "focal_length", + |_self: Ref| { + let output: f32 = bevy::math::primitives::Ellipse::focal_length( &_self, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::primitives::Ellipse>::new(world) + ) .register( "new", |half_width: f32, half_height: f32| { @@ -1918,26 +1961,6 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { output }, ) - .register( - "eccentricity", - |_self: Ref| { - let output: f32 = bevy::math::primitives::Ellipse::eccentricity( - &_self, - ) - .into(); - output - }, - ) - .register( - "focal_length", - |_self: Ref| { - let output: f32 = bevy::math::primitives::Ellipse::focal_length( - &_self, - ) - .into(); - output - }, - ) .register( "semi_major", |_self: Ref| { @@ -1953,31 +1976,18 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::primitives::Line2d>::new(world) .register( "clone", - |_self: Ref| { - let output: Val = ::clone( + |_self: Ref| { + let output: Val = ::clone( &_self, ) .into(); output }, ) - .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) - .into(); - output - }, - ); - NamespaceBuilder::<::bevy::math::primitives::Line2d>::new(world) .register( "eq", | @@ -1990,16 +2000,6 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .into(); output }, - ) - .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); - output - }, ); NamespaceBuilder::<::bevy::math::primitives::Plane2d>::new(world) .register( @@ -2037,12 +2037,14 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "new", - |width: f32, height: f32| { - let output: Val = bevy::math::primitives::Rectangle::new( - width, - height, - ) + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) .into(); output }, @@ -2058,34 +2060,54 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) + "new", + |width: f32, height: f32| { + let output: Val = bevy::math::primitives::Rectangle::new( + width, + height, + ) .into(); output }, ); NamespaceBuilder::<::bevy::math::primitives::RegularPolygon>::new(world) .register( - "new", - |circumradius: f32, sides: u32| { - let output: Val = bevy::math::primitives::RegularPolygon::new( - circumradius, - sides, + "circumradius", + |_self: Ref| { + let output: f32 = bevy::math::primitives::RegularPolygon::circumradius( + &_self, + ) + .into(); + output + }, + ) + .register( + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, ) .into(); output }, ) .register( - "circumradius", + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) + .into(); + output + }, + ) + .register( + "external_angle_degrees", |_self: Ref| { - let output: f32 = bevy::math::primitives::RegularPolygon::circumradius( + let output: f32 = bevy::math::primitives::RegularPolygon::external_angle_degrees( &_self, ) .into(); @@ -2093,9 +2115,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "inradius", + "external_angle_radians", |_self: Ref| { - let output: f32 = bevy::math::primitives::RegularPolygon::inradius( + let output: f32 = bevy::math::primitives::RegularPolygon::external_angle_radians( &_self, ) .into(); @@ -2103,9 +2125,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "side_length", + "inradius", |_self: Ref| { - let output: f32 = bevy::math::primitives::RegularPolygon::side_length( + let output: f32 = bevy::math::primitives::RegularPolygon::inradius( &_self, ) .into(); @@ -2133,49 +2155,37 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "external_angle_degrees", - |_self: Ref| { - let output: f32 = bevy::math::primitives::RegularPolygon::external_angle_degrees( - &_self, + "new", + |circumradius: f32, sides: u32| { + let output: Val = bevy::math::primitives::RegularPolygon::new( + circumradius, + sides, ) .into(); output }, ) .register( - "external_angle_radians", + "side_length", |_self: Ref| { - let output: f32 = bevy::math::primitives::RegularPolygon::external_angle_radians( + let output: f32 = bevy::math::primitives::RegularPolygon::side_length( &_self, ) .into(); output }, - ) - .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) - .into(); - output - }, - ) + ); + NamespaceBuilder::<::bevy::math::primitives::Rhombus>::new(world) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( + "circumradius", + |_self: Ref| { + let output: f32 = bevy::math::primitives::Rhombus::circumradius( &_self, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::primitives::Rhombus>::new(world) + ) .register( "clone", |_self: Ref| { @@ -2200,11 +2210,10 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "new", - |horizontal_diagonal: f32, vertical_diagonal: f32| { - let output: Val = bevy::math::primitives::Rhombus::new( - horizontal_diagonal, - vertical_diagonal, + "from_inradius", + |inradius: f32| { + let output: Val = bevy::math::primitives::Rhombus::from_inradius( + inradius, ) .into(); output @@ -2221,10 +2230,19 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "from_inradius", - |inradius: f32| { - let output: Val = bevy::math::primitives::Rhombus::from_inradius( - inradius, + "inradius", + |_self: Ref| { + let output: f32 = bevy::math::primitives::Rhombus::inradius(&_self) + .into(); + output + }, + ) + .register( + "new", + |horizontal_diagonal: f32, vertical_diagonal: f32| { + let output: Val = bevy::math::primitives::Rhombus::new( + horizontal_diagonal, + vertical_diagonal, ) .into(); output @@ -2237,26 +2255,18 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::primitives::Segment2d>::new(world) .register( - "circumradius", - |_self: Ref| { - let output: f32 = bevy::math::primitives::Rhombus::circumradius( + "clone", + |_self: Ref| { + let output: Val = ::clone( &_self, ) .into(); output }, ) - .register( - "inradius", - |_self: Ref| { - let output: f32 = bevy::math::primitives::Rhombus::inradius(&_self) - .into(); - output - }, - ); - NamespaceBuilder::<::bevy::math::primitives::Segment2d>::new(world) .register( "eq", | @@ -2280,16 +2290,6 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .into(); output }, - ) - .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); - output - }, ); NamespaceBuilder::<::bevy::math::primitives::Triangle2d>::new(world) .register( @@ -2303,9 +2303,22 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "is_degenerate", + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) + .into(); + output + }, + ) + .register( + "is_acute", |_self: Ref| { - let output: bool = bevy::math::primitives::Triangle2d::is_degenerate( + let output: bool = bevy::math::primitives::Triangle2d::is_acute( &_self, ) .into(); @@ -2313,9 +2326,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "is_acute", + "is_degenerate", |_self: Ref| { - let output: bool = bevy::math::primitives::Triangle2d::is_acute( + let output: bool = bevy::math::primitives::Triangle2d::is_degenerate( &_self, ) .into(); @@ -2351,25 +2364,12 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .into(); output }, - ) - .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) - .into(); - output - }, ); NamespaceBuilder::<::bevy::math::bounding::Aabb3d>::new(world) .register( - "clone", + "bounding_sphere", |_self: Ref| { - let output: Val = ::clone( + let output: Val = bevy::math::bounding::Aabb3d::bounding_sphere( &_self, ) .into(); @@ -2377,9 +2377,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "bounding_sphere", + "clone", |_self: Ref| { - let output: Val = bevy::math::bounding::Aabb3d::bounding_sphere( + let output: Val = ::clone( &_self, ) .into(); @@ -2388,9 +2388,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { ); NamespaceBuilder::<::bevy::math::bounding::BoundingSphere>::new(world) .register( - "clone", + "aabb_3d", |_self: Ref| { - let output: Val = ::clone( + let output: Val = bevy::math::bounding::BoundingSphere::aabb_3d( &_self, ) .into(); @@ -2398,9 +2398,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "radius", + "clone", |_self: Ref| { - let output: f32 = bevy::math::bounding::BoundingSphere::radius( + let output: Val = ::clone( &_self, ) .into(); @@ -2408,9 +2408,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "aabb_3d", + "radius", |_self: Ref| { - let output: Val = bevy::math::bounding::BoundingSphere::aabb_3d( + let output: f32 = bevy::math::bounding::BoundingSphere::radius( &_self, ) .into(); @@ -2418,6 +2418,24 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ); NamespaceBuilder::<::bevy::math::primitives::Sphere>::new(world) + .register( + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) + .into(); + output + }, + ) + .register( + "diameter", + |_self: Ref| { + let output: f32 = bevy::math::primitives::Sphere::diameter(&_self) + .into(); + output + }, + ) .register( "eq", | @@ -2431,16 +2449,6 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { output }, ) - .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); - output - }, - ) .register( "new", |radius: f32| { @@ -2450,16 +2458,18 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::primitives::Cuboid>::new(world) .register( - "diameter", - |_self: Ref| { - let output: f32 = bevy::math::primitives::Sphere::diameter(&_self) + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::primitives::Cuboid>::new(world) + ) .register( "eq", | @@ -2473,18 +2483,6 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { output }, ) - .register( - "new", - |x_length: f32, y_length: f32, z_length: f32| { - let output: Val = bevy::math::primitives::Cuboid::new( - x_length, - y_length, - z_length, - ) - .into(); - output - }, - ) .register( "from_length", |length: f32| { @@ -2496,10 +2494,12 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, + "new", + |x_length: f32, y_length: f32, z_length: f32| { + let output: Val = bevy::math::primitives::Cuboid::new( + x_length, + y_length, + z_length, ) .into(); output @@ -2507,9 +2507,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { ); NamespaceBuilder::<::bevy::math::primitives::Cylinder>::new(world) .register( - "clone", + "base", |_self: Ref| { - let output: Val = ::clone( + let output: Val = bevy::math::primitives::Cylinder::base( &_self, ) .into(); @@ -2517,26 +2517,36 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "new", - |radius: f32, height: f32| { - let output: Val = bevy::math::primitives::Cylinder::new( - radius, - height, - ) + "base_area", + |_self: Ref| { + let output: f32 = bevy::math::primitives::Cylinder::base_area(&_self) .into(); output }, ) .register( - "base", + "clone", |_self: Ref| { - let output: Val = bevy::math::primitives::Cylinder::base( + let output: Val = ::clone( &_self, ) .into(); output }, ) + .register( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) + .into(); + output + }, + ) .register( "lateral_area", |_self: Ref| { @@ -2548,27 +2558,27 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "base_area", - |_self: Ref| { - let output: f32 = bevy::math::primitives::Cylinder::base_area(&_self) + "new", + |radius: f32, height: f32| { + let output: Val = bevy::math::primitives::Cylinder::new( + radius, + height, + ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::primitives::Capsule3d>::new(world) .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::primitives::Capsule3d>::new(world) + ) .register( "eq", | @@ -2582,16 +2592,6 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { output }, ) - .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); - output - }, - ) .register( "new", |radius: f32, length: f32| { @@ -2615,9 +2615,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { ); NamespaceBuilder::<::bevy::math::primitives::Cone>::new(world) .register( - "clone", + "base", |_self: Ref| { - let output: Val = ::clone( + let output: Val = bevy::math::primitives::Cone::base( &_self, ) .into(); @@ -2625,20 +2625,17 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "new", - |radius: f32, height: f32| { - let output: Val = bevy::math::primitives::Cone::new( - radius, - height, - ) + "base_area", + |_self: Ref| { + let output: f32 = bevy::math::primitives::Cone::base_area(&_self) .into(); output }, ) .register( - "base", + "clone", |_self: Ref| { - let output: Val = bevy::math::primitives::Cone::base( + let output: Val = ::clone( &_self, ) .into(); @@ -2646,9 +2643,14 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "slant_height", - |_self: Ref| { - let output: f32 = bevy::math::primitives::Cone::slant_height(&_self) + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) .into(); output }, @@ -2662,27 +2664,35 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "base_area", - |_self: Ref| { - let output: f32 = bevy::math::primitives::Cone::base_area(&_self) + "new", + |radius: f32, height: f32| { + let output: Val = bevy::math::primitives::Cone::new( + radius, + height, + ) .into(); output }, ) .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) + "slant_height", + |_self: Ref| { + let output: f32 = bevy::math::primitives::Cone::slant_height(&_self) .into(); output }, ); NamespaceBuilder::<::bevy::math::primitives::ConicalFrustum>::new(world) + .register( + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) + .into(); + output + }, + ) .register( "eq", | @@ -2695,18 +2705,18 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::primitives::InfinitePlane3d>::new(world) .register( "clone", - |_self: Ref| { - let output: Val = ::clone( + |_self: Ref| { + let output: Val = ::clone( &_self, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::primitives::InfinitePlane3d>::new(world) + ) .register( "eq", | @@ -2719,18 +2729,18 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::primitives::Line3d>::new(world) .register( "clone", - |_self: Ref| { - let output: Val = ::clone( + |_self: Ref| { + let output: Val = ::clone( &_self, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::primitives::Line3d>::new(world) + ) .register( "eq", | @@ -2743,16 +2753,6 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .into(); output }, - ) - .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); - output - }, ); NamespaceBuilder::<::bevy::math::primitives::Segment3d>::new(world) .register( @@ -2765,6 +2765,19 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { output }, ) + .register( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) + .into(); + output + }, + ) .register( "new", |direction: Val, length: f32| { @@ -2775,21 +2788,39 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .into(); output }, + ); + NamespaceBuilder::<::bevy::math::primitives::Torus>::new(world) + .register( + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) + .into(); + output + }, ) .register( "eq", | - _self: Ref, - other: Ref| + _self: Ref, + other: Ref| { - let output: bool = >::eq(&_self, &other) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::primitives::Torus>::new(world) + ) + .register( + "inner_radius", + |_self: Ref| { + let output: f32 = bevy::math::primitives::Torus::inner_radius(&_self) + .into(); + output + }, + ) .register( "new", |inner_radius: f32, outer_radius: f32| { @@ -2801,14 +2832,6 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { output }, ) - .register( - "inner_radius", - |_self: Ref| { - let output: f32 = bevy::math::primitives::Torus::inner_radius(&_self) - .into(); - output - }, - ) .register( "outer_radius", |_self: Ref| { @@ -2816,11 +2839,12 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::primitives::Triangle3d>::new(world) .register( "clone", - |_self: Ref| { - let output: Val = ::clone( + |_self: Ref| { + let output: Val = ::clone( &_self, ) .into(); @@ -2830,21 +2854,20 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .register( "eq", | - _self: Ref, - other: Ref| + _self: Ref, + other: Ref| { - let output: bool = >::eq(&_self, &other) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::primitives::Triangle3d>::new(world) + ) .register( - "is_degenerate", + "is_acute", |_self: Ref| { - let output: bool = bevy::math::primitives::Triangle3d::is_degenerate( + let output: bool = bevy::math::primitives::Triangle3d::is_acute( &_self, ) .into(); @@ -2852,9 +2875,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "is_acute", + "is_degenerate", |_self: Ref| { - let output: bool = bevy::math::primitives::Triangle3d::is_acute( + let output: bool = bevy::math::primitives::Triangle3d::is_degenerate( &_self, ) .into(); @@ -2882,60 +2905,16 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "reversed", - |_self: Val| { - let output: Val = bevy::math::primitives::Triangle3d::reversed( - _self.into_inner(), - ) - .into(); - output - }, - ) - .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); - output - }, - ) - .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) - .into(); - output - }, - ); - NamespaceBuilder::<::bevy::math::bounding::RayCast2d>::new(world) - .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); - output - }, - ) - .register( - "from_ray", - |ray: Val, max: f32| { - let output: Val = bevy::math::bounding::RayCast2d::from_ray( - ray.into_inner(), - max, + "reversed", + |_self: Val| { + let output: Val = bevy::math::primitives::Triangle3d::reversed( + _self.into_inner(), ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::bounding::RayCast2d>::new(world) .register( "aabb_intersection_at", | @@ -2963,24 +2942,29 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .into(); output }, - ); - NamespaceBuilder::<::bevy::math::bounding::AabbCast2d>::new(world) + ) + .register( + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) + .into(); + output + }, + ) .register( "from_ray", - | - aabb: Val, - ray: Val, - max: f32| - { - let output: Val = bevy::math::bounding::AabbCast2d::from_ray( - aabb.into_inner(), + |ray: Val, max: f32| { + let output: Val = bevy::math::bounding::RayCast2d::from_ray( ray.into_inner(), max, ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::bounding::AabbCast2d>::new(world) .register( "aabb_collision_at", | @@ -3004,24 +2988,24 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .into(); output }, - ); - NamespaceBuilder::<::bevy::math::bounding::BoundingCircleCast>::new(world) + ) .register( "from_ray", | - circle: Val, + aabb: Val, ray: Val, max: f32| { - let output: Val = bevy::math::bounding::BoundingCircleCast::from_ray( - circle.into_inner(), + let output: Val = bevy::math::bounding::AabbCast2d::from_ray( + aabb.into_inner(), ray.into_inner(), max, ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::bounding::BoundingCircleCast>::new(world) .register( "circle_collision_at", | @@ -3045,19 +3029,24 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .into(); output }, - ); - NamespaceBuilder::<::bevy::math::bounding::RayCast3d>::new(world) + ) .register( "from_ray", - |ray: Val, max: f32| { - let output: Val = bevy::math::bounding::RayCast3d::from_ray( + | + circle: Val, + ray: Val, + max: f32| + { + let output: Val = bevy::math::bounding::BoundingCircleCast::from_ray( + circle.into_inner(), ray.into_inner(), max, ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::bounding::RayCast3d>::new(world) .register( "aabb_intersection_at", | @@ -3073,46 +3062,41 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "sphere_intersection_at", - | - _self: Ref, - sphere: Ref| - { - let output: std::option::Option = bevy::math::bounding::RayCast3d::sphere_intersection_at( + "clone", + |_self: Ref| { + let output: Val = ::clone( &_self, - &sphere, ) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, + "from_ray", + |ray: Val, max: f32| { + let output: Val = bevy::math::bounding::RayCast3d::from_ray( + ray.into_inner(), + max, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::bounding::AabbCast3d>::new(world) + ) .register( - "from_ray", + "sphere_intersection_at", | - aabb: Val, - ray: Val, - max: f32| + _self: Ref, + sphere: Ref| { - let output: Val = bevy::math::bounding::AabbCast3d::from_ray( - aabb.into_inner(), - ray.into_inner(), - max, + let output: std::option::Option = bevy::math::bounding::RayCast3d::sphere_intersection_at( + &_self, + &sphere, ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::bounding::AabbCast3d>::new(world) .register( "aabb_collision_at", | @@ -3136,6 +3120,22 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .into(); output }, + ) + .register( + "from_ray", + | + aabb: Val, + ray: Val, + max: f32| + { + let output: Val = bevy::math::bounding::AabbCast3d::from_ray( + aabb.into_inner(), + ray.into_inner(), + max, + ) + .into(); + output + }, ); NamespaceBuilder::<::bevy::math::bounding::BoundingSphereCast>::new(world) .register( @@ -3179,6 +3179,17 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ); NamespaceBuilder::<::bevy::math::curve::interval::Interval>::new(world) + .register( + "clamp", + |_self: Val, value: f32| { + let output: f32 = bevy::math::curve::interval::Interval::clamp( + _self.into_inner(), + value, + ) + .into(); + output + }, + ) .register( "clone", |_self: Ref| { @@ -3190,23 +3201,25 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "eq", - | - _self: Ref, - other: Ref| - { - let output: bool = >::eq(&_self, &other) + "contains", + |_self: Val, item: f32| { + let output: bool = bevy::math::curve::interval::Interval::contains( + _self.into_inner(), + item, + ) .into(); output }, ) .register( - "start", - |_self: Val| { - let output: f32 = bevy::math::curve::interval::Interval::start( + "contains_interval", + | + _self: Val, + other: Val| + { + let output: bool = bevy::math::curve::interval::Interval::contains_interval( _self.into_inner(), + other.into_inner(), ) .into(); output @@ -3223,19 +3236,22 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "length", - |_self: Val| { - let output: f32 = bevy::math::curve::interval::Interval::length( - _self.into_inner(), - ) + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "is_bounded", + "has_finite_end", |_self: Val| { - let output: bool = bevy::math::curve::interval::Interval::is_bounded( + let output: bool = bevy::math::curve::interval::Interval::has_finite_end( _self.into_inner(), ) .into(); @@ -3253,9 +3269,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "has_finite_end", + "is_bounded", |_self: Val| { - let output: bool = bevy::math::curve::interval::Interval::has_finite_end( + let output: bool = bevy::math::curve::interval::Interval::is_bounded( _self.into_inner(), ) .into(); @@ -3263,42 +3279,36 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "contains", - |_self: Val, item: f32| { - let output: bool = bevy::math::curve::interval::Interval::contains( + "length", + |_self: Val| { + let output: f32 = bevy::math::curve::interval::Interval::length( _self.into_inner(), - item, ) .into(); output }, ) .register( - "contains_interval", - | - _self: Val, - other: Val| - { - let output: bool = bevy::math::curve::interval::Interval::contains_interval( + "start", + |_self: Val| { + let output: f32 = bevy::math::curve::interval::Interval::start( _self.into_inner(), - other.into_inner(), ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::FloatOrd>::new(world) .register( - "clamp", - |_self: Val, value: f32| { - let output: f32 = bevy::math::curve::interval::Interval::clamp( - _self.into_inner(), - value, + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::FloatOrd>::new(world) + ) .register( "eq", |_self: Ref, other: Ref| { @@ -3310,51 +3320,41 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); - output - }, - ) - .register( - "lt", + "ge", |_self: Ref, other: Ref| { let output: bool = >::lt(&_self, &other) + >>::ge(&_self, &other) .into(); output }, ) .register( - "le", + "gt", |_self: Ref, other: Ref| { let output: bool = >::le(&_self, &other) + >>::gt(&_self, &other) .into(); output }, ) .register( - "gt", + "le", |_self: Ref, other: Ref| { let output: bool = >::gt(&_self, &other) + >>::le(&_self, &other) .into(); output }, ) .register( - "ge", + "lt", |_self: Ref, other: Ref| { let output: bool = >::ge(&_self, &other) + >>::lt(&_self, &other) .into(); output }, @@ -3395,9 +3395,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { ); NamespaceBuilder::<::bevy::math::primitives::Tetrahedron>::new(world) .register( - "signed_volume", + "clone", |_self: Ref| { - let output: f32 = bevy::math::primitives::Tetrahedron::signed_volume( + let output: Val = ::clone( &_self, ) .into(); @@ -3418,9 +3418,9 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ) .register( - "clone", + "signed_volume", |_self: Ref| { - let output: Val = ::clone( + let output: f32 = bevy::math::primitives::Tetrahedron::signed_volume( &_self, ) .into(); @@ -3428,6 +3428,16 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { }, ); NamespaceBuilder::<::bevy::math::curve::easing::EaseFunction>::new(world) + .register( + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) + .into(); + output + }, + ) .register( "eq", | @@ -3440,16 +3450,6 @@ impl ::bevy::app::Plugin for BevyMathScriptingPlugin { .into(); output }, - ) - .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); - output - }, ); } } diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_reflect.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_reflect.rs index a6b8b9bed4..13f1cff050 100644 --- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_reflect.rs +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_reflect.rs @@ -18,6 +18,16 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { fn build(&self, app: &mut ::bevy::prelude::App) { let mut world = app.world_mut(); NamespaceBuilder::<::std::sync::atomic::AtomicBool>::new(world) + .register( + "into_inner", + |_self: Val| { + let output: bool = std::sync::atomic::AtomicBool::into_inner( + _self.into_inner(), + ) + .into(); + output + }, + ) .register( "new", |v: bool| { @@ -27,18 +37,18 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::std::sync::atomic::AtomicI16>::new(world) .register( "into_inner", - |_self: Val| { - let output: bool = std::sync::atomic::AtomicBool::into_inner( + |_self: Val| { + let output: i16 = std::sync::atomic::AtomicI16::into_inner( _self.into_inner(), ) .into(); output }, - ); - NamespaceBuilder::<::std::sync::atomic::AtomicI16>::new(world) + ) .register( "new", |v: i16| { @@ -48,18 +58,18 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::std::sync::atomic::AtomicI32>::new(world) .register( "into_inner", - |_self: Val| { - let output: i16 = std::sync::atomic::AtomicI16::into_inner( + |_self: Val| { + let output: i32 = std::sync::atomic::AtomicI32::into_inner( _self.into_inner(), ) .into(); output }, - ); - NamespaceBuilder::<::std::sync::atomic::AtomicI32>::new(world) + ) .register( "new", |v: i32| { @@ -69,18 +79,18 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::std::sync::atomic::AtomicI64>::new(world) .register( "into_inner", - |_self: Val| { - let output: i32 = std::sync::atomic::AtomicI32::into_inner( + |_self: Val| { + let output: i64 = std::sync::atomic::AtomicI64::into_inner( _self.into_inner(), ) .into(); output }, - ); - NamespaceBuilder::<::std::sync::atomic::AtomicI64>::new(world) + ) .register( "new", |v: i64| { @@ -90,18 +100,18 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::std::sync::atomic::AtomicI8>::new(world) .register( "into_inner", - |_self: Val| { - let output: i64 = std::sync::atomic::AtomicI64::into_inner( + |_self: Val| { + let output: i8 = std::sync::atomic::AtomicI8::into_inner( _self.into_inner(), ) .into(); output }, - ); - NamespaceBuilder::<::std::sync::atomic::AtomicI8>::new(world) + ) .register( "new", |v: i8| { @@ -111,18 +121,18 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::std::sync::atomic::AtomicIsize>::new(world) .register( "into_inner", - |_self: Val| { - let output: i8 = std::sync::atomic::AtomicI8::into_inner( + |_self: Val| { + let output: isize = std::sync::atomic::AtomicIsize::into_inner( _self.into_inner(), ) .into(); output }, - ); - NamespaceBuilder::<::std::sync::atomic::AtomicIsize>::new(world) + ) .register( "new", |v: isize| { @@ -132,18 +142,18 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::std::sync::atomic::AtomicU16>::new(world) .register( "into_inner", - |_self: Val| { - let output: isize = std::sync::atomic::AtomicIsize::into_inner( + |_self: Val| { + let output: u16 = std::sync::atomic::AtomicU16::into_inner( _self.into_inner(), ) .into(); output }, - ); - NamespaceBuilder::<::std::sync::atomic::AtomicU16>::new(world) + ) .register( "new", |v: u16| { @@ -153,18 +163,18 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::std::sync::atomic::AtomicU32>::new(world) .register( "into_inner", - |_self: Val| { - let output: u16 = std::sync::atomic::AtomicU16::into_inner( + |_self: Val| { + let output: u32 = std::sync::atomic::AtomicU32::into_inner( _self.into_inner(), ) .into(); output }, - ); - NamespaceBuilder::<::std::sync::atomic::AtomicU32>::new(world) + ) .register( "new", |v: u32| { @@ -174,18 +184,18 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::std::sync::atomic::AtomicU64>::new(world) .register( "into_inner", - |_self: Val| { - let output: u32 = std::sync::atomic::AtomicU32::into_inner( + |_self: Val| { + let output: u64 = std::sync::atomic::AtomicU64::into_inner( _self.into_inner(), ) .into(); output }, - ); - NamespaceBuilder::<::std::sync::atomic::AtomicU64>::new(world) + ) .register( "new", |v: u64| { @@ -195,18 +205,18 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::std::sync::atomic::AtomicU8>::new(world) .register( "into_inner", - |_self: Val| { - let output: u64 = std::sync::atomic::AtomicU64::into_inner( + |_self: Val| { + let output: u8 = std::sync::atomic::AtomicU8::into_inner( _self.into_inner(), ) .into(); output }, - ); - NamespaceBuilder::<::std::sync::atomic::AtomicU8>::new(world) + ) .register( "new", |v: u8| { @@ -216,18 +226,18 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::std::sync::atomic::AtomicUsize>::new(world) .register( "into_inner", - |_self: Val| { - let output: u8 = std::sync::atomic::AtomicU8::into_inner( + |_self: Val| { + let output: usize = std::sync::atomic::AtomicUsize::into_inner( _self.into_inner(), ) .into(); output }, - ); - NamespaceBuilder::<::std::sync::atomic::AtomicUsize>::new(world) + ) .register( "new", |v: usize| { @@ -237,28 +247,71 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::utils::Duration>::new(world) .register( - "into_inner", - |_self: Val| { - let output: usize = std::sync::atomic::AtomicUsize::into_inner( + "abs_diff", + |_self: Val, other: Val| { + let output: Val = bevy::utils::Duration::abs_diff( _self.into_inner(), + other.into_inner(), ) .into(); output }, - ); - NamespaceBuilder::<::bevy::utils::Duration>::new(world) + ) .register( - "mul", - |_self: Val, rhs: u32| { - let output: Val = >::mul(_self.into_inner(), rhs) + "add", + |_self: Val, rhs: Val| { + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) + .register( + "as_micros", + |_self: Ref| { + let output: u128 = bevy::utils::Duration::as_micros(&_self).into(); + output + }, + ) + .register( + "as_millis", + |_self: Ref| { + let output: u128 = bevy::utils::Duration::as_millis(&_self).into(); + output + }, + ) + .register( + "as_nanos", + |_self: Ref| { + let output: u128 = bevy::utils::Duration::as_nanos(&_self).into(); + output + }, + ) + .register( + "as_secs", + |_self: Ref| { + let output: u64 = bevy::utils::Duration::as_secs(&_self).into(); + output + }, + ) + .register( + "as_secs_f32", + |_self: Ref| { + let output: f32 = bevy::utils::Duration::as_secs_f32(&_self).into(); + output + }, + ) + .register( + "as_secs_f64", + |_self: Ref| { + let output: f64 = bevy::utils::Duration::as_secs_f64(&_self).into(); + output + }, + ) .register( "assert_receiver_is_total_eq", |_self: Ref| { @@ -280,81 +333,84 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "sub", - |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + "div", + |_self: Val, rhs: u32| { + let output: Val = >::div(_self.into_inner(), rhs) .into(); output }, ) .register( - "add", + "div_duration_f32", |_self: Val, rhs: Val| { - let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + let output: f32 = bevy::utils::Duration::div_duration_f32( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) + "div_duration_f64", + |_self: Val, rhs: Val| { + let output: f64 = bevy::utils::Duration::div_duration_f64( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: u32| { - let output: Val = >::div(_self.into_inner(), rhs) + "div_f32", + |_self: Val, rhs: f32| { + let output: Val = bevy::utils::Duration::div_f32( + _self.into_inner(), + rhs, + ) .into(); output }, ) .register( - "new", - |secs: u64, nanos: u32| { - let output: Val = bevy::utils::Duration::new( - secs, - nanos, + "div_f64", + |_self: Val, rhs: f64| { + let output: Val = bevy::utils::Duration::div_f64( + _self.into_inner(), + rhs, ) .into(); output }, ) .register( - "from_secs", - |secs: u64| { - let output: Val = bevy::utils::Duration::from_secs( - secs, - ) + "eq", + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "from_millis", - |millis: u64| { - let output: Val = bevy::utils::Duration::from_millis( - millis, + "from_micros", + |micros: u64| { + let output: Val = bevy::utils::Duration::from_micros( + micros, ) .into(); output }, ) .register( - "from_micros", - |micros: u64| { - let output: Val = bevy::utils::Duration::from_micros( - micros, + "from_millis", + |millis: u64| { + let output: Val = bevy::utils::Duration::from_millis( + millis, ) .into(); output @@ -371,89 +427,89 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "is_zero", - |_self: Ref| { - let output: bool = bevy::utils::Duration::is_zero(&_self).into(); - output - }, - ) - .register( - "as_secs", - |_self: Ref| { - let output: u64 = bevy::utils::Duration::as_secs(&_self).into(); - output - }, - ) - .register( - "subsec_millis", - |_self: Ref| { - let output: u32 = bevy::utils::Duration::subsec_millis(&_self) + "from_secs", + |secs: u64| { + let output: Val = bevy::utils::Duration::from_secs( + secs, + ) .into(); output }, ) .register( - "subsec_micros", - |_self: Ref| { - let output: u32 = bevy::utils::Duration::subsec_micros(&_self) + "from_secs_f32", + |secs: f32| { + let output: Val = bevy::utils::Duration::from_secs_f32( + secs, + ) .into(); output }, ) .register( - "subsec_nanos", - |_self: Ref| { - let output: u32 = bevy::utils::Duration::subsec_nanos(&_self).into(); + "from_secs_f64", + |secs: f64| { + let output: Val = bevy::utils::Duration::from_secs_f64( + secs, + ) + .into(); output }, ) .register( - "as_millis", + "is_zero", |_self: Ref| { - let output: u128 = bevy::utils::Duration::as_millis(&_self).into(); + let output: bool = bevy::utils::Duration::is_zero(&_self).into(); output }, ) .register( - "as_micros", - |_self: Ref| { - let output: u128 = bevy::utils::Duration::as_micros(&_self).into(); + "mul", + |_self: Val, rhs: u32| { + let output: Val = >::mul(_self.into_inner(), rhs) + .into(); output }, ) .register( - "as_nanos", - |_self: Ref| { - let output: u128 = bevy::utils::Duration::as_nanos(&_self).into(); + "mul_f32", + |_self: Val, rhs: f32| { + let output: Val = bevy::utils::Duration::mul_f32( + _self.into_inner(), + rhs, + ) + .into(); output }, ) .register( - "abs_diff", - |_self: Val, other: Val| { - let output: Val = bevy::utils::Duration::abs_diff( + "mul_f64", + |_self: Val, rhs: f64| { + let output: Val = bevy::utils::Duration::mul_f64( _self.into_inner(), - other.into_inner(), + rhs, ) .into(); output }, ) .register( - "saturating_add", - |_self: Val, rhs: Val| { - let output: Val = bevy::utils::Duration::saturating_add( - _self.into_inner(), - rhs.into_inner(), + "new", + |secs: u64, nanos: u32| { + let output: Val = bevy::utils::Duration::new( + secs, + nanos, ) .into(); output }, ) .register( - "saturating_sub", + "saturating_add", |_self: Val, rhs: Val| { - let output: Val = bevy::utils::Duration::saturating_sub( + let output: Val = bevy::utils::Duration::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -473,110 +529,95 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "as_secs_f64", - |_self: Ref| { - let output: f64 = bevy::utils::Duration::as_secs_f64(&_self).into(); - output - }, - ) - .register( - "as_secs_f32", - |_self: Ref| { - let output: f32 = bevy::utils::Duration::as_secs_f32(&_self).into(); + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = bevy::utils::Duration::saturating_sub( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); output }, ) .register( - "from_secs_f64", - |secs: f64| { - let output: Val = bevy::utils::Duration::from_secs_f64( - secs, - ) + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "from_secs_f32", - |secs: f32| { - let output: Val = bevy::utils::Duration::from_secs_f32( - secs, - ) + "subsec_micros", + |_self: Ref| { + let output: u32 = bevy::utils::Duration::subsec_micros(&_self) .into(); output }, ) .register( - "mul_f64", - |_self: Val, rhs: f64| { - let output: Val = bevy::utils::Duration::mul_f64( - _self.into_inner(), - rhs, - ) + "subsec_millis", + |_self: Ref| { + let output: u32 = bevy::utils::Duration::subsec_millis(&_self) .into(); output }, ) .register( - "mul_f32", - |_self: Val, rhs: f32| { - let output: Val = bevy::utils::Duration::mul_f32( - _self.into_inner(), - rhs, - ) - .into(); + "subsec_nanos", + |_self: Ref| { + let output: u32 = bevy::utils::Duration::subsec_nanos(&_self).into(); output }, - ) + ); + NamespaceBuilder::<::bevy::utils::Instant>::new(world) .register( - "div_f64", - |_self: Val, rhs: f64| { - let output: Val = bevy::utils::Duration::div_f64( - _self.into_inner(), - rhs, - ) + "add", + |_self: Val, other: Val| { + let output: Val = >::add(_self.into_inner(), other.into_inner()) .into(); output }, ) .register( - "div_f32", - |_self: Val, rhs: f32| { - let output: Val = bevy::utils::Duration::div_f32( - _self.into_inner(), - rhs, + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( + &_self, ) .into(); output }, ) .register( - "div_duration_f64", - |_self: Val, rhs: Val| { - let output: f64 = bevy::utils::Duration::div_duration_f64( - _self.into_inner(), - rhs.into_inner(), + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, ) .into(); output }, ) .register( - "div_duration_f32", - |_self: Val, rhs: Val| { - let output: f32 = bevy::utils::Duration::div_duration_f32( - _self.into_inner(), - rhs.into_inner(), + "duration_since", + |_self: Ref, earlier: Val| { + let output: Val = bevy::utils::Instant::duration_since( + &_self, + earlier.into_inner(), ) .into(); output }, - ); - NamespaceBuilder::<::bevy::utils::Instant>::new(world) + ) .register( - "assert_receiver_is_total_eq", + "elapsed", |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( + let output: Val = bevy::utils::Instant::elapsed( &_self, ) .into(); @@ -593,26 +634,6 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { output }, ) - .register( - "sub", - |_self: Val, other: Val| { - let output: Val = >::sub(_self.into_inner(), other.into_inner()) - .into(); - output - }, - ) - .register( - "sub", - |_self: Val, other: Val| { - let output: Val = >::sub(_self.into_inner(), other.into_inner()) - .into(); - output - }, - ) .register( "now", || { @@ -621,17 +642,6 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { output }, ) - .register( - "duration_since", - |_self: Ref, earlier: Val| { - let output: Val = bevy::utils::Instant::duration_since( - &_self, - earlier.into_inner(), - ) - .into(); - output - }, - ) .register( "saturating_duration_since", |_self: Ref, earlier: Val| { @@ -644,40 +654,30 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "elapsed", - |_self: Ref| { - let output: Val = bevy::utils::Instant::elapsed( - &_self, - ) - .into(); - output - }, - ) - .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) + "sub", + |_self: Val, other: Val| { + let output: Val = >::sub(_self.into_inner(), other.into_inner()) .into(); output }, ) .register( - "add", - |_self: Val, other: Val| { - let output: Val = >::add(_self.into_inner(), other.into_inner()) + "sub", + |_self: Val, other: Val| { + let output: Val = >::sub(_self.into_inner(), other.into_inner()) .into(); output }, ); NamespaceBuilder::<::std::ops::RangeFull>::new(world) .register( - "clone", + "assert_receiver_is_total_eq", |_self: Ref| { - let output: Val = ::clone( + let output: () = ::assert_receiver_is_total_eq( &_self, ) .into(); @@ -685,9 +685,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "assert_receiver_is_total_eq", + "clone", |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( + let output: Val = ::clone( &_self, ) .into(); @@ -706,131 +706,126 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { ); NamespaceBuilder::<::bevy::math::Quat>::new(world) .register( - "neg", - |_self: Val| { - let output: Val = ::neg( - _self.into_inner(), + "abs_diff_eq", + | + _self: Val, + rhs: Val, + max_abs_diff: f32| + { + let output: bool = bevy::math::Quat::abs_diff_eq( + _self.into_inner(), + rhs.into_inner(), + max_abs_diff, ) .into(); output }, ) .register( - "mul", + "add", |_self: Val, rhs: Val| { - let output: Val = = >::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output - }, - ) - .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + >>::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "eq", - |_self: Ref, rhs: Ref| { - let output: bool = >::eq(&_self, &rhs) + "angle_between", + |_self: Val, rhs: Val| { + let output: f32 = bevy::math::Quat::angle_between( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + "as_dquat", + |_self: Val| { + let output: Val = bevy::math::Quat::as_dquat( + _self.into_inner(), + ) .into(); output }, ) .register( - "from_xyzw", - |x: f32, y: f32, z: f32, w: f32| { - let output: Val = bevy::math::Quat::from_xyzw( - x, - y, - z, - w, + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, ) .into(); output }, ) .register( - "from_array", - |a: [f32; 4]| { - let output: Val = bevy::math::Quat::from_array(a) + "conjugate", + |_self: Val| { + let output: Val = bevy::math::Quat::conjugate( + _self.into_inner(), + ) .into(); output }, ) .register( - "from_vec4", - |v: Val| { - let output: Val = bevy::math::Quat::from_vec4( - v.into_inner(), - ) + "div", + |_self: Val, rhs: f32| { + let output: Val = >::div(_self.into_inner(), rhs) .into(); output }, ) .register( - "from_axis_angle", - |axis: Val, angle: f32| { - let output: Val = bevy::math::Quat::from_axis_angle( - axis.into_inner(), - angle, + "dot", + |_self: Val, rhs: Val| { + let output: f32 = bevy::math::Quat::dot( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "from_scaled_axis", - |v: Val| { - let output: Val = bevy::math::Quat::from_scaled_axis( - v.into_inner(), - ) + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = >::eq(&_self, &rhs) .into(); output }, ) .register( - "from_rotation_x", - |angle: f32| { - let output: Val = bevy::math::Quat::from_rotation_x( - angle, + "from_affine3", + |a: Ref| { + let output: Val = bevy::math::Quat::from_affine3( + &a, ) .into(); output }, ) .register( - "from_rotation_y", - |angle: f32| { - let output: Val = bevy::math::Quat::from_rotation_y( - angle, - ) + "from_array", + |a: [f32; 4]| { + let output: Val = bevy::math::Quat::from_array(a) .into(); output }, ) .register( - "from_rotation_z", - |angle: f32| { - let output: Val = bevy::math::Quat::from_rotation_z( + "from_axis_angle", + |axis: Val, angle: f32| { + let output: Val = bevy::math::Quat::from_axis_angle( + axis.into_inner(), angle, ) .into(); @@ -888,9 +883,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_rotation_arc_colinear", - |from: Val, to: Val| { - let output: Val = bevy::math::Quat::from_rotation_arc_colinear( + "from_rotation_arc_2d", + |from: Val, to: Val| { + let output: Val = bevy::math::Quat::from_rotation_arc_2d( from.into_inner(), to.into_inner(), ) @@ -899,9 +894,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_rotation_arc_2d", - |from: Val, to: Val| { - let output: Val = bevy::math::Quat::from_rotation_arc_2d( + "from_rotation_arc_colinear", + |from: Val, to: Val| { + let output: Val = bevy::math::Quat::from_rotation_arc_colinear( from.into_inner(), to.into_inner(), ) @@ -910,104 +905,108 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "to_scaled_axis", - |_self: Val| { - let output: Val = bevy::math::Quat::to_scaled_axis( - _self.into_inner(), + "from_rotation_x", + |angle: f32| { + let output: Val = bevy::math::Quat::from_rotation_x( + angle, ) .into(); output }, ) .register( - "to_euler", - |_self: Val, order: Val| { - let output: (f32, f32, f32) = bevy::math::Quat::to_euler( - _self.into_inner(), - order.into_inner(), + "from_rotation_y", + |angle: f32| { + let output: Val = bevy::math::Quat::from_rotation_y( + angle, ) .into(); output }, ) .register( - "to_array", - |_self: Ref| { - let output: [f32; 4] = bevy::math::Quat::to_array(&_self).into(); + "from_rotation_z", + |angle: f32| { + let output: Val = bevy::math::Quat::from_rotation_z( + angle, + ) + .into(); output }, ) .register( - "xyz", - |_self: Val| { - let output: Val = bevy::math::Quat::xyz( - _self.into_inner(), + "from_scaled_axis", + |v: Val| { + let output: Val = bevy::math::Quat::from_scaled_axis( + v.into_inner(), ) .into(); output }, ) .register( - "conjugate", - |_self: Val| { - let output: Val = bevy::math::Quat::conjugate( - _self.into_inner(), + "from_vec4", + |v: Val| { + let output: Val = bevy::math::Quat::from_vec4( + v.into_inner(), ) .into(); output }, ) .register( - "inverse", - |_self: Val| { - let output: Val = bevy::math::Quat::inverse( - _self.into_inner(), + "from_xyzw", + |x: f32, y: f32, z: f32, w: f32| { + let output: Val = bevy::math::Quat::from_xyzw( + x, + y, + z, + w, ) .into(); output }, ) .register( - "dot", - |_self: Val, rhs: Val| { - let output: f32 = bevy::math::Quat::dot( + "inverse", + |_self: Val| { + let output: Val = bevy::math::Quat::inverse( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "length", + "is_finite", |_self: Val| { - let output: f32 = bevy::math::Quat::length(_self.into_inner()) + let output: bool = bevy::math::Quat::is_finite(_self.into_inner()) .into(); output }, ) .register( - "length_squared", + "is_nan", |_self: Val| { - let output: f32 = bevy::math::Quat::length_squared( - _self.into_inner(), - ) + let output: bool = bevy::math::Quat::is_nan(_self.into_inner()) .into(); output }, ) .register( - "length_recip", + "is_near_identity", |_self: Val| { - let output: f32 = bevy::math::Quat::length_recip(_self.into_inner()) + let output: bool = bevy::math::Quat::is_near_identity( + _self.into_inner(), + ) .into(); output }, ) .register( - "normalize", + "is_normalized", |_self: Val| { - let output: Val = bevy::math::Quat::normalize( + let output: bool = bevy::math::Quat::is_normalized( _self.into_inner(), ) .into(); @@ -1015,25 +1014,25 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "is_finite", + "length", |_self: Val| { - let output: bool = bevy::math::Quat::is_finite(_self.into_inner()) + let output: f32 = bevy::math::Quat::length(_self.into_inner()) .into(); output }, ) .register( - "is_nan", + "length_recip", |_self: Val| { - let output: bool = bevy::math::Quat::is_nan(_self.into_inner()) + let output: f32 = bevy::math::Quat::length_recip(_self.into_inner()) .into(); output }, ) .register( - "is_normalized", + "length_squared", |_self: Val| { - let output: bool = bevy::math::Quat::is_normalized( + let output: f32 = bevy::math::Quat::length_squared( _self.into_inner(), ) .into(); @@ -1041,77 +1040,63 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "is_near_identity", - |_self: Val| { - let output: bool = bevy::math::Quat::is_near_identity( + "lerp", + |_self: Val, end: Val, s: f32| { + let output: Val = bevy::math::Quat::lerp( _self.into_inner(), + end.into_inner(), + s, ) .into(); output }, ) .register( - "angle_between", + "mul", |_self: Val, rhs: Val| { - let output: f32 = bevy::math::Quat::angle_between( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "rotate_towards", - | - _self: Ref, - rhs: Val, - max_angle: f32| - { - let output: Val = bevy::math::Quat::rotate_towards( - &_self, - rhs.into_inner(), - max_angle, - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "abs_diff_eq", - | - _self: Val, - rhs: Val, - max_abs_diff: f32| - { - let output: bool = bevy::math::Quat::abs_diff_eq( - _self.into_inner(), - rhs.into_inner(), - max_abs_diff, - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "lerp", - |_self: Val, end: Val, s: f32| { - let output: Val = bevy::math::Quat::lerp( - _self.into_inner(), - end.into_inner(), - s, - ) + "mul", + |_self: Val, rhs: f32| { + let output: Val = >::mul(_self.into_inner(), rhs) .into(); output }, ) .register( - "slerp", - |_self: Val, end: Val, s: f32| { - let output: Val = bevy::math::Quat::slerp( + "mul_quat", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Quat::mul_quat( _self.into_inner(), - end.into_inner(), - s, + rhs.into_inner(), ) .into(); output @@ -1129,9 +1114,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "mul_quat", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Quat::mul_quat( + "mul_vec3a", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Quat::mul_vec3a( _self.into_inner(), rhs.into_inner(), ) @@ -1140,87 +1125,128 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_affine3", - |a: Ref| { - let output: Val = bevy::math::Quat::from_affine3( - &a, + "neg", + |_self: Val| { + let output: Val = ::neg( + _self.into_inner(), ) .into(); output }, ) .register( - "mul_vec3a", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Quat::mul_vec3a( + "normalize", + |_self: Val| { + let output: Val = bevy::math::Quat::normalize( _self.into_inner(), + ) + .into(); + output + }, + ) + .register( + "rotate_towards", + | + _self: Ref, + rhs: Val, + max_angle: f32| + { + let output: Val = bevy::math::Quat::rotate_towards( + &_self, rhs.into_inner(), + max_angle, ) .into(); output }, ) .register( - "as_dquat", - |_self: Val| { - let output: Val = bevy::math::Quat::as_dquat( + "slerp", + |_self: Val, end: Val, s: f32| { + let output: Val = bevy::math::Quat::slerp( _self.into_inner(), + end.into_inner(), + s, ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "clone", + "to_array", |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); + let output: [f32; 4] = bevy::math::Quat::to_array(&_self).into(); output }, ) .register( - "mul", - |_self: Val, rhs: f32| { - let output: Val = >::mul(_self.into_inner(), rhs) + "to_euler", + |_self: Val, order: Val| { + let output: (f32, f32, f32) = bevy::math::Quat::to_euler( + _self.into_inner(), + order.into_inner(), + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: f32| { - let output: Val = >::div(_self.into_inner(), rhs) + "to_scaled_axis", + |_self: Val| { + let output: Val = bevy::math::Quat::to_scaled_axis( + _self.into_inner(), + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Val| { - let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + "xyz", + |_self: Val| { + let output: Val = bevy::math::Quat::xyz( + _self.into_inner(), + ) .into(); output }, ); NamespaceBuilder::<::bevy::math::Vec3>::new(world) + .register( + "abs", + |_self: Val| { + let output: Val = bevy::math::Vec3::abs( + _self.into_inner(), + ) + .into(); + output + }, + ) + .register( + "abs_diff_eq", + | + _self: Val, + rhs: Val, + max_abs_diff: f32| + { + let output: bool = bevy::math::Vec3::abs_diff_eq( + _self.into_inner(), + rhs.into_inner(), + max_abs_diff, + ) + .into(); + output + }, + ) .register( "add", |_self: Val, rhs: Ref| { @@ -1232,29 +1258,40 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "div", + "add", |_self: Val, rhs: f32| { - let output: Val = = >::div(_self.into_inner(), rhs) + >>::add(_self.into_inner(), rhs) .into(); output }, ) .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = , rhs: Val| { + let output: Val = >::eq(&_self, &other) + >>::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "clone", + "angle_between", + |_self: Val, rhs: Val| { + let output: f32 = bevy::math::Vec3::angle_between( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + }, + ) + .register( + "any_orthogonal_vector", |_self: Ref| { - let output: Val = ::clone( + let output: Val = bevy::math::Vec3::any_orthogonal_vector( &_self, ) .into(); @@ -1262,210 +1299,194 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "rem", - |_self: Val, rhs: f32| { - let output: Val = >::rem(_self.into_inner(), rhs) + "any_orthonormal_vector", + |_self: Ref| { + let output: Val = bevy::math::Vec3::any_orthonormal_vector( + &_self, + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: Val| { - let output: Val = >::div(_self.into_inner(), rhs.into_inner()) + "as_dvec3", + |_self: Ref| { + let output: Val = bevy::math::Vec3::as_dvec3( + &_self, + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + "as_i64vec3", + |_self: Ref| { + let output: Val = bevy::math::Vec3::as_i64vec3( + &_self, + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: f32| { - let output: Val = >::mul(_self.into_inner(), rhs) + "as_ivec3", + |_self: Ref| { + let output: Val = bevy::math::Vec3::as_ivec3( + &_self, + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "as_u64vec3", + |_self: Ref| { + let output: Val = bevy::math::Vec3::as_u64vec3( + &_self, + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: f32| { - let output: Val = >::add(_self.into_inner(), rhs) + "as_uvec3", + |_self: Ref| { + let output: Val = bevy::math::Vec3::as_uvec3( + &_self, + ) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Val| { - let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) + "ceil", + |_self: Val| { + let output: Val = bevy::math::Vec3::ceil( + _self.into_inner(), + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Ref| { - let output: Val = >::mul(_self.into_inner(), &rhs) - .into(); - output - }, - ) - .register( - "rem", - |_self: Val, rhs: Ref| { - let output: Val = >::rem(_self.into_inner(), &rhs) - .into(); - output - }, - ) - .register( - "sub", - |_self: Val, rhs: Ref| { - let output: Val = >::sub(_self.into_inner(), &rhs) - .into(); - output - }, - ) - .register( - "new", - |x: f32, y: f32, z: f32| { - let output: Val = bevy::math::Vec3::new(x, y, z) + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = bevy::math::Vec3::clamp( + _self.into_inner(), + min.into_inner(), + max.into_inner(), + ) .into(); output }, ) .register( - "splat", - |v: f32| { - let output: Val = bevy::math::Vec3::splat(v) + "clamp_length", + |_self: Val, min: f32, max: f32| { + let output: Val = bevy::math::Vec3::clamp_length( + _self.into_inner(), + min, + max, + ) .into(); output }, ) .register( - "select", - | - mask: Val, - if_true: Val, - if_false: Val| - { - let output: Val = bevy::math::Vec3::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), + "clamp_length_max", + |_self: Val, max: f32| { + let output: Val = bevy::math::Vec3::clamp_length_max( + _self.into_inner(), + max, ) .into(); output }, ) .register( - "from_array", - |a: [f32; 3]| { - let output: Val = bevy::math::Vec3::from_array(a) + "clamp_length_min", + |_self: Val, min: f32| { + let output: Val = bevy::math::Vec3::clamp_length_min( + _self.into_inner(), + min, + ) .into(); output }, ) .register( - "to_array", + "clone", |_self: Ref| { - let output: [f32; 3] = bevy::math::Vec3::to_array(&_self).into(); + let output: Val = ::clone( + &_self, + ) + .into(); output }, ) .register( - "extend", - |_self: Val, w: f32| { - let output: Val = bevy::math::Vec3::extend( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3::cmpeq( _self.into_inner(), - w, + rhs.into_inner(), ) .into(); output }, ) .register( - "truncate", - |_self: Val| { - let output: Val = bevy::math::Vec3::truncate( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3::cmpge( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "with_x", - |_self: Val, x: f32| { - let output: Val = bevy::math::Vec3::with_x( + "cmpgt", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3::cmpgt( _self.into_inner(), - x, + rhs.into_inner(), ) .into(); output }, ) .register( - "with_y", - |_self: Val, y: f32| { - let output: Val = bevy::math::Vec3::with_y( + "cmple", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3::cmple( _self.into_inner(), - y, + rhs.into_inner(), ) .into(); output }, ) .register( - "with_z", - |_self: Val, z: f32| { - let output: Val = bevy::math::Vec3::with_z( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3::cmplt( _self.into_inner(), - z, + rhs.into_inner(), ) .into(); output }, ) .register( - "dot", + "cmpne", |_self: Val, rhs: Val| { - let output: f32 = bevy::math::Vec3::dot( + let output: Val = bevy::math::Vec3::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -1474,9 +1495,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "dot_into_vec", + "copysign", |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3::dot_into_vec( + let output: Val = bevy::math::Vec3::copysign( _self.into_inner(), rhs.into_inner(), ) @@ -1496,9 +1517,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "min", + "distance", |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3::min( + let output: f32 = bevy::math::Vec3::distance( _self.into_inner(), rhs.into_inner(), ) @@ -1507,9 +1528,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "max", + "distance_squared", |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3::max( + let output: f32 = bevy::math::Vec3::distance_squared( _self.into_inner(), rhs.into_inner(), ) @@ -1518,59 +1539,61 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "clamp", - | - _self: Val, - min: Val, - max: Val| - { - let output: Val = bevy::math::Vec3::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) + "div", + |_self: Val, rhs: f32| { + let output: Val = >::div(_self.into_inner(), rhs) .into(); output }, ) .register( - "min_element", - |_self: Val| { - let output: f32 = bevy::math::Vec3::min_element(_self.into_inner()) + "div", + |_self: Val, rhs: Val| { + let output: Val = >::div(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "max_element", - |_self: Val| { - let output: f32 = bevy::math::Vec3::max_element(_self.into_inner()) + "div", + |_self: Val, rhs: Ref| { + let output: Val = >::div(_self.into_inner(), &rhs) .into(); output }, ) .register( - "element_sum", - |_self: Val| { - let output: f32 = bevy::math::Vec3::element_sum(_self.into_inner()) + "div_euclid", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3::div_euclid( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "element_product", - |_self: Val| { - let output: f32 = bevy::math::Vec3::element_product( + "dot", + |_self: Val, rhs: Val| { + let output: f32 = bevy::math::Vec3::dot( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "cmpeq", + "dot_into_vec", |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3::cmpeq( + let output: Val = bevy::math::Vec3::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -1579,64 +1602,58 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cmpne", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3::cmpne( + "element_product", + |_self: Val| { + let output: f32 = bevy::math::Vec3::element_product( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "cmpge", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) + "element_sum", + |_self: Val| { + let output: f32 = bevy::math::Vec3::element_sum(_self.into_inner()) .into(); output }, ) .register( - "cmpgt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) + "eq", + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "cmple", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3::cmple( + "exp", + |_self: Val| { + let output: Val = bevy::math::Vec3::exp( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "cmplt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3::cmplt( + "extend", + |_self: Val, w: f32| { + let output: Val = bevy::math::Vec3::extend( _self.into_inner(), - rhs.into_inner(), + w, ) .into(); output }, ) .register( - "abs", + "floor", |_self: Val| { - let output: Val = bevy::math::Vec3::abs( + let output: Val = bevy::math::Vec3::floor( _self.into_inner(), ) .into(); @@ -1644,9 +1661,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "signum", + "fract", |_self: Val| { - let output: Val = bevy::math::Vec3::signum( + let output: Val = bevy::math::Vec3::fract( _self.into_inner(), ) .into(); @@ -1654,22 +1671,19 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "copysign", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3::copysign( + "fract_gl", + |_self: Val| { + let output: Val = bevy::math::Vec3::fract_gl( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "is_negative_bitmask", - |_self: Val| { - let output: u32 = bevy::math::Vec3::is_negative_bitmask( - _self.into_inner(), - ) + "from_array", + |a: [f32; 3]| { + let output: Val = bevy::math::Vec3::from_array(a) .into(); output }, @@ -1711,17 +1725,19 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "length", + "is_negative_bitmask", |_self: Val| { - let output: f32 = bevy::math::Vec3::length(_self.into_inner()) + let output: u32 = bevy::math::Vec3::is_negative_bitmask( + _self.into_inner(), + ) .into(); output }, ) .register( - "length_squared", + "is_normalized", |_self: Val| { - let output: f32 = bevy::math::Vec3::length_squared( + let output: bool = bevy::math::Vec3::is_normalized( _self.into_inner(), ) .into(); @@ -1729,50 +1745,47 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "length_recip", + "length", |_self: Val| { - let output: f32 = bevy::math::Vec3::length_recip(_self.into_inner()) + let output: f32 = bevy::math::Vec3::length(_self.into_inner()) .into(); output }, ) .register( - "distance", - |_self: Val, rhs: Val| { - let output: f32 = bevy::math::Vec3::distance( - _self.into_inner(), - rhs.into_inner(), - ) + "length_recip", + |_self: Val| { + let output: f32 = bevy::math::Vec3::length_recip(_self.into_inner()) .into(); output }, ) .register( - "distance_squared", - |_self: Val, rhs: Val| { - let output: f32 = bevy::math::Vec3::distance_squared( + "length_squared", + |_self: Val| { + let output: f32 = bevy::math::Vec3::length_squared( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "div_euclid", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3::div_euclid( + "lerp", + |_self: Val, rhs: Val, s: f32| { + let output: Val = bevy::math::Vec3::lerp( _self.into_inner(), rhs.into_inner(), + s, ) .into(); output }, ) .register( - "rem_euclid", + "max", |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3::rem_euclid( + let output: Val = bevy::math::Vec3::max( _self.into_inner(), rhs.into_inner(), ) @@ -1781,104 +1794,105 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "normalize", + "max_element", |_self: Val| { - let output: Val = bevy::math::Vec3::normalize( - _self.into_inner(), - ) + let output: f32 = bevy::math::Vec3::max_element(_self.into_inner()) .into(); output }, ) .register( - "normalize_or", - |_self: Val, fallback: Val| { - let output: Val = bevy::math::Vec3::normalize_or( + "midpoint", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3::midpoint( _self.into_inner(), - fallback.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "normalize_or_zero", - |_self: Val| { - let output: Val = bevy::math::Vec3::normalize_or_zero( + "min", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3::min( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "is_normalized", + "min_element", |_self: Val| { - let output: bool = bevy::math::Vec3::is_normalized( - _self.into_inner(), - ) + let output: f32 = bevy::math::Vec3::min_element(_self.into_inner()) .into(); output }, ) .register( - "project_onto", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3::project_onto( - _self.into_inner(), + "move_towards", + |_self: Ref, rhs: Val, d: f32| { + let output: Val = bevy::math::Vec3::move_towards( + &_self, rhs.into_inner(), + d, ) .into(); output }, ) .register( - "reject_from", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3::reject_from( - _self.into_inner(), - rhs.into_inner(), - ) + "mul", + |_self: Val, rhs: f32| { + let output: Val = >::mul(_self.into_inner(), rhs) .into(); output }, ) .register( - "project_onto_normalized", + "mul", |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3::project_onto_normalized( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "reject_from_normalized", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3::reject_from_normalized( - _self.into_inner(), - rhs.into_inner(), - ) + "mul", + |_self: Val, rhs: Ref| { + let output: Val = >::mul(_self.into_inner(), &rhs) .into(); output }, ) .register( - "round", - |_self: Val| { - let output: Val = bevy::math::Vec3::round( + "mul_add", + | + _self: Val, + a: Val, + b: Val| + { + let output: Val = bevy::math::Vec3::mul_add( _self.into_inner(), + a.into_inner(), + b.into_inner(), ) .into(); output }, ) .register( - "floor", + "neg", |_self: Val| { - let output: Val = bevy::math::Vec3::floor( + let output: Val = ::neg( _self.into_inner(), ) .into(); @@ -1886,9 +1900,17 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "ceil", + "new", + |x: f32, y: f32, z: f32| { + let output: Val = bevy::math::Vec3::new(x, y, z) + .into(); + output + }, + ) + .register( + "normalize", |_self: Val| { - let output: Val = bevy::math::Vec3::ceil( + let output: Val = bevy::math::Vec3::normalize( _self.into_inner(), ) .into(); @@ -1896,19 +1918,20 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "trunc", - |_self: Val| { - let output: Val = bevy::math::Vec3::trunc( + "normalize_or", + |_self: Val, fallback: Val| { + let output: Val = bevy::math::Vec3::normalize_or( _self.into_inner(), + fallback.into_inner(), ) .into(); output }, ) .register( - "fract", + "normalize_or_zero", |_self: Val| { - let output: Val = bevy::math::Vec3::fract( + let output: Val = bevy::math::Vec3::normalize_or_zero( _self.into_inner(), ) .into(); @@ -1916,31 +1939,33 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "fract_gl", - |_self: Val| { - let output: Val = bevy::math::Vec3::fract_gl( + "powf", + |_self: Val, n: f32| { + let output: Val = bevy::math::Vec3::powf( _self.into_inner(), + n, ) .into(); output }, ) .register( - "exp", - |_self: Val| { - let output: Val = bevy::math::Vec3::exp( + "project_onto", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3::project_onto( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "powf", - |_self: Val, n: f32| { - let output: Val = bevy::math::Vec3::powf( + "project_onto_normalized", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3::project_onto_normalized( _self.into_inner(), - n, + rhs.into_inner(), ) .into(); output @@ -1957,33 +1982,32 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "lerp", - |_self: Val, rhs: Val, s: f32| { - let output: Val = bevy::math::Vec3::lerp( + "reflect", + |_self: Val, normal: Val| { + let output: Val = bevy::math::Vec3::reflect( _self.into_inner(), - rhs.into_inner(), - s, + normal.into_inner(), ) .into(); output }, ) .register( - "move_towards", - |_self: Ref, rhs: Val, d: f32| { - let output: Val = bevy::math::Vec3::move_towards( - &_self, - rhs.into_inner(), - d, + "refract", + |_self: Val, normal: Val, eta: f32| { + let output: Val = bevy::math::Vec3::refract( + _self.into_inner(), + normal.into_inner(), + eta, ) .into(); output }, ) .register( - "midpoint", + "reject_from", |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3::midpoint( + let output: Val = bevy::math::Vec3::reject_from( _self.into_inner(), rhs.into_inner(), ) @@ -1992,300 +2016,322 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "abs_diff_eq", - | - _self: Val, - rhs: Val, - max_abs_diff: f32| - { - let output: bool = bevy::math::Vec3::abs_diff_eq( + "reject_from_normalized", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3::reject_from_normalized( _self.into_inner(), rhs.into_inner(), - max_abs_diff, ) .into(); output }, ) .register( - "clamp_length", - |_self: Val, min: f32, max: f32| { - let output: Val = bevy::math::Vec3::clamp_length( - _self.into_inner(), - min, - max, - ) + "rem", + |_self: Val, rhs: f32| { + let output: Val = >::rem(_self.into_inner(), rhs) .into(); output }, ) .register( - "clamp_length_max", - |_self: Val, max: f32| { - let output: Val = bevy::math::Vec3::clamp_length_max( - _self.into_inner(), - max, - ) + "rem", + |_self: Val, rhs: Val| { + let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "clamp_length_min", - |_self: Val, min: f32| { - let output: Val = bevy::math::Vec3::clamp_length_min( + "rem", + |_self: Val, rhs: Ref| { + let output: Val = >::rem(_self.into_inner(), &rhs) + .into(); + output + }, + ) + .register( + "rem_euclid", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3::rem_euclid( _self.into_inner(), - min, + rhs.into_inner(), ) .into(); output }, ) .register( - "mul_add", - | - _self: Val, - a: Val, - b: Val| - { - let output: Val = bevy::math::Vec3::mul_add( + "round", + |_self: Val| { + let output: Val = bevy::math::Vec3::round( _self.into_inner(), - a.into_inner(), - b.into_inner(), ) .into(); output }, ) .register( - "reflect", - |_self: Val, normal: Val| { - let output: Val = bevy::math::Vec3::reflect( - _self.into_inner(), - normal.into_inner(), + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = bevy::math::Vec3::select( + mask.into_inner(), + if_true.into_inner(), + if_false.into_inner(), ) .into(); output }, ) .register( - "refract", - |_self: Val, normal: Val, eta: f32| { - let output: Val = bevy::math::Vec3::refract( + "signum", + |_self: Val| { + let output: Val = bevy::math::Vec3::signum( _self.into_inner(), - normal.into_inner(), - eta, ) .into(); output }, ) .register( - "angle_between", + "splat", + |v: f32| { + let output: Val = bevy::math::Vec3::splat(v) + .into(); + output + }, + ) + .register( + "sub", |_self: Val, rhs: Val| { - let output: f32 = bevy::math::Vec3::angle_between( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "any_orthogonal_vector", - |_self: Ref| { - let output: Val = bevy::math::Vec3::any_orthogonal_vector( - &_self, - ) + "sub", + |_self: Val, rhs: Ref| { + let output: Val = >::sub(_self.into_inner(), &rhs) .into(); output }, ) .register( - "any_orthonormal_vector", - |_self: Ref| { - let output: Val = bevy::math::Vec3::any_orthonormal_vector( - &_self, - ) + "sub", + |_self: Val, rhs: f32| { + let output: Val = >::sub(_self.into_inner(), rhs) .into(); output }, ) .register( - "as_dvec3", + "to_array", |_self: Ref| { - let output: Val = bevy::math::Vec3::as_dvec3( - &_self, + let output: [f32; 3] = bevy::math::Vec3::to_array(&_self).into(); + output + }, + ) + .register( + "trunc", + |_self: Val| { + let output: Val = bevy::math::Vec3::trunc( + _self.into_inner(), ) .into(); output }, ) .register( - "as_ivec3", - |_self: Ref| { - let output: Val = bevy::math::Vec3::as_ivec3( - &_self, + "truncate", + |_self: Val| { + let output: Val = bevy::math::Vec3::truncate( + _self.into_inner(), ) .into(); output }, ) .register( - "as_uvec3", - |_self: Ref| { - let output: Val = bevy::math::Vec3::as_uvec3( - &_self, + "with_x", + |_self: Val, x: f32| { + let output: Val = bevy::math::Vec3::with_x( + _self.into_inner(), + x, ) .into(); output }, ) .register( - "as_i64vec3", - |_self: Ref| { - let output: Val = bevy::math::Vec3::as_i64vec3( - &_self, + "with_y", + |_self: Val, y: f32| { + let output: Val = bevy::math::Vec3::with_y( + _self.into_inner(), + y, ) .into(); output }, ) .register( - "as_u64vec3", - |_self: Ref| { - let output: Val = bevy::math::Vec3::as_u64vec3( - &_self, + "with_z", + |_self: Val, z: f32| { + let output: Val = bevy::math::Vec3::with_z( + _self.into_inner(), + z, ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::IVec2>::new(world) .register( - "div", - |_self: Val, rhs: Ref| { - let output: Val = >::div(_self.into_inner(), &rhs) + "abs", + |_self: Val| { + let output: Val = bevy::math::IVec2::abs( + _self.into_inner(), + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: f32| { - let output: Val = >::sub(_self.into_inner(), rhs) + "add", + |_self: Val, rhs: i32| { + let output: Val = >::add(_self.into_inner(), rhs) .into(); output }, ) .register( "add", - |_self: Val, rhs: Val| { - let output: Val = , rhs: Val| { + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "neg", - |_self: Val| { - let output: Val = ::neg( - _self.into_inner(), - ) + "add", + |_self: Val, rhs: Ref| { + let output: Val = >::add(_self.into_inner(), &rhs) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::IVec2>::new(world) + ) .register( - "new", - |x: i32, y: i32| { - let output: Val = bevy::math::IVec2::new(x, y) + "as_dvec2", + |_self: Ref| { + let output: Val = bevy::math::IVec2::as_dvec2( + &_self, + ) .into(); output }, ) .register( - "splat", - |v: i32| { - let output: Val = bevy::math::IVec2::splat(v) + "as_i64vec2", + |_self: Ref| { + let output: Val = bevy::math::IVec2::as_i64vec2( + &_self, + ) .into(); output }, ) .register( - "select", - | - mask: Val, - if_true: Val, - if_false: Val| - { - let output: Val = bevy::math::IVec2::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), + "as_u64vec2", + |_self: Ref| { + let output: Val = bevy::math::IVec2::as_u64vec2( + &_self, ) .into(); output }, ) .register( - "from_array", - |a: [i32; 2]| { - let output: Val = bevy::math::IVec2::from_array(a) + "as_uvec2", + |_self: Ref| { + let output: Val = bevy::math::IVec2::as_uvec2( + &_self, + ) .into(); output }, ) .register( - "to_array", + "as_vec2", |_self: Ref| { - let output: [i32; 2] = bevy::math::IVec2::to_array(&_self).into(); + let output: Val = bevy::math::IVec2::as_vec2( + &_self, + ) + .into(); output }, ) .register( - "extend", - |_self: Val, z: i32| { - let output: Val = bevy::math::IVec2::extend( - _self.into_inner(), - z, + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( + &_self, ) .into(); output }, ) .register( - "with_x", - |_self: Val, x: i32| { - let output: Val = bevy::math::IVec2::with_x( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = bevy::math::IVec2::clamp( _self.into_inner(), - x, + min.into_inner(), + max.into_inner(), ) .into(); output }, ) .register( - "with_y", - |_self: Val, y: i32| { - let output: Val = bevy::math::IVec2::with_y( - _self.into_inner(), - y, + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, ) .into(); output }, ) .register( - "dot", + "cmpeq", |_self: Val, rhs: Val| { - let output: i32 = bevy::math::IVec2::dot( + let output: Val = bevy::math::IVec2::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -2294,9 +2340,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "dot_into_vec", + "cmpge", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec2::dot_into_vec( + let output: Val = bevy::math::IVec2::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -2305,9 +2351,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "min", + "cmpgt", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec2::min( + let output: Val = bevy::math::IVec2::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -2316,9 +2362,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "max", + "cmple", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec2::max( + let output: Val = bevy::math::IVec2::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -2327,70 +2373,72 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "clamp", - | - _self: Val, - min: Val, - max: Val| - { - let output: Val = bevy::math::IVec2::clamp( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec2::cmplt( _self.into_inner(), - min.into_inner(), - max.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "min_element", - |_self: Val| { - let output: i32 = bevy::math::IVec2::min_element(_self.into_inner()) + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec2::cmpne( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "max_element", - |_self: Val| { - let output: i32 = bevy::math::IVec2::max_element(_self.into_inner()) + "distance_squared", + |_self: Val, rhs: Val| { + let output: i32 = bevy::math::IVec2::distance_squared( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "element_sum", - |_self: Val| { - let output: i32 = bevy::math::IVec2::element_sum(_self.into_inner()) + "div", + |_self: Val, rhs: Ref| { + let output: Val = >::div(_self.into_inner(), &rhs) .into(); output }, ) .register( - "element_product", - |_self: Val| { - let output: i32 = bevy::math::IVec2::element_product( - _self.into_inner(), - ) + "div", + |_self: Val, rhs: i32| { + let output: Val = >::div(_self.into_inner(), rhs) .into(); output }, ) .register( - "cmpeq", + "div", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec2::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::div(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "cmpne", + "div_euclid", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec2::cmpne( + let output: Val = bevy::math::IVec2::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -2399,9 +2447,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cmpge", + "dot", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec2::cmpge( + let output: i32 = bevy::math::IVec2::dot( _self.into_inner(), rhs.into_inner(), ) @@ -2410,9 +2458,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cmpgt", + "dot_into_vec", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec2::cmpgt( + let output: Val = bevy::math::IVec2::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -2421,47 +2469,52 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cmple", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec2::cmple( + "element_product", + |_self: Val| { + let output: i32 = bevy::math::IVec2::element_product( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "cmplt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec2::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) + "element_sum", + |_self: Val| { + let output: i32 = bevy::math::IVec2::element_sum(_self.into_inner()) .into(); output }, ) .register( - "abs", - |_self: Val| { - let output: Val = bevy::math::IVec2::abs( - _self.into_inner(), - ) + "eq", + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "signum", - |_self: Val| { - let output: Val = bevy::math::IVec2::signum( + "extend", + |_self: Val, z: i32| { + let output: Val = bevy::math::IVec2::extend( _self.into_inner(), + z, ) .into(); output }, ) + .register( + "from_array", + |a: [i32; 2]| { + let output: Val = bevy::math::IVec2::from_array(a) + .into(); + output + }, + ) .register( "is_negative_bitmask", |_self: Val| { @@ -2483,9 +2536,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "distance_squared", + "max", |_self: Val, rhs: Val| { - let output: i32 = bevy::math::IVec2::distance_squared( + let output: Val = bevy::math::IVec2::max( _self.into_inner(), rhs.into_inner(), ) @@ -2494,20 +2547,17 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "div_euclid", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec2::div_euclid( - _self.into_inner(), - rhs.into_inner(), - ) + "max_element", + |_self: Val| { + let output: i32 = bevy::math::IVec2::max_element(_self.into_inner()) .into(); output }, ) .register( - "rem_euclid", + "min", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec2::rem_euclid( + let output: Val = bevy::math::IVec2::min( _self.into_inner(), rhs.into_inner(), ) @@ -2516,124 +2566,116 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "perp", + "min_element", |_self: Val| { - let output: Val = bevy::math::IVec2::perp( - _self.into_inner(), - ) + let output: i32 = bevy::math::IVec2::min_element(_self.into_inner()) .into(); output }, ) .register( - "perp_dot", - |_self: Val, rhs: Val| { - let output: i32 = bevy::math::IVec2::perp_dot( - _self.into_inner(), - rhs.into_inner(), - ) + "mul", + |_self: Val, rhs: Ref| { + let output: Val = >::mul(_self.into_inner(), &rhs) .into(); output }, ) .register( - "rotate", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec2::rotate( - _self.into_inner(), - rhs.into_inner(), - ) + "mul", + |_self: Val, rhs: i32| { + let output: Val = >::mul(_self.into_inner(), rhs) .into(); output }, ) .register( - "as_vec2", - |_self: Ref| { - let output: Val = bevy::math::IVec2::as_vec2( - &_self, - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "as_dvec2", - |_self: Ref| { - let output: Val = bevy::math::IVec2::as_dvec2( - &_self, + "neg", + |_self: Val| { + let output: Val = ::neg( + _self.into_inner(), ) .into(); output }, ) .register( - "as_uvec2", - |_self: Ref| { - let output: Val = bevy::math::IVec2::as_uvec2( - &_self, - ) + "new", + |x: i32, y: i32| { + let output: Val = bevy::math::IVec2::new(x, y) .into(); output }, ) .register( - "as_i64vec2", - |_self: Ref| { - let output: Val = bevy::math::IVec2::as_i64vec2( - &_self, + "perp", + |_self: Val| { + let output: Val = bevy::math::IVec2::perp( + _self.into_inner(), ) .into(); output }, ) .register( - "as_u64vec2", - |_self: Ref| { - let output: Val = bevy::math::IVec2::as_u64vec2( - &_self, + "perp_dot", + |_self: Val, rhs: Val| { + let output: i32 = bevy::math::IVec2::perp_dot( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "wrapping_add", + "rem", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec2::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "wrapping_sub", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec2::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) + "rem", + |_self: Val, rhs: i32| { + let output: Val = >::rem(_self.into_inner(), rhs) .into(); output }, ) .register( - "wrapping_mul", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec2::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) + "rem", + |_self: Val, rhs: Ref| { + let output: Val = >::rem(_self.into_inner(), &rhs) .into(); output }, ) .register( - "wrapping_div", + "rem_euclid", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec2::wrapping_div( + let output: Val = bevy::math::IVec2::rem_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -2642,9 +2684,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_add", + "rotate", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec2::saturating_add( + let output: Val = bevy::math::IVec2::rotate( _self.into_inner(), rhs.into_inner(), ) @@ -2653,9 +2695,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_sub", + "saturating_add", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec2::saturating_sub( + let output: Val = bevy::math::IVec2::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -2664,9 +2706,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_mul", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec2::saturating_mul( + "saturating_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec2::saturating_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -2686,9 +2728,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_add_unsigned", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec2::wrapping_add_unsigned( + "saturating_mul", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec2::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -2697,9 +2739,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_sub_unsigned", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec2::wrapping_sub_unsigned( + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec2::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -2708,9 +2750,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_add_unsigned", + "saturating_sub_unsigned", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec2::saturating_add_unsigned( + let output: Val = bevy::math::IVec2::saturating_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -2719,20 +2761,25 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_sub_unsigned", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec2::saturating_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = bevy::math::IVec2::select( + mask.into_inner(), + if_true.into_inner(), + if_false.into_inner(), + ) .into(); output }, ) .register( - "neg", + "signum", |_self: Val| { - let output: Val = ::neg( + let output: Val = bevy::math::IVec2::signum( _self.into_inner(), ) .into(); @@ -2740,291 +2787,290 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "mul", - |_self: Val, rhs: Ref| { - let output: Val = >::mul(_self.into_inner(), &rhs) + "splat", + |v: i32| { + let output: Val = bevy::math::IVec2::splat(v) .into(); output }, ) .register( - "div", + "sub", |_self: Val, rhs: Ref| { - let output: Val = = >::div(_self.into_inner(), &rhs) - .into(); - output - }, - ) - .register( - "add", - |_self: Val, rhs: i32| { - let output: Val = >::add(_self.into_inner(), rhs) + >>::sub(_self.into_inner(), &rhs) .into(); output }, ) .register( - "mul", + "sub", |_self: Val, rhs: i32| { - let output: Val = = >::mul(_self.into_inner(), rhs) + >>::sub(_self.into_inner(), rhs) .into(); output }, ) .register( - "rem", + "sub", |_self: Val, rhs: Val| { - let output: Val = = >::rem(_self.into_inner(), rhs.into_inner()) + >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Ref| { - let output: Val = >::sub(_self.into_inner(), &rhs) - .into(); + "to_array", + |_self: Ref| { + let output: [i32; 2] = bevy::math::IVec2::to_array(&_self).into(); output }, ) .register( - "add", - |_self: Val, rhs: Val| { - let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + "with_x", + |_self: Val, x: i32| { + let output: Val = bevy::math::IVec2::with_x( + _self.into_inner(), + x, + ) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: i32| { - let output: Val = >::rem(_self.into_inner(), rhs) + "with_y", + |_self: Val, y: i32| { + let output: Val = bevy::math::IVec2::with_y( + _self.into_inner(), + y, + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Ref| { - let output: Val = >::add(_self.into_inner(), &rhs) + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec2::wrapping_add( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: i32| { - let output: Val = >::div(_self.into_inner(), rhs) + "wrapping_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec2::wrapping_add_unsigned( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec2::wrapping_div( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) + "wrapping_mul", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec2::wrapping_mul( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "div", + "wrapping_sub", |_self: Val, rhs: Val| { - let output: Val = >::div(_self.into_inner(), rhs.into_inner()) + let output: Val = bevy::math::IVec2::wrapping_sub( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Ref| { - let output: Val = >::rem(_self.into_inner(), &rhs) + "wrapping_sub_unsigned", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec2::wrapping_sub_unsigned( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::IVec3>::new(world) .register( - "sub", - |_self: Val, rhs: i32| { - let output: Val = >::sub(_self.into_inner(), rhs) + "abs", + |_self: Val| { + let output: Val = bevy::math::IVec3::abs( + _self.into_inner(), + ) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) + "add", + |_self: Val, rhs: Ref| { + let output: Val = >::add(_self.into_inner(), &rhs) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + "add", + |_self: Val, rhs: Val| { + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "add", + |_self: Val, rhs: i32| { + let output: Val = >::add(_self.into_inner(), rhs) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::IVec3>::new(world) + ) .register( - "new", - |x: i32, y: i32, z: i32| { - let output: Val = bevy::math::IVec3::new(x, y, z) + "as_dvec3", + |_self: Ref| { + let output: Val = bevy::math::IVec3::as_dvec3( + &_self, + ) .into(); output }, ) .register( - "splat", - |v: i32| { - let output: Val = bevy::math::IVec3::splat(v) + "as_i64vec3", + |_self: Ref| { + let output: Val = bevy::math::IVec3::as_i64vec3( + &_self, + ) .into(); output }, ) .register( - "select", - | - mask: Val, - if_true: Val, - if_false: Val| - { - let output: Val = bevy::math::IVec3::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), + "as_u64vec3", + |_self: Ref| { + let output: Val = bevy::math::IVec3::as_u64vec3( + &_self, ) .into(); output }, ) .register( - "from_array", - |a: [i32; 3]| { - let output: Val = bevy::math::IVec3::from_array(a) + "as_uvec3", + |_self: Ref| { + let output: Val = bevy::math::IVec3::as_uvec3( + &_self, + ) .into(); output }, ) .register( - "to_array", + "as_vec3", |_self: Ref| { - let output: [i32; 3] = bevy::math::IVec3::to_array(&_self).into(); + let output: Val = bevy::math::IVec3::as_vec3( + &_self, + ) + .into(); output }, ) .register( - "extend", - |_self: Val, w: i32| { - let output: Val = bevy::math::IVec3::extend( - _self.into_inner(), - w, + "as_vec3a", + |_self: Ref| { + let output: Val = bevy::math::IVec3::as_vec3a( + &_self, ) .into(); output }, ) .register( - "truncate", - |_self: Val| { - let output: Val = bevy::math::IVec3::truncate( - _self.into_inner(), + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( + &_self, ) .into(); output }, ) .register( - "with_x", - |_self: Val, x: i32| { - let output: Val = bevy::math::IVec3::with_x( - _self.into_inner(), - x, + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = bevy::math::IVec3::clamp( + _self.into_inner(), + min.into_inner(), + max.into_inner(), ) .into(); output }, ) .register( - "with_y", - |_self: Val, y: i32| { - let output: Val = bevy::math::IVec3::with_y( - _self.into_inner(), - y, + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, ) .into(); output }, ) .register( - "with_z", - |_self: Val, z: i32| { - let output: Val = bevy::math::IVec3::with_z( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec3::cmpeq( _self.into_inner(), - z, + rhs.into_inner(), ) .into(); output }, ) .register( - "dot", + "cmpge", |_self: Val, rhs: Val| { - let output: i32 = bevy::math::IVec3::dot( + let output: Val = bevy::math::IVec3::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -3033,9 +3079,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "dot_into_vec", + "cmpgt", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec3::dot_into_vec( + let output: Val = bevy::math::IVec3::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -3044,9 +3090,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cross", + "cmple", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec3::cross( + let output: Val = bevy::math::IVec3::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -3055,9 +3101,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "min", + "cmplt", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec3::min( + let output: Val = bevy::math::IVec3::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -3066,9 +3112,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "max", + "cmpne", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec3::max( + let output: Val = bevy::math::IVec3::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -3077,59 +3123,61 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "clamp", - | - _self: Val, - min: Val, - max: Val| - { - let output: Val = bevy::math::IVec3::clamp( + "cross", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec3::cross( _self.into_inner(), - min.into_inner(), - max.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "min_element", - |_self: Val| { - let output: i32 = bevy::math::IVec3::min_element(_self.into_inner()) + "distance_squared", + |_self: Val, rhs: Val| { + let output: i32 = bevy::math::IVec3::distance_squared( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "max_element", - |_self: Val| { - let output: i32 = bevy::math::IVec3::max_element(_self.into_inner()) + "div", + |_self: Val, rhs: Ref| { + let output: Val = >::div(_self.into_inner(), &rhs) .into(); output }, ) .register( - "element_sum", - |_self: Val| { - let output: i32 = bevy::math::IVec3::element_sum(_self.into_inner()) + "div", + |_self: Val, rhs: i32| { + let output: Val = >::div(_self.into_inner(), rhs) .into(); output }, ) .register( - "element_product", - |_self: Val| { - let output: i32 = bevy::math::IVec3::element_product( - _self.into_inner(), - ) + "div", + |_self: Val, rhs: Val| { + let output: Val = >::div(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "cmpeq", + "div_euclid", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec3::cmpeq( + let output: Val = bevy::math::IVec3::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -3138,9 +3186,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cmpne", + "dot", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec3::cmpne( + let output: i32 = bevy::math::IVec3::dot( _self.into_inner(), rhs.into_inner(), ) @@ -3149,9 +3197,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cmpge", + "dot_into_vec", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec3::cmpge( + let output: Val = bevy::math::IVec3::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -3160,54 +3208,48 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cmpgt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec3::cmpgt( + "element_product", + |_self: Val| { + let output: i32 = bevy::math::IVec3::element_product( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "cmple", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec3::cmple( - _self.into_inner(), - rhs.into_inner(), - ) + "element_sum", + |_self: Val| { + let output: i32 = bevy::math::IVec3::element_sum(_self.into_inner()) .into(); output }, ) .register( - "cmplt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec3::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) + "eq", + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "abs", - |_self: Val| { - let output: Val = bevy::math::IVec3::abs( + "extend", + |_self: Val, w: i32| { + let output: Val = bevy::math::IVec3::extend( _self.into_inner(), + w, ) .into(); output }, ) .register( - "signum", - |_self: Val| { - let output: Val = bevy::math::IVec3::signum( - _self.into_inner(), - ) + "from_array", + |a: [i32; 3]| { + let output: Val = bevy::math::IVec3::from_array(a) .into(); output }, @@ -3233,9 +3275,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "distance_squared", + "max", |_self: Val, rhs: Val| { - let output: i32 = bevy::math::IVec3::distance_squared( + let output: Val = bevy::math::IVec3::max( _self.into_inner(), rhs.into_inner(), ) @@ -3244,20 +3286,17 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "div_euclid", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec3::div_euclid( - _self.into_inner(), - rhs.into_inner(), - ) + "max_element", + |_self: Val| { + let output: i32 = bevy::math::IVec3::max_element(_self.into_inner()) .into(); output }, ) .register( - "rem_euclid", + "min", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec3::rem_euclid( + let output: Val = bevy::math::IVec3::min( _self.into_inner(), rhs.into_inner(), ) @@ -3266,102 +3305,95 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "as_vec3", - |_self: Ref| { - let output: Val = bevy::math::IVec3::as_vec3( - &_self, - ) + "min_element", + |_self: Val| { + let output: i32 = bevy::math::IVec3::min_element(_self.into_inner()) .into(); output }, ) .register( - "as_vec3a", - |_self: Ref| { - let output: Val = bevy::math::IVec3::as_vec3a( - &_self, - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "as_dvec3", - |_self: Ref| { - let output: Val = bevy::math::IVec3::as_dvec3( - &_self, - ) + "mul", + |_self: Val, rhs: i32| { + let output: Val = >::mul(_self.into_inner(), rhs) .into(); output }, ) .register( - "as_uvec3", - |_self: Ref| { - let output: Val = bevy::math::IVec3::as_uvec3( - &_self, - ) + "mul", + |_self: Val, rhs: Ref| { + let output: Val = >::mul(_self.into_inner(), &rhs) .into(); output }, ) .register( - "as_i64vec3", - |_self: Ref| { - let output: Val = bevy::math::IVec3::as_i64vec3( - &_self, + "neg", + |_self: Val| { + let output: Val = ::neg( + _self.into_inner(), ) .into(); output }, ) .register( - "as_u64vec3", - |_self: Ref| { - let output: Val = bevy::math::IVec3::as_u64vec3( - &_self, - ) + "new", + |x: i32, y: i32, z: i32| { + let output: Val = bevy::math::IVec3::new(x, y, z) .into(); output }, ) .register( - "wrapping_add", + "rem", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec3::wrapping_add( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "wrapping_sub", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec3::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) + "rem", + |_self: Val, rhs: Ref| { + let output: Val = >::rem(_self.into_inner(), &rhs) .into(); output }, ) .register( - "wrapping_mul", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec3::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), - ) + "rem", + |_self: Val, rhs: i32| { + let output: Val = >::rem(_self.into_inner(), rhs) .into(); output }, ) .register( - "wrapping_div", + "rem_euclid", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec3::wrapping_div( + let output: Val = bevy::math::IVec3::rem_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -3381,9 +3413,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_sub", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec3::saturating_sub( + "saturating_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec3::saturating_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -3392,9 +3424,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_mul", + "saturating_div", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec3::saturating_mul( + let output: Val = bevy::math::IVec3::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -3403,9 +3435,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_div", + "saturating_mul", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec3::saturating_div( + let output: Val = bevy::math::IVec3::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -3414,9 +3446,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_add_unsigned", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec3::wrapping_add_unsigned( + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec3::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -3425,9 +3457,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_sub_unsigned", + "saturating_sub_unsigned", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec3::wrapping_sub_unsigned( + let output: Val = bevy::math::IVec3::saturating_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -3436,192 +3468,191 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_add_unsigned", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec3::saturating_add_unsigned( - _self.into_inner(), - rhs.into_inner(), + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = bevy::math::IVec3::select( + mask.into_inner(), + if_true.into_inner(), + if_false.into_inner(), ) .into(); output }, ) .register( - "saturating_sub_unsigned", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec3::saturating_sub_unsigned( + "signum", + |_self: Val| { + let output: Val = bevy::math::IVec3::signum( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Ref| { - let output: Val = >::add(_self.into_inner(), &rhs) - .into(); - output - }, - ) - .register( - "rem", - |_self: Val, rhs: Val| { - let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) + "splat", + |v: i32| { + let output: Val = bevy::math::IVec3::splat(v) .into(); output }, ) .register( - "rem", + "sub", |_self: Val, rhs: Ref| { - let output: Val = = >::rem(_self.into_inner(), &rhs) + >>::sub(_self.into_inner(), &rhs) .into(); output }, ) .register( - "add", + "sub", |_self: Val, rhs: Val| { - let output: Val = = >::add(_self.into_inner(), rhs.into_inner()) + >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "neg", - |_self: Val| { - let output: Val = ::neg( - _self.into_inner(), - ) + "sub", + |_self: Val, rhs: i32| { + let output: Val = >::sub(_self.into_inner(), rhs) .into(); output }, ) .register( - "div", - |_self: Val, rhs: Ref| { - let output: Val = >::div(_self.into_inner(), &rhs) - .into(); + "to_array", + |_self: Ref| { + let output: [i32; 3] = bevy::math::IVec3::to_array(&_self).into(); output }, ) .register( - "rem", - |_self: Val, rhs: i32| { - let output: Val = >::rem(_self.into_inner(), rhs) + "truncate", + |_self: Val| { + let output: Val = bevy::math::IVec3::truncate( + _self.into_inner(), + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Ref| { - let output: Val = >::sub(_self.into_inner(), &rhs) + "with_x", + |_self: Val, x: i32| { + let output: Val = bevy::math::IVec3::with_x( + _self.into_inner(), + x, + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "with_y", + |_self: Val, y: i32| { + let output: Val = bevy::math::IVec3::with_y( + _self.into_inner(), + y, + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + "with_z", + |_self: Val, z: i32| { + let output: Val = bevy::math::IVec3::with_z( + _self.into_inner(), + z, + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: i32| { - let output: Val = >::div(_self.into_inner(), rhs) + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec3::wrapping_add( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) + "wrapping_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec3::wrapping_add_unsigned( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: i32| { - let output: Val = >::sub(_self.into_inner(), rhs) + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec3::wrapping_div( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "div", + "wrapping_mul", |_self: Val, rhs: Val| { - let output: Val = >::div(_self.into_inner(), rhs.into_inner()) + let output: Val = bevy::math::IVec3::wrapping_mul( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, + "wrapping_sub", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec3::wrapping_sub( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: i32| { - let output: Val = >::mul(_self.into_inner(), rhs) + "wrapping_sub_unsigned", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec3::wrapping_sub_unsigned( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::IVec4>::new(world) .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, + "abs", + |_self: Val| { + let output: Val = bevy::math::IVec4::abs( + _self.into_inner(), ) .into(); output @@ -3629,8 +3660,8 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { ) .register( "add", - |_self: Val, rhs: i32| { - let output: Val = , rhs: i32| { + let output: Val = >::add(_self.into_inner(), rhs) .into(); @@ -3638,50 +3669,39 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "mul", - |_self: Val, rhs: Ref| { - let output: Val = >::mul(_self.into_inner(), &rhs) - .into(); - output - }, - ); - NamespaceBuilder::<::bevy::math::IVec4>::new(world) - .register( - "rem", - |_self: Val, rhs: Ref| { - let output: Val = >::rem(_self.into_inner(), &rhs) + "add", + |_self: Val, rhs: Val| { + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "mul", + "add", |_self: Val, rhs: Ref| { - let output: Val = = >::mul(_self.into_inner(), &rhs) + >>::add(_self.into_inner(), &rhs) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "as_dvec4", + |_self: Ref| { + let output: Val = bevy::math::IVec4::as_dvec4( + &_self, + ) .into(); output }, ) .register( - "assert_receiver_is_total_eq", + "as_i64vec4", |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( + let output: Val = bevy::math::IVec4::as_i64vec4( &_self, ) .into(); @@ -3689,135 +3709,97 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "add", - |_self: Val, rhs: i32| { - let output: Val = >::add(_self.into_inner(), rhs) - .into(); - output - }, - ) - .register( - "add", - |_self: Val, rhs: Val| { - let output: Val = >::add(_self.into_inner(), rhs.into_inner()) - .into(); - output - }, - ) - .register( - "new", - |x: i32, y: i32, z: i32, w: i32| { - let output: Val = bevy::math::IVec4::new( - x, - y, - z, - w, + "as_u64vec4", + |_self: Ref| { + let output: Val = bevy::math::IVec4::as_u64vec4( + &_self, ) .into(); output }, ) .register( - "splat", - |v: i32| { - let output: Val = bevy::math::IVec4::splat(v) - .into(); - output - }, - ) - .register( - "select", - | - mask: Val, - if_true: Val, - if_false: Val| - { - let output: Val = bevy::math::IVec4::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), + "as_uvec4", + |_self: Ref| { + let output: Val = bevy::math::IVec4::as_uvec4( + &_self, ) .into(); output }, ) .register( - "from_array", - |a: [i32; 4]| { - let output: Val = bevy::math::IVec4::from_array(a) + "as_vec4", + |_self: Ref| { + let output: Val = bevy::math::IVec4::as_vec4( + &_self, + ) .into(); output }, ) .register( - "to_array", + "assert_receiver_is_total_eq", |_self: Ref| { - let output: [i32; 4] = bevy::math::IVec4::to_array(&_self).into(); - output - }, - ) - .register( - "truncate", - |_self: Val| { - let output: Val = bevy::math::IVec4::truncate( - _self.into_inner(), + let output: () = ::assert_receiver_is_total_eq( + &_self, ) .into(); output }, ) .register( - "with_x", - |_self: Val, x: i32| { - let output: Val = bevy::math::IVec4::with_x( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = bevy::math::IVec4::clamp( _self.into_inner(), - x, + min.into_inner(), + max.into_inner(), ) .into(); output }, ) .register( - "with_y", - |_self: Val, y: i32| { - let output: Val = bevy::math::IVec4::with_y( - _self.into_inner(), - y, + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, ) .into(); output }, ) .register( - "with_z", - |_self: Val, z: i32| { - let output: Val = bevy::math::IVec4::with_z( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec4::cmpeq( _self.into_inner(), - z, + rhs.into_inner(), ) .into(); output }, ) .register( - "with_w", - |_self: Val, w: i32| { - let output: Val = bevy::math::IVec4::with_w( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec4::cmpge( _self.into_inner(), - w, + rhs.into_inner(), ) .into(); output }, ) .register( - "dot", + "cmpgt", |_self: Val, rhs: Val| { - let output: i32 = bevy::math::IVec4::dot( + let output: Val = bevy::math::IVec4::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -3826,9 +3808,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "dot_into_vec", + "cmple", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec4::dot_into_vec( + let output: Val = bevy::math::IVec4::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -3837,9 +3819,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "min", + "cmplt", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec4::min( + let output: Val = bevy::math::IVec4::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -3848,9 +3830,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "max", + "cmpne", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec4::max( + let output: Val = bevy::math::IVec4::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -3859,70 +3841,50 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "clamp", - | - _self: Val, - min: Val, - max: Val| - { - let output: Val = bevy::math::IVec4::clamp( + "distance_squared", + |_self: Val, rhs: Val| { + let output: i32 = bevy::math::IVec4::distance_squared( _self.into_inner(), - min.into_inner(), - max.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "min_element", - |_self: Val| { - let output: i32 = bevy::math::IVec4::min_element(_self.into_inner()) - .into(); - output - }, - ) - .register( - "max_element", - |_self: Val| { - let output: i32 = bevy::math::IVec4::max_element(_self.into_inner()) - .into(); - output - }, - ) - .register( - "element_sum", - |_self: Val| { - let output: i32 = bevy::math::IVec4::element_sum(_self.into_inner()) + "div", + |_self: Val, rhs: Ref| { + let output: Val = >::div(_self.into_inner(), &rhs) .into(); output }, ) .register( - "element_product", - |_self: Val| { - let output: i32 = bevy::math::IVec4::element_product( - _self.into_inner(), - ) + "div", + |_self: Val, rhs: i32| { + let output: Val = >::div(_self.into_inner(), rhs) .into(); output }, ) .register( - "cmpeq", + "div", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec4::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::div(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "cmpne", + "div_euclid", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec4::cmpne( + let output: Val = bevy::math::IVec4::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -3931,9 +3893,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cmpge", + "dot", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec4::cmpge( + let output: i32 = bevy::math::IVec4::dot( _self.into_inner(), rhs.into_inner(), ) @@ -3942,9 +3904,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cmpgt", + "dot_into_vec", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec4::cmpgt( + let output: Val = bevy::math::IVec4::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -3953,43 +3915,37 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cmple", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec4::cmple( + "element_product", + |_self: Val| { + let output: i32 = bevy::math::IVec4::element_product( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "cmplt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec4::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) + "element_sum", + |_self: Val| { + let output: i32 = bevy::math::IVec4::element_sum(_self.into_inner()) .into(); output }, ) .register( - "abs", - |_self: Val| { - let output: Val = bevy::math::IVec4::abs( - _self.into_inner(), - ) + "eq", + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "signum", - |_self: Val| { - let output: Val = bevy::math::IVec4::signum( - _self.into_inner(), - ) + "from_array", + |a: [i32; 4]| { + let output: Val = bevy::math::IVec4::from_array(a) .into(); output }, @@ -4015,9 +3971,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "distance_squared", + "max", |_self: Val, rhs: Val| { - let output: i32 = bevy::math::IVec4::distance_squared( + let output: Val = bevy::math::IVec4::max( _self.into_inner(), rhs.into_inner(), ) @@ -4026,20 +3982,17 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "div_euclid", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec4::div_euclid( - _self.into_inner(), - rhs.into_inner(), - ) + "max_element", + |_self: Val| { + let output: i32 = bevy::math::IVec4::max_element(_self.into_inner()) .into(); output }, ) .register( - "rem_euclid", + "min", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec4::rem_euclid( + let output: Val = bevy::math::IVec4::min( _self.into_inner(), rhs.into_inner(), ) @@ -4048,81 +4001,100 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "as_vec4", - |_self: Ref| { - let output: Val = bevy::math::IVec4::as_vec4( - &_self, - ) + "min_element", + |_self: Val| { + let output: i32 = bevy::math::IVec4::min_element(_self.into_inner()) .into(); output }, ) .register( - "as_dvec4", - |_self: Ref| { - let output: Val = bevy::math::IVec4::as_dvec4( - &_self, - ) + "mul", + |_self: Val, rhs: Ref| { + let output: Val = >::mul(_self.into_inner(), &rhs) .into(); output }, ) .register( - "as_uvec4", - |_self: Ref| { - let output: Val = bevy::math::IVec4::as_uvec4( - &_self, - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "as_i64vec4", - |_self: Ref| { - let output: Val = bevy::math::IVec4::as_i64vec4( - &_self, - ) + "mul", + |_self: Val, rhs: i32| { + let output: Val = >::mul(_self.into_inner(), rhs) .into(); output }, ) .register( - "as_u64vec4", - |_self: Ref| { - let output: Val = bevy::math::IVec4::as_u64vec4( - &_self, + "neg", + |_self: Val| { + let output: Val = ::neg( + _self.into_inner(), ) .into(); output }, ) .register( - "wrapping_add", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec4::wrapping_add( - _self.into_inner(), - rhs.into_inner(), + "new", + |x: i32, y: i32, z: i32, w: i32| { + let output: Val = bevy::math::IVec4::new( + x, + y, + z, + w, ) .into(); output }, ) .register( - "wrapping_sub", + "rem", + |_self: Val, rhs: Ref| { + let output: Val = >::rem(_self.into_inner(), &rhs) + .into(); + output + }, + ) + .register( + "rem", + |_self: Val, rhs: i32| { + let output: Val = >::rem(_self.into_inner(), rhs) + .into(); + output + }, + ) + .register( + "rem", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec4::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "wrapping_mul", + "rem_euclid", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec4::wrapping_mul( + let output: Val = bevy::math::IVec4::rem_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -4131,9 +4103,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_div", + "saturating_add", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec4::wrapping_div( + let output: Val = bevy::math::IVec4::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -4142,9 +4114,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_add", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec4::saturating_add( + "saturating_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec4::saturating_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -4153,9 +4125,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_sub", + "saturating_div", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec4::saturating_sub( + let output: Val = bevy::math::IVec4::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -4175,9 +4147,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_div", + "saturating_sub", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec4::saturating_div( + let output: Val = bevy::math::IVec4::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -4186,9 +4158,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_add_unsigned", + "saturating_sub_unsigned", |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec4::wrapping_add_unsigned( + let output: Val = bevy::math::IVec4::saturating_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -4197,300 +4169,292 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_sub_unsigned", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec4::wrapping_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = bevy::math::IVec4::select( + mask.into_inner(), + if_true.into_inner(), + if_false.into_inner(), ) .into(); output }, ) .register( - "saturating_add_unsigned", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec4::saturating_add_unsigned( + "signum", + |_self: Val| { + let output: Val = bevy::math::IVec4::signum( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "saturating_sub_unsigned", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::IVec4::saturating_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) + "splat", + |v: i32| { + let output: Val = bevy::math::IVec4::splat(v) .into(); output }, ) .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = , rhs: Val| { + let output: Val = >::eq(&_self, &other) + >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "div", + "sub", |_self: Val, rhs: Ref| { - let output: Val = = >::div(_self.into_inner(), &rhs) + >>::sub(_self.into_inner(), &rhs) .into(); output }, ) .register( - "rem", + "sub", |_self: Val, rhs: i32| { - let output: Val = = >::rem(_self.into_inner(), rhs) + >>::sub(_self.into_inner(), rhs) .into(); output }, ) .register( - "div", - |_self: Val, rhs: i32| { - let output: Val = >::div(_self.into_inner(), rhs) - .into(); + "to_array", + |_self: Ref| { + let output: [i32; 4] = bevy::math::IVec4::to_array(&_self).into(); output }, ) .register( - "sub", - |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + "truncate", + |_self: Val| { + let output: Val = bevy::math::IVec4::truncate( + _self.into_inner(), + ) .into(); output }, ) .register( - "neg", - |_self: Val| { - let output: Val = ::neg( + "with_w", + |_self: Val, w: i32| { + let output: Val = bevy::math::IVec4::with_w( _self.into_inner(), + w, ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: i32| { - let output: Val = >::mul(_self.into_inner(), rhs) + "with_x", + |_self: Val, x: i32| { + let output: Val = bevy::math::IVec4::with_x( + _self.into_inner(), + x, + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: Val| { - let output: Val = >::div(_self.into_inner(), rhs.into_inner()) + "with_y", + |_self: Val, y: i32| { + let output: Val = bevy::math::IVec4::with_y( + _self.into_inner(), + y, + ) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Val| { - let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) + "with_z", + |_self: Val, z: i32| { + let output: Val = bevy::math::IVec4::with_z( + _self.into_inner(), + z, + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Ref| { - let output: Val = >::add(_self.into_inner(), &rhs) + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec4::wrapping_add( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Ref| { - let output: Val = >::sub(_self.into_inner(), &rhs) + "wrapping_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec4::wrapping_add_unsigned( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: i32| { - let output: Val = >::sub(_self.into_inner(), rhs) + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec4::wrapping_div( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, + "wrapping_mul", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec4::wrapping_mul( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::I64Vec2>::new(world) - .register( - "rem", - |_self: Val, rhs: Ref| { - let output: Val = >::rem(_self.into_inner(), &rhs) - .into(); - output - }, ) .register( - "new", - |x: i64, y: i64| { - let output: Val = bevy::math::I64Vec2::new(x, y) + "wrapping_sub", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec4::wrapping_sub( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "splat", - |v: i64| { - let output: Val = bevy::math::I64Vec2::splat(v) + "wrapping_sub_unsigned", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::IVec4::wrapping_sub_unsigned( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::I64Vec2>::new(world) .register( - "select", - | - mask: Val, - if_true: Val, - if_false: Val| - { - let output: Val = bevy::math::I64Vec2::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), + "abs", + |_self: Val| { + let output: Val = bevy::math::I64Vec2::abs( + _self.into_inner(), ) .into(); output }, ) .register( - "from_array", - |a: [i64; 2]| { - let output: Val = bevy::math::I64Vec2::from_array( - a, - ) + "add", + |_self: Val, rhs: Ref| { + let output: Val = >::add(_self.into_inner(), &rhs) .into(); output }, ) .register( - "to_array", - |_self: Ref| { - let output: [i64; 2] = bevy::math::I64Vec2::to_array(&_self).into(); + "add", + |_self: Val, rhs: i64| { + let output: Val = >::add(_self.into_inner(), rhs) + .into(); output }, ) .register( - "extend", - |_self: Val, z: i64| { - let output: Val = bevy::math::I64Vec2::extend( - _self.into_inner(), - z, - ) + "add", + |_self: Val, rhs: Val| { + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "with_x", - |_self: Val, x: i64| { - let output: Val = bevy::math::I64Vec2::with_x( - _self.into_inner(), - x, + "as_dvec2", + |_self: Ref| { + let output: Val = bevy::math::I64Vec2::as_dvec2( + &_self, ) .into(); output }, ) .register( - "with_y", - |_self: Val, y: i64| { - let output: Val = bevy::math::I64Vec2::with_y( - _self.into_inner(), - y, + "as_ivec2", + |_self: Ref| { + let output: Val = bevy::math::I64Vec2::as_ivec2( + &_self, ) .into(); output }, ) .register( - "dot", - |_self: Val, rhs: Val| { - let output: i64 = bevy::math::I64Vec2::dot( - _self.into_inner(), - rhs.into_inner(), + "as_u64vec2", + |_self: Ref| { + let output: Val = bevy::math::I64Vec2::as_u64vec2( + &_self, ) .into(); output }, ) .register( - "dot_into_vec", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec2::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), + "as_uvec2", + |_self: Ref| { + let output: Val = bevy::math::I64Vec2::as_uvec2( + &_self, ) .into(); output }, ) .register( - "min", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec2::min( - _self.into_inner(), - rhs.into_inner(), + "as_vec2", + |_self: Ref| { + let output: Val = bevy::math::I64Vec2::as_vec2( + &_self, ) .into(); output }, ) .register( - "max", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec2::max( - _self.into_inner(), - rhs.into_inner(), + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( + &_self, ) .into(); output @@ -4513,40 +4477,10 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "min_element", - |_self: Val| { - let output: i64 = bevy::math::I64Vec2::min_element( - _self.into_inner(), - ) - .into(); - output - }, - ) - .register( - "max_element", - |_self: Val| { - let output: i64 = bevy::math::I64Vec2::max_element( - _self.into_inner(), - ) - .into(); - output - }, - ) - .register( - "element_sum", - |_self: Val| { - let output: i64 = bevy::math::I64Vec2::element_sum( - _self.into_inner(), - ) - .into(); - output - }, - ) - .register( - "element_product", - |_self: Val| { - let output: i64 = bevy::math::I64Vec2::element_product( - _self.into_inner(), + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, ) .into(); output @@ -4563,17 +4497,6 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { output }, ) - .register( - "cmpne", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec2::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output - }, - ) .register( "cmpge", |_self: Val, rhs: Val| { @@ -4619,52 +4542,53 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "abs", - |_self: Val| { - let output: Val = bevy::math::I64Vec2::abs( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec2::cmpne( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "signum", - |_self: Val| { - let output: Val = bevy::math::I64Vec2::signum( + "distance_squared", + |_self: Val, rhs: Val| { + let output: i64 = bevy::math::I64Vec2::distance_squared( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "is_negative_bitmask", - |_self: Val| { - let output: u32 = bevy::math::I64Vec2::is_negative_bitmask( - _self.into_inner(), - ) + "div", + |_self: Val, rhs: Ref| { + let output: Val = >::div(_self.into_inner(), &rhs) .into(); output }, ) .register( - "length_squared", - |_self: Val| { - let output: i64 = bevy::math::I64Vec2::length_squared( - _self.into_inner(), - ) + "div", + |_self: Val, rhs: i64| { + let output: Val = >::div(_self.into_inner(), rhs) .into(); output }, ) .register( - "distance_squared", + "div", |_self: Val, rhs: Val| { - let output: i64 = bevy::math::I64Vec2::distance_squared( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::div(_self.into_inner(), rhs.into_inner()) .into(); output }, @@ -4681,9 +4605,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "rem_euclid", + "dot", |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec2::rem_euclid( + let output: i64 = bevy::math::I64Vec2::dot( _self.into_inner(), rhs.into_inner(), ) @@ -4692,19 +4616,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "perp", - |_self: Val| { - let output: Val = bevy::math::I64Vec2::perp( - _self.into_inner(), - ) - .into(); - output - }, - ) - .register( - "perp_dot", + "dot_into_vec", |_self: Val, rhs: Val| { - let output: i64 = bevy::math::I64Vec2::perp_dot( + let output: Val = bevy::math::I64Vec2::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -4713,81 +4627,80 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "rotate", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec2::rotate( + "element_product", + |_self: Val| { + let output: i64 = bevy::math::I64Vec2::element_product( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "as_vec2", - |_self: Ref| { - let output: Val = bevy::math::I64Vec2::as_vec2( - &_self, + "element_sum", + |_self: Val| { + let output: i64 = bevy::math::I64Vec2::element_sum( + _self.into_inner(), ) .into(); output }, ) .register( - "as_dvec2", - |_self: Ref| { - let output: Val = bevy::math::I64Vec2::as_dvec2( - &_self, - ) + "eq", + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "as_ivec2", - |_self: Ref| { - let output: Val = bevy::math::I64Vec2::as_ivec2( - &_self, + "extend", + |_self: Val, z: i64| { + let output: Val = bevy::math::I64Vec2::extend( + _self.into_inner(), + z, ) .into(); output }, ) .register( - "as_uvec2", - |_self: Ref| { - let output: Val = bevy::math::I64Vec2::as_uvec2( - &_self, + "from_array", + |a: [i64; 2]| { + let output: Val = bevy::math::I64Vec2::from_array( + a, ) .into(); output }, ) .register( - "as_u64vec2", - |_self: Ref| { - let output: Val = bevy::math::I64Vec2::as_u64vec2( - &_self, + "is_negative_bitmask", + |_self: Val| { + let output: u32 = bevy::math::I64Vec2::is_negative_bitmask( + _self.into_inner(), ) .into(); output }, ) .register( - "wrapping_add", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec2::wrapping_add( + "length_squared", + |_self: Val| { + let output: i64 = bevy::math::I64Vec2::length_squared( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "wrapping_sub", + "max", |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec2::wrapping_sub( + let output: Val = bevy::math::I64Vec2::max( _self.into_inner(), rhs.into_inner(), ) @@ -4796,20 +4709,19 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_mul", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec2::wrapping_mul( + "max_element", + |_self: Val| { + let output: i64 = bevy::math::I64Vec2::max_element( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "wrapping_div", + "min", |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec2::wrapping_div( + let output: Val = bevy::math::I64Vec2::min( _self.into_inner(), rhs.into_inner(), ) @@ -4818,86 +4730,77 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_add", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec2::saturating_add( + "min_element", + |_self: Val| { + let output: i64 = bevy::math::I64Vec2::min_element( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "saturating_sub", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec2::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) + "mul", + |_self: Val, rhs: i64| { + let output: Val = >::mul(_self.into_inner(), rhs) .into(); output }, ) .register( - "saturating_mul", + "mul", |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec2::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "saturating_div", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec2::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) + "mul", + |_self: Val, rhs: Ref| { + let output: Val = >::mul(_self.into_inner(), &rhs) .into(); output }, ) .register( - "wrapping_add_unsigned", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec2::wrapping_add_unsigned( + "neg", + |_self: Val| { + let output: Val = ::neg( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "wrapping_sub_unsigned", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec2::wrapping_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) + "new", + |x: i64, y: i64| { + let output: Val = bevy::math::I64Vec2::new(x, y) .into(); output }, ) .register( - "saturating_add_unsigned", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec2::saturating_add_unsigned( + "perp", + |_self: Val| { + let output: Val = bevy::math::I64Vec2::perp( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "saturating_sub_unsigned", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec2::saturating_sub_unsigned( + "perp_dot", + |_self: Val, rhs: Val| { + let output: i64 = bevy::math::I64Vec2::perp_dot( _self.into_inner(), rhs.into_inner(), ) @@ -4906,419 +4809,414 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) + "rem", + |_self: Val, rhs: Ref| { + let output: Val = >::rem(_self.into_inner(), &rhs) .into(); output }, ) .register( - "mul", + "rem", |_self: Val, rhs: i64| { - let output: Val = = >::mul(_self.into_inner(), rhs) + >>::rem(_self.into_inner(), rhs) .into(); output }, ) .register( - "sub", + "rem", |_self: Val, rhs: Val| { - let output: Val = = >::sub(_self.into_inner(), rhs.into_inner()) + >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Ref| { - let output: Val = >::add(_self.into_inner(), &rhs) + "rem_euclid", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec2::rem_euclid( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, + "rotate", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec2::rotate( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: Ref| { - let output: Val = >::div(_self.into_inner(), &rhs) + "saturating_add", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec2::saturating_add( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Ref| { - let output: Val = >::sub(_self.into_inner(), &rhs) + "saturating_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec2::saturating_add_unsigned( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, + "saturating_div", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec2::saturating_div( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "mul", + "saturating_mul", |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + let output: Val = bevy::math::I64Vec2::saturating_mul( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: i64| { - let output: Val = >::div(_self.into_inner(), rhs) + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec2::saturating_sub( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "neg", - |_self: Val| { - let output: Val = ::neg( + "saturating_sub_unsigned", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec2::saturating_sub_unsigned( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: i64| { - let output: Val = >::add(_self.into_inner(), rhs) + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = bevy::math::I64Vec2::select( + mask.into_inner(), + if_true.into_inner(), + if_false.into_inner(), + ) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: i64| { - let output: Val = >::rem(_self.into_inner(), rhs) + "signum", + |_self: Val| { + let output: Val = bevy::math::I64Vec2::signum( + _self.into_inner(), + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Val| { - let output: Val = >::add(_self.into_inner(), rhs.into_inner()) - .into(); - output - }, - ) - .register( - "div", - |_self: Val, rhs: Val| { - let output: Val = >::div(_self.into_inner(), rhs.into_inner()) + "splat", + |v: i64| { + let output: Val = bevy::math::I64Vec2::splat(v) .into(); output }, ) .register( "sub", - |_self: Val, rhs: i64| { + |_self: Val, rhs: Val| { let output: Val = >::sub(_self.into_inner(), rhs) + bevy::math::I64Vec2, + >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "mul", + "sub", |_self: Val, rhs: Ref| { - let output: Val = = >::mul(_self.into_inner(), &rhs) + >>::sub(_self.into_inner(), &rhs) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Val| { - let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) + "sub", + |_self: Val, rhs: i64| { + let output: Val = >::sub(_self.into_inner(), rhs) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::I64Vec3>::new(world) + ) .register( - "div", - |_self: Val, rhs: i64| { - let output: Val = >::div(_self.into_inner(), rhs) - .into(); + "to_array", + |_self: Ref| { + let output: [i64; 2] = bevy::math::I64Vec2::to_array(&_self).into(); output }, ) .register( - "sub", - |_self: Val, rhs: Ref| { - let output: Val = >::sub(_self.into_inner(), &rhs) + "with_x", + |_self: Val, x: i64| { + let output: Val = bevy::math::I64Vec2::with_x( + _self.into_inner(), + x, + ) .into(); output }, ) .register( - "new", - |x: i64, y: i64, z: i64| { - let output: Val = bevy::math::I64Vec3::new( - x, + "with_y", + |_self: Val, y: i64| { + let output: Val = bevy::math::I64Vec2::with_y( + _self.into_inner(), y, - z, ) .into(); output }, ) .register( - "splat", - |v: i64| { - let output: Val = bevy::math::I64Vec3::splat(v) + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec2::wrapping_add( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "select", - | - mask: Val, - if_true: Val, - if_false: Val| - { - let output: Val = bevy::math::I64Vec3::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), + "wrapping_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec2::wrapping_add_unsigned( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "from_array", - |a: [i64; 3]| { - let output: Val = bevy::math::I64Vec3::from_array( - a, + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec2::wrapping_div( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "to_array", - |_self: Ref| { - let output: [i64; 3] = bevy::math::I64Vec3::to_array(&_self).into(); + "wrapping_mul", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec2::wrapping_mul( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); output }, ) .register( - "extend", - |_self: Val, w: i64| { - let output: Val = bevy::math::I64Vec3::extend( + "wrapping_sub", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec2::wrapping_sub( _self.into_inner(), - w, + rhs.into_inner(), ) .into(); output }, ) .register( - "truncate", - |_self: Val| { - let output: Val = bevy::math::I64Vec3::truncate( + "wrapping_sub_unsigned", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec2::wrapping_sub_unsigned( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::I64Vec3>::new(world) .register( - "with_x", - |_self: Val, x: i64| { - let output: Val = bevy::math::I64Vec3::with_x( + "abs", + |_self: Val| { + let output: Val = bevy::math::I64Vec3::abs( _self.into_inner(), - x, ) .into(); output }, ) .register( - "with_y", - |_self: Val, y: i64| { - let output: Val = bevy::math::I64Vec3::with_y( - _self.into_inner(), - y, - ) + "add", + |_self: Val, rhs: Val| { + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "with_z", - |_self: Val, z: i64| { - let output: Val = bevy::math::I64Vec3::with_z( - _self.into_inner(), - z, - ) + "add", + |_self: Val, rhs: i64| { + let output: Val = >::add(_self.into_inner(), rhs) .into(); output }, ) .register( - "dot", - |_self: Val, rhs: Val| { - let output: i64 = bevy::math::I64Vec3::dot( - _self.into_inner(), - rhs.into_inner(), - ) + "add", + |_self: Val, rhs: Ref| { + let output: Val = >::add(_self.into_inner(), &rhs) .into(); output }, ) .register( - "dot_into_vec", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec3::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), + "as_dvec3", + |_self: Ref| { + let output: Val = bevy::math::I64Vec3::as_dvec3( + &_self, ) .into(); output }, ) .register( - "cross", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec3::cross( - _self.into_inner(), - rhs.into_inner(), + "as_ivec3", + |_self: Ref| { + let output: Val = bevy::math::I64Vec3::as_ivec3( + &_self, ) .into(); output }, ) .register( - "min", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec3::min( - _self.into_inner(), - rhs.into_inner(), + "as_u64vec3", + |_self: Ref| { + let output: Val = bevy::math::I64Vec3::as_u64vec3( + &_self, ) .into(); output }, ) .register( - "max", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec3::max( - _self.into_inner(), - rhs.into_inner(), + "as_uvec3", + |_self: Ref| { + let output: Val = bevy::math::I64Vec3::as_uvec3( + &_self, ) .into(); output }, ) .register( - "clamp", - | - _self: Val, - min: Val, - max: Val| - { - let output: Val = bevy::math::I64Vec3::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), + "as_vec3", + |_self: Ref| { + let output: Val = bevy::math::I64Vec3::as_vec3( + &_self, ) .into(); output }, ) .register( - "min_element", - |_self: Val| { - let output: i64 = bevy::math::I64Vec3::min_element( - _self.into_inner(), + "as_vec3a", + |_self: Ref| { + let output: Val = bevy::math::I64Vec3::as_vec3a( + &_self, ) .into(); output }, ) .register( - "max_element", - |_self: Val| { - let output: i64 = bevy::math::I64Vec3::max_element( - _self.into_inner(), + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( + &_self, ) .into(); output }, ) .register( - "element_sum", - |_self: Val| { - let output: i64 = bevy::math::I64Vec3::element_sum( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = bevy::math::I64Vec3::clamp( _self.into_inner(), + min.into_inner(), + max.into_inner(), ) .into(); output }, ) .register( - "element_product", - |_self: Val| { - let output: i64 = bevy::math::I64Vec3::element_product( - _self.into_inner(), + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, ) .into(); output @@ -5336,20 +5234,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cmpne", + "cmpge", |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec3::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output - }, - ) - .register( - "cmpge", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec3::cmpge( + let output: Val = bevy::math::I64Vec3::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -5391,49 +5278,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "abs", - |_self: Val| { - let output: Val = bevy::math::I64Vec3::abs( - _self.into_inner(), - ) - .into(); - output - }, - ) - .register( - "signum", - |_self: Val| { - let output: Val = bevy::math::I64Vec3::signum( - _self.into_inner(), - ) - .into(); - output - }, - ) - .register( - "is_negative_bitmask", - |_self: Val| { - let output: u32 = bevy::math::I64Vec3::is_negative_bitmask( - _self.into_inner(), - ) - .into(); - output - }, - ) - .register( - "length_squared", - |_self: Val| { - let output: i64 = bevy::math::I64Vec3::length_squared( - _self.into_inner(), - ) - .into(); - output - }, - ) - .register( - "distance_squared", + "cmpne", |_self: Val, rhs: Val| { - let output: i64 = bevy::math::I64Vec3::distance_squared( + let output: Val = bevy::math::I64Vec3::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -5442,9 +5289,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "div_euclid", + "cross", |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec3::div_euclid( + let output: Val = bevy::math::I64Vec3::cross( _self.into_inner(), rhs.into_inner(), ) @@ -5453,9 +5300,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "rem_euclid", + "distance_squared", |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec3::rem_euclid( + let output: i64 = bevy::math::I64Vec3::distance_squared( _self.into_inner(), rhs.into_inner(), ) @@ -5464,69 +5311,61 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "as_vec3", - |_self: Ref| { - let output: Val = bevy::math::I64Vec3::as_vec3( - &_self, - ) - .into(); - output - }, - ) - .register( - "as_vec3a", - |_self: Ref| { - let output: Val = bevy::math::I64Vec3::as_vec3a( - &_self, - ) + "div", + |_self: Val, rhs: i64| { + let output: Val = >::div(_self.into_inner(), rhs) .into(); output }, ) .register( - "as_dvec3", - |_self: Ref| { - let output: Val = bevy::math::I64Vec3::as_dvec3( - &_self, - ) + "div", + |_self: Val, rhs: Val| { + let output: Val = >::div(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "as_ivec3", - |_self: Ref| { - let output: Val = bevy::math::I64Vec3::as_ivec3( - &_self, - ) + "div", + |_self: Val, rhs: Ref| { + let output: Val = >::div(_self.into_inner(), &rhs) .into(); output }, ) .register( - "as_uvec3", - |_self: Ref| { - let output: Val = bevy::math::I64Vec3::as_uvec3( - &_self, + "div_euclid", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec3::div_euclid( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "as_u64vec3", - |_self: Ref| { - let output: Val = bevy::math::I64Vec3::as_u64vec3( - &_self, + "dot", + |_self: Val, rhs: Val| { + let output: i64 = bevy::math::I64Vec3::dot( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "wrapping_add", + "dot_into_vec", |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec3::wrapping_add( + let output: Val = bevy::math::I64Vec3::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -5535,86 +5374,80 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_sub", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec3::wrapping_sub( + "element_product", + |_self: Val| { + let output: i64 = bevy::math::I64Vec3::element_product( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "wrapping_mul", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec3::wrapping_mul( + "element_sum", + |_self: Val| { + let output: i64 = bevy::math::I64Vec3::element_sum( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "wrapping_div", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec3::wrapping_div( - _self.into_inner(), - rhs.into_inner(), - ) + "eq", + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "saturating_add", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec3::saturating_add( + "extend", + |_self: Val, w: i64| { + let output: Val = bevy::math::I64Vec3::extend( _self.into_inner(), - rhs.into_inner(), + w, ) .into(); output }, ) .register( - "saturating_sub", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec3::saturating_sub( - _self.into_inner(), - rhs.into_inner(), + "from_array", + |a: [i64; 3]| { + let output: Val = bevy::math::I64Vec3::from_array( + a, ) .into(); output }, ) .register( - "saturating_mul", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec3::saturating_mul( + "is_negative_bitmask", + |_self: Val| { + let output: u32 = bevy::math::I64Vec3::is_negative_bitmask( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "saturating_div", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec3::saturating_div( + "length_squared", + |_self: Val| { + let output: i64 = bevy::math::I64Vec3::length_squared( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "wrapping_add_unsigned", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec3::wrapping_add_unsigned( + "max", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec3::max( _self.into_inner(), rhs.into_inner(), ) @@ -5623,20 +5456,19 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_sub_unsigned", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec3::wrapping_sub_unsigned( + "max_element", + |_self: Val| { + let output: i64 = bevy::math::I64Vec3::max_element( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "saturating_add_unsigned", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec3::saturating_add_unsigned( + "min", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec3::min( _self.into_inner(), rhs.into_inner(), ) @@ -5645,11 +5477,10 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_sub_unsigned", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec3::saturating_sub_unsigned( + "min_element", + |_self: Val| { + let output: i64 = bevy::math::I64Vec3::min_element( _self.into_inner(), - rhs.into_inner(), ) .into(); output @@ -5665,16 +5496,6 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { output }, ) - .register( - "neg", - |_self: Val| { - let output: Val = ::neg( - _self.into_inner(), - ) - .into(); - output - }, - ) .register( "mul", |_self: Val, rhs: i64| { @@ -5696,171 +5517,173 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, + "neg", + |_self: Val| { + let output: Val = ::neg( + _self.into_inner(), ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Val| { - let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + "new", + |x: i64, y: i64, z: i64| { + let output: Val = bevy::math::I64Vec3::new( + x, + y, + z, + ) .into(); output }, ) .register( - "add", + "rem", |_self: Val, rhs: i64| { - let output: Val = = >::add(_self.into_inner(), rhs) + >>::rem(_self.into_inner(), rhs) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: i64| { - let output: Val = >::sub(_self.into_inner(), rhs) + "rem", + |_self: Val, rhs: Val| { + let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) + "rem", + |_self: Val, rhs: Ref| { + let output: Val = >::rem(_self.into_inner(), &rhs) .into(); output }, ) .register( - "div", + "rem_euclid", |_self: Val, rhs: Val| { - let output: Val = >::div(_self.into_inner(), rhs.into_inner()) + let output: Val = bevy::math::I64Vec3::rem_euclid( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Ref| { - let output: Val = >::add(_self.into_inner(), &rhs) + "saturating_add", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec3::saturating_add( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: i64| { - let output: Val = >::rem(_self.into_inner(), rhs) + "saturating_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec3::saturating_add_unsigned( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "rem", + "saturating_div", |_self: Val, rhs: Val| { - let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) + let output: Val = bevy::math::I64Vec3::saturating_div( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: Ref| { - let output: Val = >::div(_self.into_inner(), &rhs) + "saturating_mul", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec3::saturating_mul( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Ref| { - let output: Val = >::rem(_self.into_inner(), &rhs) + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec3::saturating_sub( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, + "saturating_sub_unsigned", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec3::saturating_sub_unsigned( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output - }, - ); - NamespaceBuilder::<::bevy::math::I64Vec4>::new(world) - .register( - "sub", - |_self: Val, rhs: i64| { - let output: Val = >::sub(_self.into_inner(), rhs) + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = bevy::math::I64Vec3::select( + mask.into_inner(), + if_true.into_inner(), + if_false.into_inner(), + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: i64| { - let output: Val = >::div(_self.into_inner(), rhs) + "signum", + |_self: Val| { + let output: Val = bevy::math::I64Vec3::signum( + _self.into_inner(), + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Ref| { - let output: Val = >::mul(_self.into_inner(), &rhs) + "splat", + |v: i64| { + let output: Val = bevy::math::I64Vec3::splat(v) .into(); output }, ) .register( "sub", - |_self: Val, rhs: Ref| { - let output: Val = , rhs: Ref| { + let output: Val = >::sub(_self.into_inner(), &rhs) .into(); output @@ -5868,277 +5691,262 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { ) .register( "sub", - |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output - }, - ) - .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) + |_self: Val, rhs: i64| { + let output: Val = >::sub(_self.into_inner(), rhs) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: i64| { - let output: Val = >::mul(_self.into_inner(), rhs) + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "div", - |_self: Val, rhs: Ref| { - let output: Val = >::div(_self.into_inner(), &rhs) - .into(); + "to_array", + |_self: Ref| { + let output: [i64; 3] = bevy::math::I64Vec3::to_array(&_self).into(); output }, ) .register( - "rem", - |_self: Val, rhs: i64| { - let output: Val = >::rem(_self.into_inner(), rhs) + "truncate", + |_self: Val| { + let output: Val = bevy::math::I64Vec3::truncate( + _self.into_inner(), + ) .into(); output }, ) .register( - "neg", - |_self: Val| { - let output: Val = ::neg( + "with_x", + |_self: Val, x: i64| { + let output: Val = bevy::math::I64Vec3::with_x( _self.into_inner(), + x, ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Val| { - let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + "with_y", + |_self: Val, y: i64| { + let output: Val = bevy::math::I64Vec3::with_y( + _self.into_inner(), + y, + ) .into(); output }, ) .register( - "new", - |x: i64, y: i64, z: i64, w: i64| { - let output: Val = bevy::math::I64Vec4::new( - x, - y, + "with_z", + |_self: Val, z: i64| { + let output: Val = bevy::math::I64Vec3::with_z( + _self.into_inner(), z, - w, ) .into(); output }, ) .register( - "splat", - |v: i64| { - let output: Val = bevy::math::I64Vec4::splat(v) + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec3::wrapping_add( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "select", - | - mask: Val, - if_true: Val, - if_false: Val| - { - let output: Val = bevy::math::I64Vec4::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), + "wrapping_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec3::wrapping_add_unsigned( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "from_array", - |a: [i64; 4]| { - let output: Val = bevy::math::I64Vec4::from_array( - a, + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec3::wrapping_div( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "to_array", - |_self: Ref| { - let output: [i64; 4] = bevy::math::I64Vec4::to_array(&_self).into(); + "wrapping_mul", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec3::wrapping_mul( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); output }, ) .register( - "truncate", - |_self: Val| { - let output: Val = bevy::math::I64Vec4::truncate( + "wrapping_sub", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec3::wrapping_sub( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "with_x", - |_self: Val, x: i64| { - let output: Val = bevy::math::I64Vec4::with_x( + "wrapping_sub_unsigned", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec3::wrapping_sub_unsigned( _self.into_inner(), - x, + rhs.into_inner(), ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::I64Vec4>::new(world) .register( - "with_y", - |_self: Val, y: i64| { - let output: Val = bevy::math::I64Vec4::with_y( + "abs", + |_self: Val| { + let output: Val = bevy::math::I64Vec4::abs( _self.into_inner(), - y, ) .into(); output }, ) .register( - "with_z", - |_self: Val, z: i64| { - let output: Val = bevy::math::I64Vec4::with_z( - _self.into_inner(), - z, - ) + "add", + |_self: Val, rhs: Val| { + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "with_w", - |_self: Val, w: i64| { - let output: Val = bevy::math::I64Vec4::with_w( - _self.into_inner(), - w, - ) + "add", + |_self: Val, rhs: i64| { + let output: Val = >::add(_self.into_inner(), rhs) .into(); output }, ) .register( - "dot", - |_self: Val, rhs: Val| { - let output: i64 = bevy::math::I64Vec4::dot( - _self.into_inner(), - rhs.into_inner(), - ) + "add", + |_self: Val, rhs: Ref| { + let output: Val = >::add(_self.into_inner(), &rhs) .into(); output }, ) .register( - "dot_into_vec", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec4::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), + "as_dvec4", + |_self: Ref| { + let output: Val = bevy::math::I64Vec4::as_dvec4( + &_self, ) .into(); output }, ) .register( - "min", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec4::min( - _self.into_inner(), - rhs.into_inner(), + "as_ivec4", + |_self: Ref| { + let output: Val = bevy::math::I64Vec4::as_ivec4( + &_self, ) .into(); output }, ) .register( - "max", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec4::max( - _self.into_inner(), - rhs.into_inner(), + "as_u64vec4", + |_self: Ref| { + let output: Val = bevy::math::I64Vec4::as_u64vec4( + &_self, ) .into(); output }, ) .register( - "clamp", - | - _self: Val, - min: Val, - max: Val| - { - let output: Val = bevy::math::I64Vec4::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), + "as_uvec4", + |_self: Ref| { + let output: Val = bevy::math::I64Vec4::as_uvec4( + &_self, ) .into(); output }, ) .register( - "min_element", - |_self: Val| { - let output: i64 = bevy::math::I64Vec4::min_element( - _self.into_inner(), + "as_vec4", + |_self: Ref| { + let output: Val = bevy::math::I64Vec4::as_vec4( + &_self, ) .into(); output }, ) .register( - "max_element", - |_self: Val| { - let output: i64 = bevy::math::I64Vec4::max_element( - _self.into_inner(), + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( + &_self, ) .into(); output }, ) .register( - "element_sum", - |_self: Val| { - let output: i64 = bevy::math::I64Vec4::element_sum( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = bevy::math::I64Vec4::clamp( _self.into_inner(), + min.into_inner(), + max.into_inner(), ) .into(); output }, ) .register( - "element_product", - |_self: Val| { - let output: i64 = bevy::math::I64Vec4::element_product( - _self.into_inner(), + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, ) .into(); output @@ -6155,17 +5963,6 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { output }, ) - .register( - "cmpne", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec4::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output - }, - ) .register( "cmpge", |_self: Val, rhs: Val| { @@ -6211,52 +6008,53 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "abs", - |_self: Val| { - let output: Val = bevy::math::I64Vec4::abs( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec4::cmpne( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "signum", - |_self: Val| { - let output: Val = bevy::math::I64Vec4::signum( + "distance_squared", + |_self: Val, rhs: Val| { + let output: i64 = bevy::math::I64Vec4::distance_squared( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "is_negative_bitmask", - |_self: Val| { - let output: u32 = bevy::math::I64Vec4::is_negative_bitmask( - _self.into_inner(), - ) + "div", + |_self: Val, rhs: i64| { + let output: Val = >::div(_self.into_inner(), rhs) .into(); output }, ) .register( - "length_squared", - |_self: Val| { - let output: i64 = bevy::math::I64Vec4::length_squared( - _self.into_inner(), - ) + "div", + |_self: Val, rhs: Ref| { + let output: Val = >::div(_self.into_inner(), &rhs) .into(); output }, ) .register( - "distance_squared", + "div", |_self: Val, rhs: Val| { - let output: i64 = bevy::math::I64Vec4::distance_squared( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::div(_self.into_inner(), rhs.into_inner()) .into(); output }, @@ -6273,9 +6071,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "rem_euclid", + "dot", |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec4::rem_euclid( + let output: i64 = bevy::math::I64Vec4::dot( _self.into_inner(), rhs.into_inner(), ) @@ -6284,81 +6082,80 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "as_vec4", - |_self: Ref| { - let output: Val = bevy::math::I64Vec4::as_vec4( - &_self, + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec4::dot_into_vec( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "as_dvec4", - |_self: Ref| { - let output: Val = bevy::math::I64Vec4::as_dvec4( - &_self, + "element_product", + |_self: Val| { + let output: i64 = bevy::math::I64Vec4::element_product( + _self.into_inner(), ) .into(); output }, ) .register( - "as_ivec4", - |_self: Ref| { - let output: Val = bevy::math::I64Vec4::as_ivec4( - &_self, + "element_sum", + |_self: Val| { + let output: i64 = bevy::math::I64Vec4::element_sum( + _self.into_inner(), ) .into(); output }, ) .register( - "as_uvec4", - |_self: Ref| { - let output: Val = bevy::math::I64Vec4::as_uvec4( - &_self, - ) + "eq", + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "as_u64vec4", - |_self: Ref| { - let output: Val = bevy::math::I64Vec4::as_u64vec4( - &_self, + "from_array", + |a: [i64; 4]| { + let output: Val = bevy::math::I64Vec4::from_array( + a, ) .into(); output }, ) .register( - "wrapping_add", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec4::wrapping_add( + "is_negative_bitmask", + |_self: Val| { + let output: u32 = bevy::math::I64Vec4::is_negative_bitmask( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "wrapping_sub", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec4::wrapping_sub( + "length_squared", + |_self: Val| { + let output: i64 = bevy::math::I64Vec4::length_squared( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "wrapping_mul", + "max", |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec4::wrapping_mul( + let output: Val = bevy::math::I64Vec4::max( _self.into_inner(), rhs.into_inner(), ) @@ -6367,20 +6164,19 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_div", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec4::wrapping_div( + "max_element", + |_self: Val| { + let output: i64 = bevy::math::I64Vec4::max_element( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "saturating_add", + "min", |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec4::saturating_add( + let output: Val = bevy::math::I64Vec4::min( _self.into_inner(), rhs.into_inner(), ) @@ -6389,78 +6185,74 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_sub", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec4::saturating_sub( + "min_element", + |_self: Val| { + let output: i64 = bevy::math::I64Vec4::min_element( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "saturating_mul", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec4::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) + "mul", + |_self: Val, rhs: Ref| { + let output: Val = >::mul(_self.into_inner(), &rhs) .into(); output }, ) .register( - "saturating_div", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec4::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) + "mul", + |_self: Val, rhs: i64| { + let output: Val = >::mul(_self.into_inner(), rhs) .into(); output }, ) .register( - "wrapping_add_unsigned", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec4::wrapping_add_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "wrapping_sub_unsigned", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec4::wrapping_sub_unsigned( + "neg", + |_self: Val| { + let output: Val = ::neg( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "saturating_add_unsigned", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec4::saturating_add_unsigned( - _self.into_inner(), - rhs.into_inner(), + "new", + |x: i64, y: i64, z: i64, w: i64| { + let output: Val = bevy::math::I64Vec4::new( + x, + y, + z, + w, ) .into(); output }, ) .register( - "saturating_sub_unsigned", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::I64Vec4::saturating_sub_unsigned( - _self.into_inner(), - rhs.into_inner(), - ) + "rem", + |_self: Val, rhs: i64| { + let output: Val = >::rem(_self.into_inner(), rhs) .into(); output }, @@ -6476,179 +6268,179 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "mul", + "rem", |_self: Val, rhs: Val| { - let output: Val = = >::mul(_self.into_inner(), rhs.into_inner()) + >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "add", - |_self: Val, rhs: i64| { - let output: Val = >::add(_self.into_inner(), rhs) + "rem_euclid", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec4::rem_euclid( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, + "saturating_add", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec4::saturating_add( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, + "saturating_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec4::saturating_add_unsigned( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "div", + "saturating_div", |_self: Val, rhs: Val| { - let output: Val = >::div(_self.into_inner(), rhs.into_inner()) + let output: Val = bevy::math::I64Vec4::saturating_div( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Ref| { - let output: Val = >::add(_self.into_inner(), &rhs) + "saturating_mul", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec4::saturating_mul( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "rem", + "saturating_sub", |_self: Val, rhs: Val| { - let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) - .into(); - output - }, - ); - NamespaceBuilder::<::bevy::math::UVec2>::new(world) - .register( - "div", - |_self: Val, rhs: Ref| { - let output: Val = >::div(_self.into_inner(), &rhs) + let output: Val = bevy::math::I64Vec4::saturating_sub( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "saturating_sub_unsigned", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec4::saturating_sub_unsigned( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Val| { - let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = bevy::math::I64Vec4::select( + mask.into_inner(), + if_true.into_inner(), + if_false.into_inner(), + ) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Val| { - let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) + "signum", + |_self: Val| { + let output: Val = bevy::math::I64Vec4::signum( + _self.into_inner(), + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: Val| { - let output: Val = >::div(_self.into_inner(), rhs.into_inner()) + "splat", + |v: i64| { + let output: Val = bevy::math::I64Vec4::splat(v) .into(); output }, ) .register( - "new", - |x: u32, y: u32| { - let output: Val = bevy::math::UVec2::new(x, y) + "sub", + |_self: Val, rhs: i64| { + let output: Val = >::sub(_self.into_inner(), rhs) .into(); output }, ) .register( - "splat", - |v: u32| { - let output: Val = bevy::math::UVec2::splat(v) + "sub", + |_self: Val, rhs: Ref| { + let output: Val = >::sub(_self.into_inner(), &rhs) .into(); output }, ) .register( - "select", - | - mask: Val, - if_true: Val, - if_false: Val| - { - let output: Val = bevy::math::UVec2::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "from_array", - |a: [u32; 2]| { - let output: Val = bevy::math::UVec2::from_array(a) - .into(); + "to_array", + |_self: Ref| { + let output: [i64; 4] = bevy::math::I64Vec4::to_array(&_self).into(); output }, ) .register( - "to_array", - |_self: Ref| { - let output: [u32; 2] = bevy::math::UVec2::to_array(&_self).into(); + "truncate", + |_self: Val| { + let output: Val = bevy::math::I64Vec4::truncate( + _self.into_inner(), + ) + .into(); output }, ) .register( - "extend", - |_self: Val, z: u32| { - let output: Val = bevy::math::UVec2::extend( + "with_w", + |_self: Val, w: i64| { + let output: Val = bevy::math::I64Vec4::with_w( _self.into_inner(), - z, + w, ) .into(); output @@ -6656,8 +6448,8 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { ) .register( "with_x", - |_self: Val, x: u32| { - let output: Val = bevy::math::UVec2::with_x( + |_self: Val, x: i64| { + let output: Val = bevy::math::I64Vec4::with_x( _self.into_inner(), x, ) @@ -6667,8 +6459,8 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { ) .register( "with_y", - |_self: Val, y: u32| { - let output: Val = bevy::math::UVec2::with_y( + |_self: Val, y: i64| { + let output: Val = bevy::math::I64Vec4::with_y( _self.into_inner(), y, ) @@ -6677,20 +6469,20 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "dot", - |_self: Val, rhs: Val| { - let output: u32 = bevy::math::UVec2::dot( + "with_z", + |_self: Val, z: i64| { + let output: Val = bevy::math::I64Vec4::with_z( _self.into_inner(), - rhs.into_inner(), + z, ) .into(); output }, ) .register( - "dot_into_vec", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec2::dot_into_vec( + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec4::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -6699,9 +6491,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "min", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec2::min( + "wrapping_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec4::wrapping_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -6710,9 +6502,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "max", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec2::max( + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec4::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -6721,135 +6513,103 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "clamp", - | - _self: Val, - min: Val, - max: Val| - { - let output: Val = bevy::math::UVec2::clamp( + "wrapping_mul", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec4::wrapping_mul( _self.into_inner(), - min.into_inner(), - max.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "min_element", - |_self: Val| { - let output: u32 = bevy::math::UVec2::min_element(_self.into_inner()) - .into(); - output - }, - ) - .register( - "max_element", - |_self: Val| { - let output: u32 = bevy::math::UVec2::max_element(_self.into_inner()) - .into(); - output - }, - ) - .register( - "element_sum", - |_self: Val| { - let output: u32 = bevy::math::UVec2::element_sum(_self.into_inner()) - .into(); - output - }, - ) - .register( - "element_product", - |_self: Val| { - let output: u32 = bevy::math::UVec2::element_product( + "wrapping_sub", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec4::wrapping_sub( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "cmpeq", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec2::cmpeq( + "wrapping_sub_unsigned", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::I64Vec4::wrapping_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::UVec2>::new(world) .register( - "cmpne", + "add", |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec2::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "cmpge", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec2::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) + "add", + |_self: Val, rhs: u32| { + let output: Val = >::add(_self.into_inner(), rhs) .into(); output }, ) .register( - "cmpgt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec2::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) + "add", + |_self: Val, rhs: Ref| { + let output: Val = >::add(_self.into_inner(), &rhs) .into(); output }, ) .register( - "cmple", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec2::cmple( - _self.into_inner(), - rhs.into_inner(), + "as_dvec2", + |_self: Ref| { + let output: Val = bevy::math::UVec2::as_dvec2( + &_self, ) .into(); output }, ) .register( - "cmplt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec2::cmplt( - _self.into_inner(), - rhs.into_inner(), + "as_i64vec2", + |_self: Ref| { + let output: Val = bevy::math::UVec2::as_i64vec2( + &_self, ) .into(); output }, ) .register( - "length_squared", - |_self: Val| { - let output: u32 = bevy::math::UVec2::length_squared( - _self.into_inner(), + "as_ivec2", + |_self: Ref| { + let output: Val = bevy::math::UVec2::as_ivec2( + &_self, ) .into(); output }, ) .register( - "as_vec2", + "as_u64vec2", |_self: Ref| { - let output: Val = bevy::math::UVec2::as_vec2( + let output: Val = bevy::math::UVec2::as_u64vec2( &_self, ) .into(); @@ -6857,9 +6617,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "as_dvec2", + "as_vec2", |_self: Ref| { - let output: Val = bevy::math::UVec2::as_dvec2( + let output: Val = bevy::math::UVec2::as_vec2( &_self, ) .into(); @@ -6867,9 +6627,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "as_ivec2", + "assert_receiver_is_total_eq", |_self: Ref| { - let output: Val = bevy::math::UVec2::as_ivec2( + let output: () = ::assert_receiver_is_total_eq( &_self, ) .into(); @@ -6877,19 +6637,25 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "as_i64vec2", - |_self: Ref| { - let output: Val = bevy::math::UVec2::as_i64vec2( - &_self, + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = bevy::math::UVec2::clamp( + _self.into_inner(), + min.into_inner(), + max.into_inner(), ) .into(); output }, ) .register( - "as_u64vec2", + "clone", |_self: Ref| { - let output: Val = bevy::math::UVec2::as_u64vec2( + let output: Val = ::clone( &_self, ) .into(); @@ -6897,9 +6663,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_add", + "cmpeq", |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec2::wrapping_add( + let output: Val = bevy::math::UVec2::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -6908,9 +6674,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_sub", + "cmpge", |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec2::wrapping_sub( + let output: Val = bevy::math::UVec2::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -6919,9 +6685,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_mul", + "cmpgt", |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec2::wrapping_mul( + let output: Val = bevy::math::UVec2::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -6930,9 +6696,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_div", + "cmple", |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec2::wrapping_div( + let output: Val = bevy::math::UVec2::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -6941,9 +6707,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_add", + "cmplt", |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec2::saturating_add( + let output: Val = bevy::math::UVec2::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -6952,9 +6718,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_sub", + "cmpne", |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec2::saturating_sub( + let output: Val = bevy::math::UVec2::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -6963,20 +6729,39 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_mul", + "div", + |_self: Val, rhs: Ref| { + let output: Val = >::div(_self.into_inner(), &rhs) + .into(); + output + }, + ) + .register( + "div", |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec2::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::div(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "saturating_div", + "div", + |_self: Val, rhs: u32| { + let output: Val = >::div(_self.into_inner(), rhs) + .into(); + output + }, + ) + .register( + "dot", |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec2::saturating_div( + let output: u32 = bevy::math::UVec2::dot( _self.into_inner(), rhs.into_inner(), ) @@ -6985,9 +6770,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_add_signed", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec2::wrapping_add_signed( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec2::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -6996,122 +6781,116 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_add_signed", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec2::saturating_add_signed( + "element_product", + |_self: Val| { + let output: u32 = bevy::math::UVec2::element_product( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Ref| { - let output: Val = >::rem(_self.into_inner(), &rhs) + "element_sum", + |_self: Val| { + let output: u32 = bevy::math::UVec2::element_sum(_self.into_inner()) .into(); output }, ) .register( - "add", - |_self: Val, rhs: u32| { - let output: Val = >::add(_self.into_inner(), rhs) + "eq", + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: u32| { - let output: Val = >::sub(_self.into_inner(), rhs) + "extend", + |_self: Val, z: u32| { + let output: Val = bevy::math::UVec2::extend( + _self.into_inner(), + z, + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Ref| { - let output: Val = >::mul(_self.into_inner(), &rhs) + "from_array", + |a: [u32; 2]| { + let output: Val = bevy::math::UVec2::from_array(a) .into(); output }, ) .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) + "length_squared", + |_self: Val| { + let output: u32 = bevy::math::UVec2::length_squared( + _self.into_inner(), + ) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, + "max", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec2::max( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: u32| { - let output: Val = >::div(_self.into_inner(), rhs) + "max_element", + |_self: Val| { + let output: u32 = bevy::math::UVec2::max_element(_self.into_inner()) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: u32| { - let output: Val = >::rem(_self.into_inner(), rhs) + "min", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec2::min( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Ref| { - let output: Val = >::sub(_self.into_inner(), &rhs) + "min_element", + |_self: Val| { + let output: u32 = bevy::math::UVec2::min_element(_self.into_inner()) .into(); output }, ) .register( - "sub", + "mul", |_self: Val, rhs: Val| { - let output: Val = = >::sub(_self.into_inner(), rhs.into_inner()) + >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "add", + "mul", |_self: Val, rhs: Ref| { - let output: Val = = >::add(_self.into_inner(), &rhs) + >>::mul(_self.into_inner(), &rhs) .into(); output }, @@ -7127,70 +6906,37 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - }, - ); - NamespaceBuilder::<::bevy::math::UVec3>::new(world) - .register( - "mul", - |_self: Val, rhs: Ref| { - let output: Val = >::mul(_self.into_inner(), &rhs) - .into(); - output - }, - ) - .register( - "add", - |_self: Val, rhs: Ref| { - let output: Val = >::add(_self.into_inner(), &rhs) - .into(); - output - }, - ) - .register( - "div", - |_self: Val, rhs: Val| { - let output: Val = >::div(_self.into_inner(), rhs.into_inner()) + "new", + |x: u32, y: u32| { + let output: Val = bevy::math::UVec2::new(x, y) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) + "rem", + |_self: Val, rhs: Val| { + let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, - ) + "rem", + |_self: Val, rhs: Ref| { + let output: Val = >::rem(_self.into_inner(), &rhs) .into(); output }, ) .register( "rem", - |_self: Val, rhs: u32| { - let output: Val = , rhs: u32| { + let output: Val = >::rem(_self.into_inner(), rhs) .into(); @@ -7198,57 +6944,56 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) - .into(); - output - }, - ) - .register( - "rem", - |_self: Val, rhs: Ref| { - let output: Val = >::rem(_self.into_inner(), &rhs) + "saturating_add", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec2::saturating_add( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: u32| { - let output: Val = >::add(_self.into_inner(), rhs) + "saturating_add_signed", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec2::saturating_add_signed( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Ref| { - let output: Val = >::sub(_self.into_inner(), &rhs) + "saturating_div", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec2::saturating_div( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "new", - |x: u32, y: u32, z: u32| { - let output: Val = bevy::math::UVec3::new(x, y, z) + "saturating_mul", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec2::saturating_mul( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "splat", - |v: u32| { - let output: Val = bevy::math::UVec3::splat(v) + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec2::saturating_sub( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, @@ -7256,11 +7001,11 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { .register( "select", | - mask: Val, - if_true: Val, - if_false: Val| + mask: Val, + if_true: Val, + if_false: Val| { - let output: Val = bevy::math::UVec3::select( + let output: Val = bevy::math::UVec2::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -7270,45 +7015,54 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_array", - |a: [u32; 3]| { - let output: Val = bevy::math::UVec3::from_array(a) + "splat", + |v: u32| { + let output: Val = bevy::math::UVec2::splat(v) .into(); output }, ) .register( - "to_array", - |_self: Ref| { - let output: [u32; 3] = bevy::math::UVec3::to_array(&_self).into(); + "sub", + |_self: Val, rhs: u32| { + let output: Val = >::sub(_self.into_inner(), rhs) + .into(); output }, ) .register( - "extend", - |_self: Val, w: u32| { - let output: Val = bevy::math::UVec3::extend( - _self.into_inner(), - w, - ) + "sub", + |_self: Val, rhs: Ref| { + let output: Val = >::sub(_self.into_inner(), &rhs) .into(); output }, ) .register( - "truncate", - |_self: Val| { - let output: Val = bevy::math::UVec3::truncate( - _self.into_inner(), - ) + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) + .register( + "to_array", + |_self: Ref| { + let output: [u32; 2] = bevy::math::UVec2::to_array(&_self).into(); + output + }, + ) .register( "with_x", - |_self: Val, x: u32| { - let output: Val = bevy::math::UVec3::with_x( + |_self: Val, x: u32| { + let output: Val = bevy::math::UVec2::with_x( _self.into_inner(), x, ) @@ -7318,8 +7072,8 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { ) .register( "with_y", - |_self: Val, y: u32| { - let output: Val = bevy::math::UVec3::with_y( + |_self: Val, y: u32| { + let output: Val = bevy::math::UVec2::with_y( _self.into_inner(), y, ) @@ -7328,20 +7082,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "with_z", - |_self: Val, z: u32| { - let output: Val = bevy::math::UVec3::with_z( - _self.into_inner(), - z, - ) - .into(); - output - }, - ) - .register( - "dot", - |_self: Val, rhs: Val| { - let output: u32 = bevy::math::UVec3::dot( + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec2::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -7350,9 +7093,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "dot_into_vec", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec3::dot_into_vec( + "wrapping_add_signed", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec2::wrapping_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -7361,9 +7104,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cross", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec3::cross( + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec2::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -7372,9 +7115,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "min", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec3::min( + "wrapping_mul", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec2::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -7383,137 +7126,82 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "max", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec3::max( + "wrapping_sub", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec2::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) .into(); output }, - ) - .register( - "clamp", - | - _self: Val, - min: Val, - max: Val| - { - let output: Val = bevy::math::UVec3::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output - }, - ) - .register( - "min_element", - |_self: Val| { - let output: u32 = bevy::math::UVec3::min_element(_self.into_inner()) - .into(); - output - }, - ) - .register( - "max_element", - |_self: Val| { - let output: u32 = bevy::math::UVec3::max_element(_self.into_inner()) - .into(); - output - }, - ) - .register( - "element_sum", - |_self: Val| { - let output: u32 = bevy::math::UVec3::element_sum(_self.into_inner()) - .into(); - output - }, - ) - .register( - "element_product", - |_self: Val| { - let output: u32 = bevy::math::UVec3::element_product( - _self.into_inner(), - ) - .into(); - output - }, - ) + ); + NamespaceBuilder::<::bevy::math::UVec3>::new(world) .register( - "cmpeq", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec3::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) + "add", + |_self: Val, rhs: Ref| { + let output: Val = >::add(_self.into_inner(), &rhs) .into(); output }, ) .register( - "cmpne", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec3::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) + "add", + |_self: Val, rhs: u32| { + let output: Val = >::add(_self.into_inner(), rhs) .into(); output }, ) .register( - "cmpge", + "add", |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec3::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "cmpgt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec3::cmpgt( - _self.into_inner(), - rhs.into_inner(), + "as_dvec3", + |_self: Ref| { + let output: Val = bevy::math::UVec3::as_dvec3( + &_self, ) .into(); output }, ) .register( - "cmple", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec3::cmple( - _self.into_inner(), - rhs.into_inner(), + "as_i64vec3", + |_self: Ref| { + let output: Val = bevy::math::UVec3::as_i64vec3( + &_self, ) .into(); output }, ) .register( - "cmplt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec3::cmplt( - _self.into_inner(), - rhs.into_inner(), + "as_ivec3", + |_self: Ref| { + let output: Val = bevy::math::UVec3::as_ivec3( + &_self, ) .into(); output }, ) .register( - "length_squared", - |_self: Val| { - let output: u32 = bevy::math::UVec3::length_squared( - _self.into_inner(), + "as_u64vec3", + |_self: Ref| { + let output: Val = bevy::math::UVec3::as_u64vec3( + &_self, ) .into(); output @@ -7540,9 +7228,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "as_dvec3", + "assert_receiver_is_total_eq", |_self: Ref| { - let output: Val = bevy::math::UVec3::as_dvec3( + let output: () = ::assert_receiver_is_total_eq( &_self, ) .into(); @@ -7550,19 +7238,25 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "as_ivec3", - |_self: Ref| { - let output: Val = bevy::math::UVec3::as_ivec3( - &_self, + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = bevy::math::UVec3::clamp( + _self.into_inner(), + min.into_inner(), + max.into_inner(), ) .into(); output }, ) .register( - "as_i64vec3", + "clone", |_self: Ref| { - let output: Val = bevy::math::UVec3::as_i64vec3( + let output: Val = ::clone( &_self, ) .into(); @@ -7570,19 +7264,20 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "as_u64vec3", - |_self: Ref| { - let output: Val = bevy::math::UVec3::as_u64vec3( - &_self, + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec3::cmpeq( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "wrapping_add", + "cmpge", |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec3::wrapping_add( + let output: Val = bevy::math::UVec3::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -7591,9 +7286,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_sub", + "cmpgt", |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec3::wrapping_sub( + let output: Val = bevy::math::UVec3::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -7602,9 +7297,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_mul", + "cmple", |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec3::wrapping_mul( + let output: Val = bevy::math::UVec3::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -7613,9 +7308,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_div", + "cmplt", |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec3::wrapping_div( + let output: Val = bevy::math::UVec3::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -7624,9 +7319,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_add", + "cmpne", |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec3::saturating_add( + let output: Val = bevy::math::UVec3::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -7635,9 +7330,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_sub", + "cross", |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec3::saturating_sub( + let output: Val = bevy::math::UVec3::cross( _self.into_inner(), rhs.into_inner(), ) @@ -7646,42 +7341,39 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_mul", + "div", |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec3::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::div(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "saturating_div", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec3::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) + "div", + |_self: Val, rhs: u32| { + let output: Val = >::div(_self.into_inner(), rhs) .into(); output }, ) .register( - "wrapping_add_signed", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec3::wrapping_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) + "div", + |_self: Val, rhs: Ref| { + let output: Val = >::div(_self.into_inner(), &rhs) .into(); output }, ) .register( - "saturating_add_signed", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec3::saturating_add_signed( + "dot", + |_self: Val, rhs: Val| { + let output: u32 = bevy::math::UVec3::dot( _self.into_inner(), rhs.into_inner(), ) @@ -7690,236 +7382,227 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "mul", - |_self: Val, rhs: u32| { - let output: Val = >::mul(_self.into_inner(), rhs) + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec3::dot_into_vec( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: u32| { - let output: Val = >::sub(_self.into_inner(), rhs) + "element_product", + |_self: Val| { + let output: u32 = bevy::math::UVec3::element_product( + _self.into_inner(), + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Val| { - let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + "element_sum", + |_self: Val| { + let output: u32 = bevy::math::UVec3::element_sum(_self.into_inner()) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Val| { - let output: Val = , other: Ref| { + let output: bool = >::rem(_self.into_inner(), rhs.into_inner()) + >>::eq(&_self, &other) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "extend", + |_self: Val, w: u32| { + let output: Val = bevy::math::UVec3::extend( + _self.into_inner(), + w, + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: u32| { - let output: Val = >::div(_self.into_inner(), rhs) + "from_array", + |a: [u32; 3]| { + let output: Val = bevy::math::UVec3::from_array(a) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + "length_squared", + |_self: Val| { + let output: u32 = bevy::math::UVec3::length_squared( + _self.into_inner(), + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: Ref| { - let output: Val = >::div(_self.into_inner(), &rhs) + "max", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec3::max( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::UVec4>::new(world) + ) .register( - "mul", - |_self: Val, rhs: u32| { - let output: Val = >::mul(_self.into_inner(), rhs) + "max_element", + |_self: Val| { + let output: u32 = bevy::math::UVec3::max_element(_self.into_inner()) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Val| { - let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + "min", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec3::min( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: Ref| { - let output: Val = >::div(_self.into_inner(), &rhs) + "min_element", + |_self: Val| { + let output: u32 = bevy::math::UVec3::min_element(_self.into_inner()) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Ref| { - let output: Val = >::sub(_self.into_inner(), &rhs) + "mul", + |_self: Val, rhs: Ref| { + let output: Val = >::mul(_self.into_inner(), &rhs) .into(); output }, ) .register( - "new", - |x: u32, y: u32, z: u32, w: u32| { - let output: Val = bevy::math::UVec4::new( - x, - y, - z, - w, - ) + "mul", + |_self: Val, rhs: u32| { + let output: Val = >::mul(_self.into_inner(), rhs) .into(); output }, ) .register( - "splat", - |v: u32| { - let output: Val = bevy::math::UVec4::splat(v) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "select", - | - mask: Val, - if_true: Val, - if_false: Val| - { - let output: Val = bevy::math::UVec4::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) + "new", + |x: u32, y: u32, z: u32| { + let output: Val = bevy::math::UVec3::new(x, y, z) .into(); output }, ) .register( - "from_array", - |a: [u32; 4]| { - let output: Val = bevy::math::UVec4::from_array(a) + "rem", + |_self: Val, rhs: u32| { + let output: Val = >::rem(_self.into_inner(), rhs) .into(); output }, ) .register( - "to_array", - |_self: Ref| { - let output: [u32; 4] = bevy::math::UVec4::to_array(&_self).into(); + "rem", + |_self: Val, rhs: Ref| { + let output: Val = >::rem(_self.into_inner(), &rhs) + .into(); output }, ) .register( - "truncate", - |_self: Val| { - let output: Val = bevy::math::UVec4::truncate( - _self.into_inner(), - ) + "rem", + |_self: Val, rhs: Val| { + let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "with_x", - |_self: Val, x: u32| { - let output: Val = bevy::math::UVec4::with_x( + "saturating_add", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec3::saturating_add( _self.into_inner(), - x, + rhs.into_inner(), ) .into(); output }, ) .register( - "with_y", - |_self: Val, y: u32| { - let output: Val = bevy::math::UVec4::with_y( + "saturating_add_signed", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec3::saturating_add_signed( _self.into_inner(), - y, + rhs.into_inner(), ) .into(); output }, ) .register( - "with_z", - |_self: Val, z: u32| { - let output: Val = bevy::math::UVec4::with_z( + "saturating_div", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec3::saturating_div( _self.into_inner(), - z, + rhs.into_inner(), ) .into(); output }, ) .register( - "with_w", - |_self: Val, w: u32| { - let output: Val = bevy::math::UVec4::with_w( + "saturating_mul", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec3::saturating_mul( _self.into_inner(), - w, + rhs.into_inner(), ) .into(); output }, ) .register( - "dot", - |_self: Val, rhs: Val| { - let output: u32 = bevy::math::UVec4::dot( + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec3::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -7928,114 +7611,113 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "dot_into_vec", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec4::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = bevy::math::UVec3::select( + mask.into_inner(), + if_true.into_inner(), + if_false.into_inner(), ) .into(); output }, ) .register( - "min", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec4::min( - _self.into_inner(), - rhs.into_inner(), - ) + "splat", + |v: u32| { + let output: Val = bevy::math::UVec3::splat(v) .into(); output }, ) .register( - "max", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec4::max( - _self.into_inner(), - rhs.into_inner(), - ) + "sub", + |_self: Val, rhs: Ref| { + let output: Val = >::sub(_self.into_inner(), &rhs) .into(); output }, ) .register( - "clamp", - | - _self: Val, - min: Val, - max: Val| - { - let output: Val = bevy::math::UVec4::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) + "sub", + |_self: Val, rhs: u32| { + let output: Val = >::sub(_self.into_inner(), rhs) .into(); output }, ) .register( - "min_element", - |_self: Val| { - let output: u32 = bevy::math::UVec4::min_element(_self.into_inner()) + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "max_element", - |_self: Val| { - let output: u32 = bevy::math::UVec4::max_element(_self.into_inner()) - .into(); + "to_array", + |_self: Ref| { + let output: [u32; 3] = bevy::math::UVec3::to_array(&_self).into(); output }, ) .register( - "element_sum", - |_self: Val| { - let output: u32 = bevy::math::UVec4::element_sum(_self.into_inner()) + "truncate", + |_self: Val| { + let output: Val = bevy::math::UVec3::truncate( + _self.into_inner(), + ) .into(); output }, ) .register( - "element_product", - |_self: Val| { - let output: u32 = bevy::math::UVec4::element_product( + "with_x", + |_self: Val, x: u32| { + let output: Val = bevy::math::UVec3::with_x( _self.into_inner(), + x, ) .into(); output }, ) .register( - "cmpeq", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec4::cmpeq( + "with_y", + |_self: Val, y: u32| { + let output: Val = bevy::math::UVec3::with_y( _self.into_inner(), - rhs.into_inner(), + y, ) .into(); output }, ) .register( - "cmpne", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec4::cmpne( + "with_z", + |_self: Val, z: u32| { + let output: Val = bevy::math::UVec3::with_z( _self.into_inner(), - rhs.into_inner(), + z, ) .into(); output }, ) .register( - "cmpge", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec4::cmpge( + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec3::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -8044,9 +7726,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cmpgt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec4::cmpgt( + "wrapping_add_signed", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec3::wrapping_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -8055,9 +7737,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cmple", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec4::cmple( + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec3::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -8066,9 +7748,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cmplt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec4::cmplt( + "wrapping_mul", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec3::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -8077,21 +7759,43 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "length_squared", - |_self: Val| { - let output: u32 = bevy::math::UVec4::length_squared( + "wrapping_sub", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec3::wrapping_sub( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, + ); + NamespaceBuilder::<::bevy::math::UVec4>::new(world) + .register( + "add", + |_self: Val, rhs: Val| { + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + .into(); + output + }, ) .register( - "as_vec4", - |_self: Ref| { - let output: Val = bevy::math::UVec4::as_vec4( - &_self, - ) + "add", + |_self: Val, rhs: u32| { + let output: Val = >::add(_self.into_inner(), rhs) + .into(); + output + }, + ) + .register( + "add", + |_self: Val, rhs: Ref| { + let output: Val = >::add(_self.into_inner(), &rhs) .into(); output }, @@ -8107,9 +7811,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "as_ivec4", + "as_i64vec4", |_self: Ref| { - let output: Val = bevy::math::UVec4::as_ivec4( + let output: Val = bevy::math::UVec4::as_i64vec4( &_self, ) .into(); @@ -8117,9 +7821,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "as_i64vec4", + "as_ivec4", |_self: Ref| { - let output: Val = bevy::math::UVec4::as_i64vec4( + let output: Val = bevy::math::UVec4::as_ivec4( &_self, ) .into(); @@ -8137,53 +7841,55 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_add", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec4::wrapping_add( - _self.into_inner(), - rhs.into_inner(), + "as_vec4", + |_self: Ref| { + let output: Val = bevy::math::UVec4::as_vec4( + &_self, ) .into(); output }, ) .register( - "wrapping_sub", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec4::wrapping_sub( - _self.into_inner(), - rhs.into_inner(), + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( + &_self, ) .into(); output }, ) .register( - "wrapping_mul", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec4::wrapping_mul( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = bevy::math::UVec4::clamp( _self.into_inner(), - rhs.into_inner(), + min.into_inner(), + max.into_inner(), ) .into(); output }, ) .register( - "wrapping_div", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec4::wrapping_div( - _self.into_inner(), - rhs.into_inner(), + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, ) .into(); output }, ) .register( - "saturating_add", + "cmpeq", |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec4::saturating_add( + let output: Val = bevy::math::UVec4::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -8192,9 +7898,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_sub", + "cmpge", |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec4::saturating_sub( + let output: Val = bevy::math::UVec4::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -8203,9 +7909,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_mul", + "cmpgt", |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec4::saturating_mul( + let output: Val = bevy::math::UVec4::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -8214,9 +7920,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_div", + "cmple", |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec4::saturating_div( + let output: Val = bevy::math::UVec4::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -8225,9 +7931,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_add_signed", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec4::wrapping_add_signed( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec4::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -8236,9 +7942,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_add_signed", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::UVec4::saturating_add_signed( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec4::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -8247,101 +7953,157 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) + "div", + |_self: Val, rhs: Ref| { + let output: Val = >::div(_self.into_inner(), &rhs) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Val| { - let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) + "div", + |_self: Val, rhs: u32| { + let output: Val = >::div(_self.into_inner(), rhs) .into(); output }, ) .register( - "mul", + "div", |_self: Val, rhs: Val| { - let output: Val = = >::mul(_self.into_inner(), rhs.into_inner()) + >>::div(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "add", - |_self: Val, rhs: u32| { - let output: Val = >::add(_self.into_inner(), rhs) + "dot", + |_self: Val, rhs: Val| { + let output: u32 = bevy::math::UVec4::dot( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec4::dot_into_vec( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, + "element_product", + |_self: Val| { + let output: u32 = bevy::math::UVec4::element_product( + _self.into_inner(), ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: u32| { - let output: Val = >::div(_self.into_inner(), rhs) + "element_sum", + |_self: Val| { + let output: u32 = bevy::math::UVec4::element_sum(_self.into_inner()) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: u32| { - let output: Val = >::rem(_self.into_inner(), rhs) + "eq", + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "sub", + "from_array", + |a: [u32; 4]| { + let output: Val = bevy::math::UVec4::from_array(a) + .into(); + output + }, + ) + .register( + "length_squared", + |_self: Val| { + let output: u32 = bevy::math::UVec4::length_squared( + _self.into_inner(), + ) + .into(); + output + }, + ) + .register( + "max", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec4::max( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + }, + ) + .register( + "max_element", + |_self: Val| { + let output: u32 = bevy::math::UVec4::max_element(_self.into_inner()) + .into(); + output + }, + ) + .register( + "min", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec4::min( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); + output + }, + ) + .register( + "min_element", + |_self: Val| { + let output: u32 = bevy::math::UVec4::min_element(_self.into_inner()) + .into(); + output + }, + ) + .register( + "mul", |_self: Val, rhs: u32| { - let output: Val = = >::sub(_self.into_inner(), rhs) + >>::mul(_self.into_inner(), rhs) .into(); output }, ) .register( - "sub", + "mul", |_self: Val, rhs: Val| { - let output: Val = = >::sub(_self.into_inner(), rhs.into_inner()) + >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, @@ -8357,161 +8119,180 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "div", + "new", + |x: u32, y: u32, z: u32, w: u32| { + let output: Val = bevy::math::UVec4::new( + x, + y, + z, + w, + ) + .into(); + output + }, + ) + .register( + "rem", |_self: Val, rhs: Val| { - let output: Val = = >::div(_self.into_inner(), rhs.into_inner()) + >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( "rem", - |_self: Val, rhs: Ref| { + |_self: Val, rhs: u32| { let output: Val = >::rem(_self.into_inner(), &rhs) + u32, + >>::rem(_self.into_inner(), rhs) .into(); output }, ) .register( - "add", + "rem", |_self: Val, rhs: Ref| { - let output: Val = = >::add(_self.into_inner(), &rhs) + >>::rem(_self.into_inner(), &rhs) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::U64Vec2>::new(world) + ) .register( - "div", - |_self: Val, rhs: Val| { - let output: Val = >::div(_self.into_inner(), rhs.into_inner()) + "saturating_add", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec4::saturating_add( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: u64| { - let output: Val = >::add(_self.into_inner(), rhs) + "saturating_add_signed", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec4::saturating_add_signed( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: u64| { - let output: Val = >::sub(_self.into_inner(), rhs) + "saturating_div", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec4::saturating_div( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, + "saturating_mul", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec4::saturating_mul( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Val| { - let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec4::saturating_sub( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Ref| { - let output: Val = >::add(_self.into_inner(), &rhs) + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = bevy::math::UVec4::select( + mask.into_inner(), + if_true.into_inner(), + if_false.into_inner(), + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "splat", + |v: u32| { + let output: Val = bevy::math::UVec4::splat(v) .into(); output }, ) .register( - "new", - |x: u64, y: u64| { - let output: Val = bevy::math::U64Vec2::new(x, y) + "sub", + |_self: Val, rhs: Ref| { + let output: Val = >::sub(_self.into_inner(), &rhs) .into(); output }, ) .register( - "splat", - |v: u64| { - let output: Val = bevy::math::U64Vec2::splat(v) + "sub", + |_self: Val, rhs: u32| { + let output: Val = >::sub(_self.into_inner(), rhs) .into(); output }, ) .register( - "select", - | - mask: Val, - if_true: Val, - if_false: Val| - { - let output: Val = bevy::math::U64Vec2::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "from_array", - |a: [u64; 2]| { - let output: Val = bevy::math::U64Vec2::from_array( - a, - ) - .into(); + "to_array", + |_self: Ref| { + let output: [u32; 4] = bevy::math::UVec4::to_array(&_self).into(); output }, ) .register( - "to_array", - |_self: Ref| { - let output: [u64; 2] = bevy::math::U64Vec2::to_array(&_self).into(); + "truncate", + |_self: Val| { + let output: Val = bevy::math::UVec4::truncate( + _self.into_inner(), + ) + .into(); output }, ) .register( - "extend", - |_self: Val, z: u64| { - let output: Val = bevy::math::U64Vec2::extend( + "with_w", + |_self: Val, w: u32| { + let output: Val = bevy::math::UVec4::with_w( _self.into_inner(), - z, + w, ) .into(); output @@ -8519,8 +8300,8 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { ) .register( "with_x", - |_self: Val, x: u64| { - let output: Val = bevy::math::U64Vec2::with_x( + |_self: Val, x: u32| { + let output: Val = bevy::math::UVec4::with_x( _self.into_inner(), x, ) @@ -8530,8 +8311,8 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { ) .register( "with_y", - |_self: Val, y: u64| { - let output: Val = bevy::math::U64Vec2::with_y( + |_self: Val, y: u32| { + let output: Val = bevy::math::UVec4::with_y( _self.into_inner(), y, ) @@ -8540,20 +8321,20 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "dot", - |_self: Val, rhs: Val| { - let output: u64 = bevy::math::U64Vec2::dot( + "with_z", + |_self: Val, z: u32| { + let output: Val = bevy::math::UVec4::with_z( _self.into_inner(), - rhs.into_inner(), + z, ) .into(); output }, ) .register( - "dot_into_vec", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec2::dot_into_vec( + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec4::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -8562,9 +8343,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "min", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec2::min( + "wrapping_add_signed", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec4::wrapping_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -8573,9 +8354,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "max", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec2::max( + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec4::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -8584,132 +8365,93 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "clamp", - | - _self: Val, - min: Val, - max: Val| - { - let output: Val = bevy::math::U64Vec2::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output - }, - ) - .register( - "min_element", - |_self: Val| { - let output: u64 = bevy::math::U64Vec2::min_element( - _self.into_inner(), - ) - .into(); - output - }, - ) - .register( - "max_element", - |_self: Val| { - let output: u64 = bevy::math::U64Vec2::max_element( - _self.into_inner(), - ) - .into(); - output - }, - ) - .register( - "element_sum", - |_self: Val| { - let output: u64 = bevy::math::U64Vec2::element_sum( + "wrapping_mul", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec4::wrapping_mul( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "element_product", - |_self: Val| { - let output: u64 = bevy::math::U64Vec2::element_product( + "wrapping_sub", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::UVec4::wrapping_sub( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::U64Vec2>::new(world) .register( - "cmpeq", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec2::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) + "add", + |_self: Val, rhs: u64| { + let output: Val = >::add(_self.into_inner(), rhs) .into(); output }, ) .register( - "cmpne", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec2::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) + "add", + |_self: Val, rhs: Ref| { + let output: Val = >::add(_self.into_inner(), &rhs) .into(); output }, ) .register( - "cmpge", + "add", |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec2::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "cmpgt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec2::cmpgt( - _self.into_inner(), - rhs.into_inner(), + "as_dvec2", + |_self: Ref| { + let output: Val = bevy::math::U64Vec2::as_dvec2( + &_self, ) .into(); output }, ) .register( - "cmple", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec2::cmple( - _self.into_inner(), - rhs.into_inner(), + "as_i64vec2", + |_self: Ref| { + let output: Val = bevy::math::U64Vec2::as_i64vec2( + &_self, ) .into(); output }, ) .register( - "cmplt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec2::cmplt( - _self.into_inner(), - rhs.into_inner(), + "as_ivec2", + |_self: Ref| { + let output: Val = bevy::math::U64Vec2::as_ivec2( + &_self, ) .into(); output }, ) .register( - "length_squared", - |_self: Val| { - let output: u64 = bevy::math::U64Vec2::length_squared( - _self.into_inner(), + "as_uvec2", + |_self: Ref| { + let output: Val = bevy::math::U64Vec2::as_uvec2( + &_self, ) .into(); output @@ -8726,9 +8468,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "as_dvec2", + "assert_receiver_is_total_eq", |_self: Ref| { - let output: Val = bevy::math::U64Vec2::as_dvec2( + let output: () = ::assert_receiver_is_total_eq( &_self, ) .into(); @@ -8736,19 +8478,25 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "as_ivec2", - |_self: Ref| { - let output: Val = bevy::math::U64Vec2::as_ivec2( - &_self, + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = bevy::math::U64Vec2::clamp( + _self.into_inner(), + min.into_inner(), + max.into_inner(), ) .into(); output }, ) .register( - "as_uvec2", + "clone", |_self: Ref| { - let output: Val = bevy::math::U64Vec2::as_uvec2( + let output: Val = ::clone( &_self, ) .into(); @@ -8756,19 +8504,20 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "as_i64vec2", - |_self: Ref| { - let output: Val = bevy::math::U64Vec2::as_i64vec2( - &_self, + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec2::cmpeq( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "wrapping_add", + "cmpge", |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec2::wrapping_add( + let output: Val = bevy::math::U64Vec2::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -8777,9 +8526,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_sub", + "cmpgt", |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec2::wrapping_sub( + let output: Val = bevy::math::U64Vec2::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -8788,9 +8537,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_mul", + "cmple", |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec2::wrapping_mul( + let output: Val = bevy::math::U64Vec2::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -8799,9 +8548,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_div", + "cmplt", |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec2::wrapping_div( + let output: Val = bevy::math::U64Vec2::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -8810,9 +8559,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_add", + "cmpne", |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec2::saturating_add( + let output: Val = bevy::math::U64Vec2::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -8821,42 +8570,39 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_sub", + "div", |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec2::saturating_sub( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::div(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "saturating_mul", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec2::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) + "div", + |_self: Val, rhs: Ref| { + let output: Val = >::div(_self.into_inner(), &rhs) .into(); output }, ) .register( - "saturating_div", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec2::saturating_div( - _self.into_inner(), - rhs.into_inner(), - ) + "div", + |_self: Val, rhs: u64| { + let output: Val = >::div(_self.into_inner(), rhs) .into(); output }, ) .register( - "wrapping_add_signed", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec2::wrapping_add_signed( + "dot", + |_self: Val, rhs: Val| { + let output: u64 = bevy::math::U64Vec2::dot( _self.into_inner(), rhs.into_inner(), ) @@ -8865,9 +8611,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_add_signed", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec2::saturating_add_signed( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec2::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -8876,150 +8622,132 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, + "element_product", + |_self: Val| { + let output: u64 = bevy::math::U64Vec2::element_product( + _self.into_inner(), ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Ref| { - let output: Val = >::mul(_self.into_inner(), &rhs) + "element_sum", + |_self: Val| { + let output: u64 = bevy::math::U64Vec2::element_sum( + _self.into_inner(), + ) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Ref| { - let output: Val = >::rem(_self.into_inner(), &rhs) + "eq", + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: u64| { - let output: Val = >::mul(_self.into_inner(), rhs) + "extend", + |_self: Val, z: u64| { + let output: Val = bevy::math::U64Vec2::extend( + _self.into_inner(), + z, + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: Ref| { - let output: Val = >::div(_self.into_inner(), &rhs) + "from_array", + |a: [u64; 2]| { + let output: Val = bevy::math::U64Vec2::from_array( + a, + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Ref| { - let output: Val = >::sub(_self.into_inner(), &rhs) + "length_squared", + |_self: Val| { + let output: u64 = bevy::math::U64Vec2::length_squared( + _self.into_inner(), + ) .into(); output }, ) .register( - "sub", + "max", |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output - }, - ) - .register( - "rem", - |_self: Val, rhs: u64| { - let output: Val = >::rem(_self.into_inner(), rhs) + let output: Val = bevy::math::U64Vec2::max( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) + "max_element", + |_self: Val| { + let output: u64 = bevy::math::U64Vec2::max_element( + _self.into_inner(), + ) .into(); output }, ) .register( - "add", + "min", |_self: Val, rhs: Val| { - let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + let output: Val = bevy::math::U64Vec2::min( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: u64| { - let output: Val = >::div(_self.into_inner(), rhs) - .into(); - output - }, - ); - NamespaceBuilder::<::bevy::math::U64Vec3>::new(world) - .register( - "mul", - |_self: Val, rhs: Ref| { - let output: Val = >::mul(_self.into_inner(), &rhs) + "min_element", + |_self: Val| { + let output: u64 = bevy::math::U64Vec2::min_element( + _self.into_inner(), + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: u64| { - let output: Val = >::add(_self.into_inner(), rhs) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + "mul", + |_self: Val, rhs: Ref| { + let output: Val = >::mul(_self.into_inner(), &rhs) .into(); output }, ) .register( "mul", - |_self: Val, rhs: u64| { - let output: Val = , rhs: u64| { + let output: Val = >::mul(_self.into_inner(), rhs) .into(); @@ -9027,111 +8755,94 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "rem", - |_self: Val, rhs: u64| { - let output: Val = >::rem(_self.into_inner(), rhs) + "new", + |x: u64, y: u64| { + let output: Val = bevy::math::U64Vec2::new(x, y) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) + "rem", + |_self: Val, rhs: Val| { + let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( "rem", - |_self: Val, rhs: Ref| { - let output: Val = , rhs: Ref| { + let output: Val = >::rem(_self.into_inner(), &rhs) .into(); output }, ) .register( - "div", - |_self: Val, rhs: Ref| { - let output: Val = >::div(_self.into_inner(), &rhs) - .into(); - output - }, - ) - .register( - "add", - |_self: Val, rhs: Ref| { - let output: Val = >::add(_self.into_inner(), &rhs) - .into(); - output - }, - ) - .register( - "sub", - |_self: Val, rhs: u64| { - let output: Val = , rhs: u64| { + let output: Val = >::sub(_self.into_inner(), rhs) + >>::rem(_self.into_inner(), rhs) .into(); output }, ) .register( - "div", - |_self: Val, rhs: u64| { - let output: Val = >::div(_self.into_inner(), rhs) + "saturating_add", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec2::saturating_add( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Val| { - let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + "saturating_add_signed", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec2::saturating_add_signed( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Val| { - let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) + "saturating_div", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec2::saturating_div( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "new", - |x: u64, y: u64, z: u64| { - let output: Val = bevy::math::U64Vec3::new( - x, - y, - z, + "saturating_mul", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec2::saturating_mul( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "splat", - |v: u64| { - let output: Val = bevy::math::U64Vec3::splat(v) + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec2::saturating_sub( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, @@ -9139,11 +8850,11 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { .register( "select", | - mask: Val, - if_true: Val, - if_false: Val| + mask: Val, + if_true: Val, + if_false: Val| { - let output: Val = bevy::math::U64Vec3::select( + let output: Val = bevy::math::U64Vec2::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -9153,80 +8864,76 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_array", - |a: [u64; 3]| { - let output: Val = bevy::math::U64Vec3::from_array( - a, - ) + "splat", + |v: u64| { + let output: Val = bevy::math::U64Vec2::splat(v) .into(); output }, ) .register( - "to_array", - |_self: Ref| { - let output: [u64; 3] = bevy::math::U64Vec3::to_array(&_self).into(); + "sub", + |_self: Val, rhs: u64| { + let output: Val = >::sub(_self.into_inner(), rhs) + .into(); output }, ) .register( - "extend", - |_self: Val, w: u64| { - let output: Val = bevy::math::U64Vec3::extend( - _self.into_inner(), - w, - ) + "sub", + |_self: Val, rhs: Ref| { + let output: Val = >::sub(_self.into_inner(), &rhs) .into(); output }, ) .register( - "truncate", - |_self: Val| { - let output: Val = bevy::math::U64Vec3::truncate( - _self.into_inner(), - ) + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "with_x", - |_self: Val, x: u64| { - let output: Val = bevy::math::U64Vec3::with_x( - _self.into_inner(), - x, - ) - .into(); + "to_array", + |_self: Ref| { + let output: [u64; 2] = bevy::math::U64Vec2::to_array(&_self).into(); output }, ) .register( - "with_y", - |_self: Val, y: u64| { - let output: Val = bevy::math::U64Vec3::with_y( + "with_x", + |_self: Val, x: u64| { + let output: Val = bevy::math::U64Vec2::with_x( _self.into_inner(), - y, + x, ) .into(); output }, ) .register( - "with_z", - |_self: Val, z: u64| { - let output: Val = bevy::math::U64Vec3::with_z( + "with_y", + |_self: Val, y: u64| { + let output: Val = bevy::math::U64Vec2::with_y( _self.into_inner(), - z, + y, ) .into(); output }, ) .register( - "dot", - |_self: Val, rhs: Val| { - let output: u64 = bevy::math::U64Vec3::dot( + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec2::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -9235,9 +8942,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "dot_into_vec", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec3::dot_into_vec( + "wrapping_add_signed", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec2::wrapping_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -9246,9 +8953,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cross", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec3::cross( + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec2::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -9257,9 +8964,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "min", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec3::min( + "wrapping_mul", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec2::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -9268,143 +8975,82 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "max", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec3::max( + "wrapping_sub", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec2::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) .into(); output }, - ) - .register( - "clamp", - | - _self: Val, - min: Val, - max: Val| - { - let output: Val = bevy::math::U64Vec3::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output - }, - ) - .register( - "min_element", - |_self: Val| { - let output: u64 = bevy::math::U64Vec3::min_element( - _self.into_inner(), - ) - .into(); - output - }, - ) - .register( - "max_element", - |_self: Val| { - let output: u64 = bevy::math::U64Vec3::max_element( - _self.into_inner(), - ) - .into(); - output - }, - ) - .register( - "element_sum", - |_self: Val| { - let output: u64 = bevy::math::U64Vec3::element_sum( - _self.into_inner(), - ) - .into(); - output - }, - ) - .register( - "element_product", - |_self: Val| { - let output: u64 = bevy::math::U64Vec3::element_product( - _self.into_inner(), - ) - .into(); - output - }, - ) + ); + NamespaceBuilder::<::bevy::math::U64Vec3>::new(world) .register( - "cmpeq", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec3::cmpeq( - _self.into_inner(), - rhs.into_inner(), - ) + "add", + |_self: Val, rhs: u64| { + let output: Val = >::add(_self.into_inner(), rhs) .into(); output }, ) .register( - "cmpne", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec3::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) + "add", + |_self: Val, rhs: Ref| { + let output: Val = >::add(_self.into_inner(), &rhs) .into(); output }, ) .register( - "cmpge", + "add", |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec3::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "cmpgt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec3::cmpgt( - _self.into_inner(), - rhs.into_inner(), + "as_dvec3", + |_self: Ref| { + let output: Val = bevy::math::U64Vec3::as_dvec3( + &_self, ) .into(); output }, ) .register( - "cmple", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec3::cmple( - _self.into_inner(), - rhs.into_inner(), + "as_i64vec3", + |_self: Ref| { + let output: Val = bevy::math::U64Vec3::as_i64vec3( + &_self, ) .into(); output }, ) .register( - "cmplt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec3::cmplt( - _self.into_inner(), - rhs.into_inner(), + "as_ivec3", + |_self: Ref| { + let output: Val = bevy::math::U64Vec3::as_ivec3( + &_self, ) .into(); output }, ) .register( - "length_squared", - |_self: Val| { - let output: u64 = bevy::math::U64Vec3::length_squared( - _self.into_inner(), + "as_uvec3", + |_self: Ref| { + let output: Val = bevy::math::U64Vec3::as_uvec3( + &_self, ) .into(); output @@ -9431,9 +9077,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "as_dvec3", + "assert_receiver_is_total_eq", |_self: Ref| { - let output: Val = bevy::math::U64Vec3::as_dvec3( + let output: () = ::assert_receiver_is_total_eq( &_self, ) .into(); @@ -9441,19 +9087,25 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "as_ivec3", - |_self: Ref| { - let output: Val = bevy::math::U64Vec3::as_ivec3( - &_self, + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = bevy::math::U64Vec3::clamp( + _self.into_inner(), + min.into_inner(), + max.into_inner(), ) .into(); output }, ) .register( - "as_uvec3", + "clone", |_self: Ref| { - let output: Val = bevy::math::U64Vec3::as_uvec3( + let output: Val = ::clone( &_self, ) .into(); @@ -9461,19 +9113,20 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "as_i64vec3", - |_self: Ref| { - let output: Val = bevy::math::U64Vec3::as_i64vec3( - &_self, + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec3::cmpeq( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "wrapping_add", + "cmpge", |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec3::wrapping_add( + let output: Val = bevy::math::U64Vec3::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -9482,9 +9135,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_sub", + "cmpgt", |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec3::wrapping_sub( + let output: Val = bevy::math::U64Vec3::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -9493,9 +9146,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_mul", + "cmple", |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec3::wrapping_mul( + let output: Val = bevy::math::U64Vec3::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -9504,9 +9157,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_div", + "cmplt", |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec3::wrapping_div( + let output: Val = bevy::math::U64Vec3::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -9515,9 +9168,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_add", + "cmpne", |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec3::saturating_add( + let output: Val = bevy::math::U64Vec3::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -9526,9 +9179,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_sub", + "cross", |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec3::saturating_sub( + let output: Val = bevy::math::U64Vec3::cross( _self.into_inner(), rhs.into_inner(), ) @@ -9537,20 +9190,39 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_mul", + "div", + |_self: Val, rhs: Ref| { + let output: Val = >::div(_self.into_inner(), &rhs) + .into(); + output + }, + ) + .register( + "div", + |_self: Val, rhs: u64| { + let output: Val = >::div(_self.into_inner(), rhs) + .into(); + output + }, + ) + .register( + "div", |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec3::saturating_mul( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::div(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "saturating_div", + "dot", |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec3::saturating_div( + let output: u64 = bevy::math::U64Vec3::dot( _self.into_inner(), rhs.into_inner(), ) @@ -9559,9 +9231,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_add_signed", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec3::wrapping_add_signed( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec3::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -9570,22 +9242,21 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_add_signed", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec3::saturating_add_signed( + "element_product", + |_self: Val| { + let output: u64 = bevy::math::U64Vec3::element_product( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: Val| { - let output: Val = >::div(_self.into_inner(), rhs.into_inner()) + "element_sum", + |_self: Val| { + let output: u64 = bevy::math::U64Vec3::element_sum( + _self.into_inner(), + ) .into(); output }, @@ -9601,348 +9272,324 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "extend", + |_self: Val, w: u64| { + let output: Val = bevy::math::U64Vec3::extend( + _self.into_inner(), + w, + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Ref| { - let output: Val = >::sub(_self.into_inner(), &rhs) + "from_array", + |a: [u64; 3]| { + let output: Val = bevy::math::U64Vec3::from_array( + a, + ) .into(); output }, ) .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, + "length_squared", + |_self: Val| { + let output: u64 = bevy::math::U64Vec3::length_squared( + _self.into_inner(), ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::U64Vec4>::new(world) + ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "max", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec3::max( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Val| { - let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + "max_element", + |_self: Val| { + let output: u64 = bevy::math::U64Vec3::max_element( + _self.into_inner(), + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: u64| { - let output: Val = >::add(_self.into_inner(), rhs) + "min", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec3::min( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Val| { - let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) + "min_element", + |_self: Val| { + let output: u64 = bevy::math::U64Vec3::min_element( + _self.into_inner(), + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Ref| { - let output: Val = >::add(_self.into_inner(), &rhs) + "mul", + |_self: Val, rhs: Ref| { + let output: Val = >::mul(_self.into_inner(), &rhs) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: u64| { - let output: Val = , rhs: u64| { + let output: Val = >::sub(_self.into_inner(), rhs) + >>::mul(_self.into_inner(), rhs) .into(); output }, ) .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Ref| { - let output: Val = >::sub(_self.into_inner(), &rhs) + "new", + |x: u64, y: u64, z: u64| { + let output: Val = bevy::math::U64Vec3::new( + x, + y, + z, + ) .into(); output }, ) .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, - ) + "rem", + |_self: Val, rhs: u64| { + let output: Val = >::rem(_self.into_inner(), rhs) .into(); output }, ) .register( - "div", - |_self: Val, rhs: Ref| { - let output: Val = >::div(_self.into_inner(), &rhs) + "rem", + |_self: Val, rhs: Ref| { + let output: Val = >::rem(_self.into_inner(), &rhs) .into(); output }, ) .register( - "new", - |x: u64, y: u64, z: u64, w: u64| { - let output: Val = bevy::math::U64Vec4::new( - x, - y, - z, - w, - ) + "rem", + |_self: Val, rhs: Val| { + let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "splat", - |v: u64| { - let output: Val = bevy::math::U64Vec4::splat(v) + "saturating_add", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec3::saturating_add( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "select", - | - mask: Val, - if_true: Val, - if_false: Val| - { - let output: Val = bevy::math::U64Vec4::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), + "saturating_add_signed", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec3::saturating_add_signed( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "from_array", - |a: [u64; 4]| { - let output: Val = bevy::math::U64Vec4::from_array( - a, + "saturating_div", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec3::saturating_div( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "to_array", - |_self: Ref| { - let output: [u64; 4] = bevy::math::U64Vec4::to_array(&_self).into(); + "saturating_mul", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec3::saturating_mul( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); output }, ) .register( - "truncate", - |_self: Val| { - let output: Val = bevy::math::U64Vec4::truncate( + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec3::saturating_sub( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "with_x", - |_self: Val, x: u64| { - let output: Val = bevy::math::U64Vec4::with_x( - _self.into_inner(), - x, - ) - .into(); - output - }, - ) - .register( - "with_y", - |_self: Val, y: u64| { - let output: Val = bevy::math::U64Vec4::with_y( - _self.into_inner(), - y, - ) - .into(); - output - }, - ) - .register( - "with_z", - |_self: Val, z: u64| { - let output: Val = bevy::math::U64Vec4::with_z( - _self.into_inner(), - z, + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = bevy::math::U64Vec3::select( + mask.into_inner(), + if_true.into_inner(), + if_false.into_inner(), ) .into(); output }, ) .register( - "with_w", - |_self: Val, w: u64| { - let output: Val = bevy::math::U64Vec4::with_w( - _self.into_inner(), - w, - ) + "splat", + |v: u64| { + let output: Val = bevy::math::U64Vec3::splat(v) .into(); output }, ) .register( - "dot", - |_self: Val, rhs: Val| { - let output: u64 = bevy::math::U64Vec4::dot( - _self.into_inner(), - rhs.into_inner(), - ) + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "dot_into_vec", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec4::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) + "sub", + |_self: Val, rhs: u64| { + let output: Val = >::sub(_self.into_inner(), rhs) .into(); output }, ) .register( - "min", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec4::min( - _self.into_inner(), - rhs.into_inner(), - ) + "sub", + |_self: Val, rhs: Ref| { + let output: Val = >::sub(_self.into_inner(), &rhs) .into(); output }, ) .register( - "max", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec4::max( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); + "to_array", + |_self: Ref| { + let output: [u64; 3] = bevy::math::U64Vec3::to_array(&_self).into(); output }, ) .register( - "clamp", - | - _self: Val, - min: Val, - max: Val| - { - let output: Val = bevy::math::U64Vec4::clamp( + "truncate", + |_self: Val| { + let output: Val = bevy::math::U64Vec3::truncate( _self.into_inner(), - min.into_inner(), - max.into_inner(), ) .into(); output }, ) .register( - "min_element", - |_self: Val| { - let output: u64 = bevy::math::U64Vec4::min_element( + "with_x", + |_self: Val, x: u64| { + let output: Val = bevy::math::U64Vec3::with_x( _self.into_inner(), + x, ) .into(); output }, ) .register( - "max_element", - |_self: Val| { - let output: u64 = bevy::math::U64Vec4::max_element( + "with_y", + |_self: Val, y: u64| { + let output: Val = bevy::math::U64Vec3::with_y( _self.into_inner(), + y, ) .into(); output }, ) .register( - "element_sum", - |_self: Val| { - let output: u64 = bevy::math::U64Vec4::element_sum( + "with_z", + |_self: Val, z: u64| { + let output: Val = bevy::math::U64Vec3::with_z( _self.into_inner(), + z, ) .into(); output }, ) .register( - "element_product", - |_self: Val| { - let output: u64 = bevy::math::U64Vec4::element_product( + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec3::wrapping_add( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "cmpeq", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec4::cmpeq( + "wrapping_add_signed", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec3::wrapping_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -9951,9 +9598,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cmpne", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec4::cmpne( + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec3::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -9962,9 +9609,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cmpge", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec4::cmpge( + "wrapping_mul", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec3::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -9973,52 +9620,51 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cmpgt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec4::cmpgt( + "wrapping_sub", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec3::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::U64Vec4>::new(world) .register( - "cmple", + "add", |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec4::cmple( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "cmplt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec4::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) + "add", + |_self: Val, rhs: u64| { + let output: Val = >::add(_self.into_inner(), rhs) .into(); output }, ) .register( - "length_squared", - |_self: Val| { - let output: u64 = bevy::math::U64Vec4::length_squared( - _self.into_inner(), - ) + "add", + |_self: Val, rhs: Ref| { + let output: Val = >::add(_self.into_inner(), &rhs) .into(); output }, ) .register( - "as_vec4", + "as_dvec4", |_self: Ref| { - let output: Val = bevy::math::U64Vec4::as_vec4( + let output: Val = bevy::math::U64Vec4::as_dvec4( &_self, ) .into(); @@ -10026,9 +9672,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "as_dvec4", + "as_i64vec4", |_self: Ref| { - let output: Val = bevy::math::U64Vec4::as_dvec4( + let output: Val = bevy::math::U64Vec4::as_i64vec4( &_self, ) .into(); @@ -10056,9 +9702,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "as_i64vec4", + "as_vec4", |_self: Ref| { - let output: Val = bevy::math::U64Vec4::as_i64vec4( + let output: Val = bevy::math::U64Vec4::as_vec4( &_self, ) .into(); @@ -10066,42 +9712,45 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_add", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec4::wrapping_add( - _self.into_inner(), - rhs.into_inner(), + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( + &_self, ) .into(); output }, ) .register( - "wrapping_sub", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec4::wrapping_sub( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = bevy::math::U64Vec4::clamp( _self.into_inner(), - rhs.into_inner(), + min.into_inner(), + max.into_inner(), ) .into(); output }, ) .register( - "wrapping_mul", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec4::wrapping_mul( - _self.into_inner(), - rhs.into_inner(), + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, ) .into(); output }, ) .register( - "wrapping_div", + "cmpeq", |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec4::wrapping_div( + let output: Val = bevy::math::U64Vec4::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -10110,9 +9759,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_add", + "cmpge", |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec4::saturating_add( + let output: Val = bevy::math::U64Vec4::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -10121,9 +9770,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_sub", + "cmpgt", |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec4::saturating_sub( + let output: Val = bevy::math::U64Vec4::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -10132,9 +9781,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_mul", + "cmple", |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec4::saturating_mul( + let output: Val = bevy::math::U64Vec4::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -10143,9 +9792,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_div", + "cmplt", |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec4::saturating_div( + let output: Val = bevy::math::U64Vec4::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -10154,9 +9803,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "wrapping_add_signed", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec4::wrapping_add_signed( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec4::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -10165,259 +9814,273 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "saturating_add_signed", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::U64Vec4::saturating_add_signed( - _self.into_inner(), - rhs.into_inner(), - ) + "div", + |_self: Val, rhs: Ref| { + let output: Val = >::div(_self.into_inner(), &rhs) .into(); output }, ) .register( - "sub", + "div", |_self: Val, rhs: Val| { - let output: Val = = >::sub(_self.into_inner(), rhs.into_inner()) + >>::div(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) + "div", + |_self: Val, rhs: u64| { + let output: Val = >::div(_self.into_inner(), rhs) .into(); output }, ) .register( - "div", + "dot", |_self: Val, rhs: Val| { - let output: Val = >::div(_self.into_inner(), rhs.into_inner()) + let output: u64 = bevy::math::U64Vec4::dot( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: u64| { - let output: Val = >::rem(_self.into_inner(), rhs) + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec4::dot_into_vec( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: u64| { - let output: Val = >::div(_self.into_inner(), rhs) + "element_product", + |_self: Val| { + let output: u64 = bevy::math::U64Vec4::element_product( + _self.into_inner(), + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: u64| { - let output: Val = >::mul(_self.into_inner(), rhs) + "element_sum", + |_self: Val| { + let output: u64 = bevy::math::U64Vec4::element_sum( + _self.into_inner(), + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Ref| { - let output: Val = >::mul(_self.into_inner(), &rhs) + "eq", + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Ref| { - let output: Val = >::rem(_self.into_inner(), &rhs) + "from_array", + |a: [u64; 4]| { + let output: Val = bevy::math::U64Vec4::from_array( + a, + ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::Vec2>::new(world) + ) .register( - "mul", - |_self: Val, rhs: f32| { - let output: Val = >::mul(_self.into_inner(), rhs) + "length_squared", + |_self: Val| { + let output: u64 = bevy::math::U64Vec4::length_squared( + _self.into_inner(), + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: Val| { - let output: Val = >::div(_self.into_inner(), rhs.into_inner()) + "max", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec4::max( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: Ref| { - let output: Val = >::div(_self.into_inner(), &rhs) + "max_element", + |_self: Val| { + let output: u64 = bevy::math::U64Vec4::max_element( + _self.into_inner(), + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + "min", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec4::min( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Ref| { - let output: Val = >::sub(_self.into_inner(), &rhs) + "min_element", + |_self: Val| { + let output: u64 = bevy::math::U64Vec4::min_element( + _self.into_inner(), + ) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( "mul", - |_self: Val, rhs: Ref| { - let output: Val = >::mul(_self.into_inner(), &rhs) + |_self: Val, rhs: u64| { + let output: Val = >::mul(_self.into_inner(), rhs) .into(); output }, ) .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) + "mul", + |_self: Val, rhs: Ref| { + let output: Val = >::mul(_self.into_inner(), &rhs) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Ref| { - let output: Val = >::rem(_self.into_inner(), &rhs) + "new", + |x: u64, y: u64, z: u64, w: u64| { + let output: Val = bevy::math::U64Vec4::new( + x, + y, + z, + w, + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Ref| { - let output: Val = >::add(_self.into_inner(), &rhs) + "rem", + |_self: Val, rhs: Val| { + let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "div", - |_self: Val, rhs: f32| { - let output: Val = >::div(_self.into_inner(), rhs) + "rem", + |_self: Val, rhs: u64| { + let output: Val = >::rem(_self.into_inner(), rhs) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: f32| { - let output: Val = >::sub(_self.into_inner(), rhs) + "rem", + |_self: Val, rhs: Ref| { + let output: Val = >::rem(_self.into_inner(), &rhs) .into(); output }, ) .register( - "neg", - |_self: Val| { - let output: Val = ::neg( + "saturating_add", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec4::saturating_add( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: f32| { - let output: Val = >::add(_self.into_inner(), rhs) + "saturating_add_signed", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec4::saturating_add_signed( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: f32| { - let output: Val = >::rem(_self.into_inner(), rhs) + "saturating_div", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec4::saturating_div( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "new", - |x: f32, y: f32| { - let output: Val = bevy::math::Vec2::new(x, y) + "saturating_mul", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec4::saturating_mul( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "splat", - |v: f32| { - let output: Val = bevy::math::Vec2::splat(v) + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec4::saturating_sub( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, @@ -10425,11 +10088,11 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { .register( "select", | - mask: Val, - if_true: Val, - if_false: Val| + mask: Val, + if_true: Val, + if_false: Val| { - let output: Val = bevy::math::Vec2::select( + let output: Val = bevy::math::U64Vec4::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -10439,151 +10102,130 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_array", - |a: [f32; 2]| { - let output: Val = bevy::math::Vec2::from_array(a) + "splat", + |v: u64| { + let output: Val = bevy::math::U64Vec4::splat(v) .into(); output }, ) .register( - "to_array", - |_self: Ref| { - let output: [f32; 2] = bevy::math::Vec2::to_array(&_self).into(); + "sub", + |_self: Val, rhs: u64| { + let output: Val = >::sub(_self.into_inner(), rhs) + .into(); output }, ) .register( - "extend", - |_self: Val, z: f32| { - let output: Val = bevy::math::Vec2::extend( - _self.into_inner(), - z, - ) + "sub", + |_self: Val, rhs: Ref| { + let output: Val = >::sub(_self.into_inner(), &rhs) .into(); output }, ) .register( - "with_x", - |_self: Val, x: f32| { - let output: Val = bevy::math::Vec2::with_x( - _self.into_inner(), - x, - ) + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "with_y", - |_self: Val, y: f32| { - let output: Val = bevy::math::Vec2::with_y( - _self.into_inner(), - y, - ) - .into(); + "to_array", + |_self: Ref| { + let output: [u64; 4] = bevy::math::U64Vec4::to_array(&_self).into(); output }, ) .register( - "dot", - |_self: Val, rhs: Val| { - let output: f32 = bevy::math::Vec2::dot( + "truncate", + |_self: Val| { + let output: Val = bevy::math::U64Vec4::truncate( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "dot_into_vec", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec2::dot_into_vec( + "with_w", + |_self: Val, w: u64| { + let output: Val = bevy::math::U64Vec4::with_w( _self.into_inner(), - rhs.into_inner(), + w, ) .into(); output }, ) .register( - "min", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec2::min( + "with_x", + |_self: Val, x: u64| { + let output: Val = bevy::math::U64Vec4::with_x( _self.into_inner(), - rhs.into_inner(), + x, ) .into(); output }, ) .register( - "max", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec2::max( + "with_y", + |_self: Val, y: u64| { + let output: Val = bevy::math::U64Vec4::with_y( _self.into_inner(), - rhs.into_inner(), + y, ) .into(); output }, ) .register( - "clamp", - | - _self: Val, - min: Val, - max: Val| - { - let output: Val = bevy::math::Vec2::clamp( + "with_z", + |_self: Val, z: u64| { + let output: Val = bevy::math::U64Vec4::with_z( _self.into_inner(), - min.into_inner(), - max.into_inner(), + z, ) .into(); output }, ) .register( - "min_element", - |_self: Val| { - let output: f32 = bevy::math::Vec2::min_element(_self.into_inner()) - .into(); - output - }, - ) - .register( - "max_element", - |_self: Val| { - let output: f32 = bevy::math::Vec2::max_element(_self.into_inner()) - .into(); - output - }, - ) - .register( - "element_sum", - |_self: Val| { - let output: f32 = bevy::math::Vec2::element_sum(_self.into_inner()) + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec4::wrapping_add( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "element_product", - |_self: Val| { - let output: f32 = bevy::math::Vec2::element_product( + "wrapping_add_signed", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec4::wrapping_add_signed( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "cmpeq", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec2::cmpeq( + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec4::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -10592,9 +10234,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cmpne", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec2::cmpne( + "wrapping_mul", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec4::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -10603,73 +10245,77 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cmpge", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec2::cmpge( + "wrapping_sub", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::U64Vec4::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::Vec2>::new(world) .register( - "cmpgt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec2::cmpgt( + "abs", + |_self: Val| { + let output: Val = bevy::math::Vec2::abs( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "cmple", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec2::cmple( + "abs_diff_eq", + | + _self: Val, + rhs: Val, + max_abs_diff: f32| + { + let output: bool = bevy::math::Vec2::abs_diff_eq( _self.into_inner(), rhs.into_inner(), + max_abs_diff, ) .into(); output }, ) .register( - "cmplt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec2::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) + "add", + |_self: Val, rhs: Ref| { + let output: Val = >::add(_self.into_inner(), &rhs) .into(); output }, ) .register( - "abs", - |_self: Val| { - let output: Val = bevy::math::Vec2::abs( - _self.into_inner(), - ) + "add", + |_self: Val, rhs: f32| { + let output: Val = >::add(_self.into_inner(), rhs) .into(); output }, ) .register( - "signum", - |_self: Val| { - let output: Val = bevy::math::Vec2::signum( - _self.into_inner(), - ) + "add", + |_self: Val, rhs: Val| { + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "copysign", + "angle_between", |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec2::copysign( + let output: f32 = bevy::math::Vec2::angle_between( _self.into_inner(), rhs.into_inner(), ) @@ -10678,63 +10324,70 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "is_negative_bitmask", - |_self: Val| { - let output: u32 = bevy::math::Vec2::is_negative_bitmask( + "angle_to", + |_self: Val, rhs: Val| { + let output: f32 = bevy::math::Vec2::angle_to( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "is_finite", - |_self: Val| { - let output: bool = bevy::math::Vec2::is_finite(_self.into_inner()) + "as_dvec2", + |_self: Ref| { + let output: Val = bevy::math::Vec2::as_dvec2( + &_self, + ) .into(); output }, ) .register( - "is_finite_mask", - |_self: Val| { - let output: Val = bevy::math::Vec2::is_finite_mask( - _self.into_inner(), + "as_i64vec2", + |_self: Ref| { + let output: Val = bevy::math::Vec2::as_i64vec2( + &_self, ) .into(); output }, ) .register( - "is_nan", - |_self: Val| { - let output: bool = bevy::math::Vec2::is_nan(_self.into_inner()) + "as_ivec2", + |_self: Ref| { + let output: Val = bevy::math::Vec2::as_ivec2( + &_self, + ) .into(); output }, ) .register( - "is_nan_mask", - |_self: Val| { - let output: Val = bevy::math::Vec2::is_nan_mask( - _self.into_inner(), + "as_u64vec2", + |_self: Ref| { + let output: Val = bevy::math::Vec2::as_u64vec2( + &_self, ) .into(); output }, ) .register( - "length", - |_self: Val| { - let output: f32 = bevy::math::Vec2::length(_self.into_inner()) + "as_uvec2", + |_self: Ref| { + let output: Val = bevy::math::Vec2::as_uvec2( + &_self, + ) .into(); output }, ) .register( - "length_squared", + "ceil", |_self: Val| { - let output: f32 = bevy::math::Vec2::length_squared( + let output: Val = bevy::math::Vec2::ceil( _self.into_inner(), ) .into(); @@ -10742,50 +10395,69 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "length_recip", - |_self: Val| { - let output: f32 = bevy::math::Vec2::length_recip(_self.into_inner()) + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = bevy::math::Vec2::clamp( + _self.into_inner(), + min.into_inner(), + max.into_inner(), + ) .into(); output }, ) .register( - "distance", - |_self: Val, rhs: Val| { - let output: f32 = bevy::math::Vec2::distance( + "clamp_length", + |_self: Val, min: f32, max: f32| { + let output: Val = bevy::math::Vec2::clamp_length( _self.into_inner(), - rhs.into_inner(), + min, + max, ) .into(); output }, ) .register( - "distance_squared", - |_self: Val, rhs: Val| { - let output: f32 = bevy::math::Vec2::distance_squared( + "clamp_length_max", + |_self: Val, max: f32| { + let output: Val = bevy::math::Vec2::clamp_length_max( _self.into_inner(), - rhs.into_inner(), + max, ) .into(); output }, ) .register( - "div_euclid", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec2::div_euclid( + "clamp_length_min", + |_self: Val, min: f32| { + let output: Val = bevy::math::Vec2::clamp_length_min( _self.into_inner(), - rhs.into_inner(), + min, ) .into(); output }, ) .register( - "rem_euclid", + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) + .into(); + output + }, + ) + .register( + "cmpeq", |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec2::rem_euclid( + let output: Val = bevy::math::Vec2::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -10794,50 +10466,53 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "normalize", - |_self: Val| { - let output: Val = bevy::math::Vec2::normalize( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec2::cmpge( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "normalize_or", - |_self: Val, fallback: Val| { - let output: Val = bevy::math::Vec2::normalize_or( + "cmpgt", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec2::cmpgt( _self.into_inner(), - fallback.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "normalize_or_zero", - |_self: Val| { - let output: Val = bevy::math::Vec2::normalize_or_zero( + "cmple", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec2::cmple( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "is_normalized", - |_self: Val| { - let output: bool = bevy::math::Vec2::is_normalized( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec2::cmplt( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "project_onto", + "cmpne", |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec2::project_onto( + let output: Val = bevy::math::Vec2::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -10846,9 +10521,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "reject_from", + "copysign", |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec2::reject_from( + let output: Val = bevy::math::Vec2::copysign( _self.into_inner(), rhs.into_inner(), ) @@ -10857,9 +10532,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "project_onto_normalized", + "distance", |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec2::project_onto_normalized( + let output: f32 = bevy::math::Vec2::distance( _self.into_inner(), rhs.into_inner(), ) @@ -10868,9 +10543,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "reject_from_normalized", + "distance_squared", |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec2::reject_from_normalized( + let output: f32 = bevy::math::Vec2::distance_squared( _self.into_inner(), rhs.into_inner(), ) @@ -10879,69 +10554,72 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "round", - |_self: Val| { - let output: Val = bevy::math::Vec2::round( - _self.into_inner(), - ) + "div", + |_self: Val, rhs: Val| { + let output: Val = >::div(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "floor", - |_self: Val| { - let output: Val = bevy::math::Vec2::floor( - _self.into_inner(), - ) + "div", + |_self: Val, rhs: Ref| { + let output: Val = >::div(_self.into_inner(), &rhs) .into(); output }, ) .register( - "ceil", - |_self: Val| { - let output: Val = bevy::math::Vec2::ceil( - _self.into_inner(), - ) + "div", + |_self: Val, rhs: f32| { + let output: Val = >::div(_self.into_inner(), rhs) .into(); output }, ) .register( - "trunc", - |_self: Val| { - let output: Val = bevy::math::Vec2::trunc( + "div_euclid", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec2::div_euclid( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "fract", - |_self: Val| { - let output: Val = bevy::math::Vec2::fract( + "dot", + |_self: Val, rhs: Val| { + let output: f32 = bevy::math::Vec2::dot( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "fract_gl", - |_self: Val| { - let output: Val = bevy::math::Vec2::fract_gl( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec2::dot_into_vec( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "exp", + "element_product", |_self: Val| { - let output: Val = bevy::math::Vec2::exp( + let output: f32 = bevy::math::Vec2::element_product( _self.into_inner(), ) .into(); @@ -10949,283 +10627,242 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "powf", - |_self: Val, n: f32| { - let output: Val = bevy::math::Vec2::powf( - _self.into_inner(), - n, - ) + "element_sum", + |_self: Val| { + let output: f32 = bevy::math::Vec2::element_sum(_self.into_inner()) .into(); output }, ) .register( - "recip", - |_self: Val| { - let output: Val = bevy::math::Vec2::recip( - _self.into_inner(), - ) + "eq", + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "lerp", - |_self: Val, rhs: Val, s: f32| { - let output: Val = bevy::math::Vec2::lerp( + "exp", + |_self: Val| { + let output: Val = bevy::math::Vec2::exp( _self.into_inner(), - rhs.into_inner(), - s, ) .into(); output }, ) .register( - "move_towards", - |_self: Ref, rhs: Val, d: f32| { - let output: Val = bevy::math::Vec2::move_towards( - &_self, - rhs.into_inner(), - d, + "extend", + |_self: Val, z: f32| { + let output: Val = bevy::math::Vec2::extend( + _self.into_inner(), + z, ) .into(); output }, ) .register( - "midpoint", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec2::midpoint( + "floor", + |_self: Val| { + let output: Val = bevy::math::Vec2::floor( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "abs_diff_eq", - | - _self: Val, - rhs: Val, - max_abs_diff: f32| - { - let output: bool = bevy::math::Vec2::abs_diff_eq( + "fract", + |_self: Val| { + let output: Val = bevy::math::Vec2::fract( _self.into_inner(), - rhs.into_inner(), - max_abs_diff, ) .into(); output }, ) .register( - "clamp_length", - |_self: Val, min: f32, max: f32| { - let output: Val = bevy::math::Vec2::clamp_length( + "fract_gl", + |_self: Val| { + let output: Val = bevy::math::Vec2::fract_gl( _self.into_inner(), - min, - max, ) .into(); output }, ) .register( - "clamp_length_max", - |_self: Val, max: f32| { - let output: Val = bevy::math::Vec2::clamp_length_max( - _self.into_inner(), - max, + "from_angle", + |angle: f32| { + let output: Val = bevy::math::Vec2::from_angle( + angle, ) .into(); output }, ) .register( - "clamp_length_min", - |_self: Val, min: f32| { - let output: Val = bevy::math::Vec2::clamp_length_min( - _self.into_inner(), - min, - ) + "from_array", + |a: [f32; 2]| { + let output: Val = bevy::math::Vec2::from_array(a) .into(); output }, ) .register( - "mul_add", - | - _self: Val, - a: Val, - b: Val| - { - let output: Val = bevy::math::Vec2::mul_add( - _self.into_inner(), - a.into_inner(), - b.into_inner(), - ) + "is_finite", + |_self: Val| { + let output: bool = bevy::math::Vec2::is_finite(_self.into_inner()) .into(); output }, ) .register( - "reflect", - |_self: Val, normal: Val| { - let output: Val = bevy::math::Vec2::reflect( + "is_finite_mask", + |_self: Val| { + let output: Val = bevy::math::Vec2::is_finite_mask( _self.into_inner(), - normal.into_inner(), ) .into(); output }, ) .register( - "refract", - |_self: Val, normal: Val, eta: f32| { - let output: Val = bevy::math::Vec2::refract( - _self.into_inner(), - normal.into_inner(), - eta, - ) + "is_nan", + |_self: Val| { + let output: bool = bevy::math::Vec2::is_nan(_self.into_inner()) .into(); output }, ) .register( - "from_angle", - |angle: f32| { - let output: Val = bevy::math::Vec2::from_angle( - angle, + "is_nan_mask", + |_self: Val| { + let output: Val = bevy::math::Vec2::is_nan_mask( + _self.into_inner(), ) .into(); output }, ) .register( - "to_angle", + "is_negative_bitmask", |_self: Val| { - let output: f32 = bevy::math::Vec2::to_angle(_self.into_inner()) + let output: u32 = bevy::math::Vec2::is_negative_bitmask( + _self.into_inner(), + ) .into(); output }, ) .register( - "angle_between", - |_self: Val, rhs: Val| { - let output: f32 = bevy::math::Vec2::angle_between( + "is_normalized", + |_self: Val| { + let output: bool = bevy::math::Vec2::is_normalized( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "angle_to", - |_self: Val, rhs: Val| { - let output: f32 = bevy::math::Vec2::angle_to( - _self.into_inner(), - rhs.into_inner(), - ) + "length", + |_self: Val| { + let output: f32 = bevy::math::Vec2::length(_self.into_inner()) .into(); output }, ) .register( - "perp", + "length_recip", |_self: Val| { - let output: Val = bevy::math::Vec2::perp( - _self.into_inner(), - ) + let output: f32 = bevy::math::Vec2::length_recip(_self.into_inner()) .into(); output }, ) .register( - "perp_dot", - |_self: Val, rhs: Val| { - let output: f32 = bevy::math::Vec2::perp_dot( + "length_squared", + |_self: Val| { + let output: f32 = bevy::math::Vec2::length_squared( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "rotate", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec2::rotate( + "lerp", + |_self: Val, rhs: Val, s: f32| { + let output: Val = bevy::math::Vec2::lerp( _self.into_inner(), rhs.into_inner(), + s, ) .into(); output }, ) .register( - "rotate_towards", - | - _self: Ref, - rhs: Val, - max_angle: f32| - { - let output: Val = bevy::math::Vec2::rotate_towards( - &_self, + "max", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec2::max( + _self.into_inner(), rhs.into_inner(), - max_angle, ) .into(); output }, ) .register( - "as_dvec2", - |_self: Ref| { - let output: Val = bevy::math::Vec2::as_dvec2( - &_self, - ) + "max_element", + |_self: Val| { + let output: f32 = bevy::math::Vec2::max_element(_self.into_inner()) .into(); output }, ) .register( - "as_ivec2", - |_self: Ref| { - let output: Val = bevy::math::Vec2::as_ivec2( - &_self, + "midpoint", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec2::midpoint( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "as_uvec2", - |_self: Ref| { - let output: Val = bevy::math::Vec2::as_uvec2( - &_self, + "min", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec2::min( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "as_i64vec2", - |_self: Ref| { - let output: Val = bevy::math::Vec2::as_i64vec2( - &_self, - ) + "min_element", + |_self: Val| { + let output: f32 = bevy::math::Vec2::min_element(_self.into_inner()) .into(); output }, ) .register( - "as_u64vec2", - |_self: Ref| { - let output: Val = bevy::math::Vec2::as_u64vec2( + "move_towards", + |_self: Ref, rhs: Val, d: f32| { + let output: Val = bevy::math::Vec2::move_towards( &_self, + rhs.into_inner(), + d, ) .into(); output @@ -11233,193 +10870,190 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { ) .register( "mul", - |_self: Val, rhs: Val| { + |_self: Val, rhs: f32| { let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + f32, + >>::mul(_self.into_inner(), rhs) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Val| { - let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) + "mul", + |_self: Val, rhs: Ref| { + let output: Val = >::mul(_self.into_inner(), &rhs) .into(); output }, ) .register( - "add", + "mul", |_self: Val, rhs: Val| { - let output: Val = = >::add(_self.into_inner(), rhs.into_inner()) + >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::Vec3A>::new(world) + ) .register( - "mul", - |_self: Val, rhs: f32| { - let output: Val = >::mul(_self.into_inner(), rhs) + "mul_add", + | + _self: Val, + a: Val, + b: Val| + { + let output: Val = bevy::math::Vec2::mul_add( + _self.into_inner(), + a.into_inner(), + b.into_inner(), + ) .into(); output }, ) .register( - "new", - |x: f32, y: f32, z: f32| { - let output: Val = bevy::math::Vec3A::new(x, y, z) + "neg", + |_self: Val| { + let output: Val = ::neg( + _self.into_inner(), + ) .into(); output }, ) .register( - "splat", - |v: f32| { - let output: Val = bevy::math::Vec3A::splat(v) + "new", + |x: f32, y: f32| { + let output: Val = bevy::math::Vec2::new(x, y) .into(); output }, ) .register( - "select", - | - mask: Val, - if_true: Val, - if_false: Val| - { - let output: Val = bevy::math::Vec3A::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), + "normalize", + |_self: Val| { + let output: Val = bevy::math::Vec2::normalize( + _self.into_inner(), ) .into(); output }, ) .register( - "from_array", - |a: [f32; 3]| { - let output: Val = bevy::math::Vec3A::from_array(a) + "normalize_or", + |_self: Val, fallback: Val| { + let output: Val = bevy::math::Vec2::normalize_or( + _self.into_inner(), + fallback.into_inner(), + ) .into(); output }, ) .register( - "to_array", - |_self: Ref| { - let output: [f32; 3] = bevy::math::Vec3A::to_array(&_self).into(); + "normalize_or_zero", + |_self: Val| { + let output: Val = bevy::math::Vec2::normalize_or_zero( + _self.into_inner(), + ) + .into(); output }, ) .register( - "from_vec4", - |v: Val| { - let output: Val = bevy::math::Vec3A::from_vec4( - v.into_inner(), + "perp", + |_self: Val| { + let output: Val = bevy::math::Vec2::perp( + _self.into_inner(), ) .into(); output }, ) .register( - "extend", - |_self: Val, w: f32| { - let output: Val = bevy::math::Vec3A::extend( + "perp_dot", + |_self: Val, rhs: Val| { + let output: f32 = bevy::math::Vec2::perp_dot( _self.into_inner(), - w, + rhs.into_inner(), ) .into(); output }, ) .register( - "truncate", - |_self: Val| { - let output: Val = bevy::math::Vec3A::truncate( + "powf", + |_self: Val, n: f32| { + let output: Val = bevy::math::Vec2::powf( _self.into_inner(), + n, ) .into(); output }, ) .register( - "with_x", - |_self: Val, x: f32| { - let output: Val = bevy::math::Vec3A::with_x( + "project_onto", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec2::project_onto( _self.into_inner(), - x, + rhs.into_inner(), ) .into(); output }, ) .register( - "with_y", - |_self: Val, y: f32| { - let output: Val = bevy::math::Vec3A::with_y( + "project_onto_normalized", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec2::project_onto_normalized( _self.into_inner(), - y, + rhs.into_inner(), ) .into(); output }, ) .register( - "with_z", - |_self: Val, z: f32| { - let output: Val = bevy::math::Vec3A::with_z( + "recip", + |_self: Val| { + let output: Val = bevy::math::Vec2::recip( _self.into_inner(), - z, ) .into(); output }, ) .register( - "dot", - |_self: Val, rhs: Val| { - let output: f32 = bevy::math::Vec3A::dot( + "reflect", + |_self: Val, normal: Val| { + let output: Val = bevy::math::Vec2::reflect( _self.into_inner(), - rhs.into_inner(), + normal.into_inner(), ) .into(); output }, ) .register( - "dot_into_vec", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3A::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); - output - }, - ) - .register( - "cross", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3A::cross( + "refract", + |_self: Val, normal: Val, eta: f32| { + let output: Val = bevy::math::Vec2::refract( _self.into_inner(), - rhs.into_inner(), + normal.into_inner(), + eta, ) .into(); output }, ) .register( - "min", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3A::min( + "reject_from", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec2::reject_from( _self.into_inner(), rhs.into_inner(), ) @@ -11428,9 +11062,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "max", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3A::max( + "reject_from_normalized", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec2::reject_from_normalized( _self.into_inner(), rhs.into_inner(), ) @@ -11439,59 +11073,50 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "clamp", - | - _self: Val, - min: Val, - max: Val| - { - let output: Val = bevy::math::Vec3A::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) - .into(); - output - }, - ) - .register( - "min_element", - |_self: Val| { - let output: f32 = bevy::math::Vec3A::min_element(_self.into_inner()) + "rem", + |_self: Val, rhs: Ref| { + let output: Val = >::rem(_self.into_inner(), &rhs) .into(); output }, ) .register( - "max_element", - |_self: Val| { - let output: f32 = bevy::math::Vec3A::max_element(_self.into_inner()) + "rem", + |_self: Val, rhs: f32| { + let output: Val = >::rem(_self.into_inner(), rhs) .into(); output }, ) .register( - "element_sum", - |_self: Val| { - let output: f32 = bevy::math::Vec3A::element_sum(_self.into_inner()) + "rem", + |_self: Val, rhs: Val| { + let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "element_product", - |_self: Val| { - let output: f32 = bevy::math::Vec3A::element_product( + "rem_euclid", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec2::rem_euclid( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "cmpeq", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3A::cmpeq( + "rotate", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec2::rotate( _self.into_inner(), rhs.into_inner(), ) @@ -11500,113 +11125,114 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cmpne", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3A::cmpne( - _self.into_inner(), + "rotate_towards", + | + _self: Ref, + rhs: Val, + max_angle: f32| + { + let output: Val = bevy::math::Vec2::rotate_towards( + &_self, rhs.into_inner(), + max_angle, ) .into(); output }, ) .register( - "cmpge", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3A::cmpge( + "round", + |_self: Val| { + let output: Val = bevy::math::Vec2::round( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "cmpgt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3A::cmpgt( - _self.into_inner(), - rhs.into_inner(), + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = bevy::math::Vec2::select( + mask.into_inner(), + if_true.into_inner(), + if_false.into_inner(), ) .into(); output }, ) .register( - "cmple", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3A::cmple( + "signum", + |_self: Val| { + let output: Val = bevy::math::Vec2::signum( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "cmplt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3A::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) + "splat", + |v: f32| { + let output: Val = bevy::math::Vec2::splat(v) .into(); output }, ) .register( - "abs", - |_self: Val| { - let output: Val = bevy::math::Vec3A::abs( - _self.into_inner(), - ) + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "signum", - |_self: Val| { - let output: Val = bevy::math::Vec3A::signum( - _self.into_inner(), - ) + "sub", + |_self: Val, rhs: Ref| { + let output: Val = >::sub(_self.into_inner(), &rhs) .into(); output }, ) .register( - "copysign", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3A::copysign( - _self.into_inner(), - rhs.into_inner(), - ) + "sub", + |_self: Val, rhs: f32| { + let output: Val = >::sub(_self.into_inner(), rhs) .into(); output }, ) .register( - "is_negative_bitmask", - |_self: Val| { - let output: u32 = bevy::math::Vec3A::is_negative_bitmask( - _self.into_inner(), - ) + "to_angle", + |_self: Val| { + let output: f32 = bevy::math::Vec2::to_angle(_self.into_inner()) .into(); output }, ) .register( - "is_finite", - |_self: Val| { - let output: bool = bevy::math::Vec3A::is_finite(_self.into_inner()) - .into(); + "to_array", + |_self: Ref| { + let output: [f32; 2] = bevy::math::Vec2::to_array(&_self).into(); output }, ) .register( - "is_finite_mask", - |_self: Val| { - let output: Val = bevy::math::Vec3A::is_finite_mask( + "trunc", + |_self: Val| { + let output: Val = bevy::math::Vec2::trunc( _self.into_inner(), ) .into(); @@ -11614,64 +11240,88 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "is_nan", - |_self: Val| { - let output: bool = bevy::math::Vec3A::is_nan(_self.into_inner()) + "with_x", + |_self: Val, x: f32| { + let output: Val = bevy::math::Vec2::with_x( + _self.into_inner(), + x, + ) .into(); output }, ) .register( - "is_nan_mask", - |_self: Val| { - let output: Val = bevy::math::Vec3A::is_nan_mask( + "with_y", + |_self: Val, y: f32| { + let output: Val = bevy::math::Vec2::with_y( _self.into_inner(), + y, ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::Vec3A>::new(world) .register( - "length", + "abs", |_self: Val| { - let output: f32 = bevy::math::Vec3A::length(_self.into_inner()) + let output: Val = bevy::math::Vec3A::abs( + _self.into_inner(), + ) .into(); output }, ) .register( - "length_squared", - |_self: Val| { - let output: f32 = bevy::math::Vec3A::length_squared( + "abs_diff_eq", + | + _self: Val, + rhs: Val, + max_abs_diff: f32| + { + let output: bool = bevy::math::Vec3A::abs_diff_eq( _self.into_inner(), + rhs.into_inner(), + max_abs_diff, ) .into(); output }, ) .register( - "length_recip", - |_self: Val| { - let output: f32 = bevy::math::Vec3A::length_recip(_self.into_inner()) + "add", + |_self: Val, rhs: Ref| { + let output: Val = >::add(_self.into_inner(), &rhs) .into(); output }, ) .register( - "distance", + "add", + |_self: Val, rhs: f32| { + let output: Val = >::add(_self.into_inner(), rhs) + .into(); + output + }, + ) + .register( + "add", |_self: Val, rhs: Val| { - let output: f32 = bevy::math::Vec3A::distance( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "distance_squared", + "angle_between", |_self: Val, rhs: Val| { - let output: f32 = bevy::math::Vec3A::distance_squared( + let output: f32 = bevy::math::Vec3A::angle_between( _self.into_inner(), rhs.into_inner(), ) @@ -11680,231 +11330,237 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "div_euclid", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3A::div_euclid( - _self.into_inner(), - rhs.into_inner(), + "any_orthogonal_vector", + |_self: Ref| { + let output: Val = bevy::math::Vec3A::any_orthogonal_vector( + &_self, ) .into(); output }, ) .register( - "rem_euclid", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3A::rem_euclid( - _self.into_inner(), - rhs.into_inner(), + "any_orthonormal_vector", + |_self: Ref| { + let output: Val = bevy::math::Vec3A::any_orthonormal_vector( + &_self, ) .into(); output }, ) .register( - "normalize", - |_self: Val| { - let output: Val = bevy::math::Vec3A::normalize( - _self.into_inner(), + "as_dvec3", + |_self: Ref| { + let output: Val = bevy::math::Vec3A::as_dvec3( + &_self, ) .into(); output }, ) .register( - "normalize_or", - |_self: Val, fallback: Val| { - let output: Val = bevy::math::Vec3A::normalize_or( - _self.into_inner(), - fallback.into_inner(), + "as_i64vec3", + |_self: Ref| { + let output: Val = bevy::math::Vec3A::as_i64vec3( + &_self, ) .into(); output }, ) .register( - "normalize_or_zero", - |_self: Val| { - let output: Val = bevy::math::Vec3A::normalize_or_zero( - _self.into_inner(), + "as_ivec3", + |_self: Ref| { + let output: Val = bevy::math::Vec3A::as_ivec3( + &_self, ) .into(); output }, ) .register( - "is_normalized", - |_self: Val| { - let output: bool = bevy::math::Vec3A::is_normalized( - _self.into_inner(), + "as_u64vec3", + |_self: Ref| { + let output: Val = bevy::math::Vec3A::as_u64vec3( + &_self, ) .into(); output }, ) .register( - "project_onto", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3A::project_onto( - _self.into_inner(), - rhs.into_inner(), + "as_uvec3", + |_self: Ref| { + let output: Val = bevy::math::Vec3A::as_uvec3( + &_self, ) .into(); output }, ) .register( - "reject_from", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3A::reject_from( + "ceil", + |_self: Val| { + let output: Val = bevy::math::Vec3A::ceil( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "project_onto_normalized", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3A::project_onto_normalized( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = bevy::math::Vec3A::clamp( _self.into_inner(), - rhs.into_inner(), + min.into_inner(), + max.into_inner(), ) .into(); output }, ) .register( - "reject_from_normalized", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3A::reject_from_normalized( + "clamp_length", + |_self: Val, min: f32, max: f32| { + let output: Val = bevy::math::Vec3A::clamp_length( _self.into_inner(), - rhs.into_inner(), + min, + max, ) .into(); output }, ) .register( - "round", - |_self: Val| { - let output: Val = bevy::math::Vec3A::round( + "clamp_length_max", + |_self: Val, max: f32| { + let output: Val = bevy::math::Vec3A::clamp_length_max( _self.into_inner(), + max, ) .into(); output }, ) .register( - "floor", - |_self: Val| { - let output: Val = bevy::math::Vec3A::floor( + "clamp_length_min", + |_self: Val, min: f32| { + let output: Val = bevy::math::Vec3A::clamp_length_min( _self.into_inner(), + min, ) .into(); output }, ) .register( - "ceil", - |_self: Val| { - let output: Val = bevy::math::Vec3A::ceil( - _self.into_inner(), + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, ) .into(); output }, ) .register( - "trunc", - |_self: Val| { - let output: Val = bevy::math::Vec3A::trunc( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3A::cmpeq( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "fract", - |_self: Val| { - let output: Val = bevy::math::Vec3A::fract( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3A::cmpge( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "fract_gl", - |_self: Val| { - let output: Val = bevy::math::Vec3A::fract_gl( + "cmpgt", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3A::cmpgt( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "exp", - |_self: Val| { - let output: Val = bevy::math::Vec3A::exp( + "cmple", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3A::cmple( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "powf", - |_self: Val, n: f32| { - let output: Val = bevy::math::Vec3A::powf( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3A::cmplt( _self.into_inner(), - n, + rhs.into_inner(), ) .into(); output }, ) .register( - "recip", - |_self: Val| { - let output: Val = bevy::math::Vec3A::recip( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3A::cmpne( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "lerp", - |_self: Val, rhs: Val, s: f32| { - let output: Val = bevy::math::Vec3A::lerp( + "copysign", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3A::copysign( _self.into_inner(), rhs.into_inner(), - s, ) .into(); output }, ) .register( - "move_towards", - |_self: Ref, rhs: Val, d: f32| { - let output: Val = bevy::math::Vec3A::move_towards( - &_self, + "cross", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3A::cross( + _self.into_inner(), rhs.into_inner(), - d, ) .into(); output }, ) .register( - "midpoint", + "distance", |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec3A::midpoint( + let output: f32 = bevy::math::Vec3A::distance( _self.into_inner(), rhs.into_inner(), ) @@ -11913,223 +11569,206 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "abs_diff_eq", - | - _self: Val, - rhs: Val, - max_abs_diff: f32| - { - let output: bool = bevy::math::Vec3A::abs_diff_eq( + "distance_squared", + |_self: Val, rhs: Val| { + let output: f32 = bevy::math::Vec3A::distance_squared( _self.into_inner(), rhs.into_inner(), - max_abs_diff, ) .into(); output }, ) .register( - "clamp_length", - |_self: Val, min: f32, max: f32| { - let output: Val = bevy::math::Vec3A::clamp_length( - _self.into_inner(), - min, - max, - ) + "div", + |_self: Val, rhs: Val| { + let output: Val = >::div(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "clamp_length_max", - |_self: Val, max: f32| { - let output: Val = bevy::math::Vec3A::clamp_length_max( - _self.into_inner(), - max, - ) + "div", + |_self: Val, rhs: f32| { + let output: Val = >::div(_self.into_inner(), rhs) .into(); output }, ) .register( - "clamp_length_min", - |_self: Val, min: f32| { - let output: Val = bevy::math::Vec3A::clamp_length_min( - _self.into_inner(), - min, - ) + "div", + |_self: Val, rhs: Ref| { + let output: Val = >::div(_self.into_inner(), &rhs) .into(); output }, ) .register( - "mul_add", - | - _self: Val, - a: Val, - b: Val| - { - let output: Val = bevy::math::Vec3A::mul_add( + "div_euclid", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3A::div_euclid( _self.into_inner(), - a.into_inner(), - b.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "reflect", - |_self: Val, normal: Val| { - let output: Val = bevy::math::Vec3A::reflect( + "dot", + |_self: Val, rhs: Val| { + let output: f32 = bevy::math::Vec3A::dot( _self.into_inner(), - normal.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "refract", - | - _self: Val, - normal: Val, - eta: f32| - { - let output: Val = bevy::math::Vec3A::refract( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3A::dot_into_vec( _self.into_inner(), - normal.into_inner(), - eta, + rhs.into_inner(), ) .into(); output }, ) .register( - "angle_between", - |_self: Val, rhs: Val| { - let output: f32 = bevy::math::Vec3A::angle_between( + "element_product", + |_self: Val| { + let output: f32 = bevy::math::Vec3A::element_product( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "any_orthogonal_vector", - |_self: Ref| { - let output: Val = bevy::math::Vec3A::any_orthogonal_vector( - &_self, - ) + "element_sum", + |_self: Val| { + let output: f32 = bevy::math::Vec3A::element_sum(_self.into_inner()) .into(); output }, ) .register( - "any_orthonormal_vector", - |_self: Ref| { - let output: Val = bevy::math::Vec3A::any_orthonormal_vector( - &_self, - ) + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = >::eq(&_self, &rhs) .into(); output }, ) .register( - "as_dvec3", - |_self: Ref| { - let output: Val = bevy::math::Vec3A::as_dvec3( - &_self, + "exp", + |_self: Val| { + let output: Val = bevy::math::Vec3A::exp( + _self.into_inner(), ) .into(); output }, ) .register( - "as_ivec3", - |_self: Ref| { - let output: Val = bevy::math::Vec3A::as_ivec3( - &_self, + "extend", + |_self: Val, w: f32| { + let output: Val = bevy::math::Vec3A::extend( + _self.into_inner(), + w, ) .into(); output }, ) .register( - "as_uvec3", - |_self: Ref| { - let output: Val = bevy::math::Vec3A::as_uvec3( - &_self, + "floor", + |_self: Val| { + let output: Val = bevy::math::Vec3A::floor( + _self.into_inner(), ) .into(); output }, ) .register( - "as_i64vec3", - |_self: Ref| { - let output: Val = bevy::math::Vec3A::as_i64vec3( - &_self, + "fract", + |_self: Val| { + let output: Val = bevy::math::Vec3A::fract( + _self.into_inner(), ) .into(); output }, ) .register( - "as_u64vec3", - |_self: Ref| { - let output: Val = bevy::math::Vec3A::as_u64vec3( - &_self, + "fract_gl", + |_self: Val| { + let output: Val = bevy::math::Vec3A::fract_gl( + _self.into_inner(), ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: Val| { - let output: Val = >::div(_self.into_inner(), rhs.into_inner()) + "from_array", + |a: [f32; 3]| { + let output: Val = bevy::math::Vec3A::from_array(a) .into(); output }, ) .register( - "div", - |_self: Val, rhs: f32| { - let output: Val = >::div(_self.into_inner(), rhs) + "from_vec4", + |v: Val| { + let output: Val = bevy::math::Vec3A::from_vec4( + v.into_inner(), + ) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: f32| { - let output: Val = >::rem(_self.into_inner(), rhs) + "is_finite", + |_self: Val| { + let output: bool = bevy::math::Vec3A::is_finite(_self.into_inner()) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "is_finite_mask", + |_self: Val| { + let output: Val = bevy::math::Vec3A::is_finite_mask( + _self.into_inner(), + ) .into(); output }, ) .register( - "neg", + "is_nan", |_self: Val| { - let output: Val = ::neg( + let output: bool = bevy::math::Vec3A::is_nan(_self.into_inner()) + .into(); + output + }, + ) + .register( + "is_nan_mask", + |_self: Val| { + let output: Val = bevy::math::Vec3A::is_nan_mask( _self.into_inner(), ) .into(); @@ -12137,475 +11776,491 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "eq", - |_self: Ref, rhs: Ref| { - let output: bool = >::eq(&_self, &rhs) + "is_negative_bitmask", + |_self: Val| { + let output: u32 = bevy::math::Vec3A::is_negative_bitmask( + _self.into_inner(), + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: f32| { - let output: Val = >::sub(_self.into_inner(), rhs) + "is_normalized", + |_self: Val| { + let output: bool = bevy::math::Vec3A::is_normalized( + _self.into_inner(), + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Ref| { - let output: Val = >::add(_self.into_inner(), &rhs) + "length", + |_self: Val| { + let output: f32 = bevy::math::Vec3A::length(_self.into_inner()) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Ref| { - let output: Val = >::rem(_self.into_inner(), &rhs) + "length_recip", + |_self: Val| { + let output: f32 = bevy::math::Vec3A::length_recip(_self.into_inner()) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, + "length_squared", + |_self: Val| { + let output: f32 = bevy::math::Vec3A::length_squared( + _self.into_inner(), ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: f32| { - let output: Val = >::add(_self.into_inner(), rhs) + "lerp", + |_self: Val, rhs: Val, s: f32| { + let output: Val = bevy::math::Vec3A::lerp( + _self.into_inner(), + rhs.into_inner(), + s, + ) .into(); output }, ) .register( - "rem", + "max", |_self: Val, rhs: Val| { - let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) + let output: Val = bevy::math::Vec3A::max( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + "max_element", + |_self: Val| { + let output: f32 = bevy::math::Vec3A::max_element(_self.into_inner()) .into(); output }, ) .register( - "add", + "midpoint", |_self: Val, rhs: Val| { - let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + let output: Val = bevy::math::Vec3A::midpoint( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Ref| { - let output: Val = >::mul(_self.into_inner(), &rhs) + "min", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3A::min( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: Ref| { - let output: Val = >::div(_self.into_inner(), &rhs) + "min_element", + |_self: Val| { + let output: f32 = bevy::math::Vec3A::min_element(_self.into_inner()) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Ref| { - let output: Val = >::sub(_self.into_inner(), &rhs) + "move_towards", + |_self: Ref, rhs: Val, d: f32| { + let output: Val = bevy::math::Vec3A::move_towards( + &_self, + rhs.into_inner(), + d, + ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::Vec4>::new(world) + ) .register( - "rem", - |_self: Val, rhs: f32| { - let output: Val = , rhs: f32| { + let output: Val = >::rem(_self.into_inner(), rhs) + >>::mul(_self.into_inner(), rhs) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "div", - |_self: Val, rhs: Ref| { - let output: Val = >::div(_self.into_inner(), &rhs) + "mul", + |_self: Val, rhs: Ref| { + let output: Val = >::mul(_self.into_inner(), &rhs) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Ref| { - let output: Val = >::add(_self.into_inner(), &rhs) + "mul_add", + | + _self: Val, + a: Val, + b: Val| + { + let output: Val = bevy::math::Vec3A::mul_add( + _self.into_inner(), + a.into_inner(), + b.into_inner(), + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: f32| { - let output: Val = >::mul(_self.into_inner(), rhs) + "neg", + |_self: Val| { + let output: Val = ::neg( + _self.into_inner(), + ) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Ref| { - let output: Val = >::rem(_self.into_inner(), &rhs) + "new", + |x: f32, y: f32, z: f32| { + let output: Val = bevy::math::Vec3A::new(x, y, z) .into(); output }, ) .register( - "eq", - |_self: Ref, rhs: Ref| { - let output: bool = >::eq(&_self, &rhs) + "normalize", + |_self: Val| { + let output: Val = bevy::math::Vec3A::normalize( + _self.into_inner(), + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Val| { - let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + "normalize_or", + |_self: Val, fallback: Val| { + let output: Val = bevy::math::Vec3A::normalize_or( + _self.into_inner(), + fallback.into_inner(), + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: f32| { - let output: Val = >::sub(_self.into_inner(), rhs) + "normalize_or_zero", + |_self: Val| { + let output: Val = bevy::math::Vec3A::normalize_or_zero( + _self.into_inner(), + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "powf", + |_self: Val, n: f32| { + let output: Val = bevy::math::Vec3A::powf( + _self.into_inner(), + n, + ) .into(); output }, ) .register( - "neg", - |_self: Val| { - let output: Val = ::neg( + "project_onto", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3A::project_onto( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Ref| { - let output: Val = >::sub(_self.into_inner(), &rhs) + "project_onto_normalized", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3A::project_onto_normalized( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, + "recip", + |_self: Val| { + let output: Val = bevy::math::Vec3A::recip( + _self.into_inner(), ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Ref| { - let output: Val = >::mul(_self.into_inner(), &rhs) + "reflect", + |_self: Val, normal: Val| { + let output: Val = bevy::math::Vec3A::reflect( + _self.into_inner(), + normal.into_inner(), + ) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Val| { - let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) + "refract", + | + _self: Val, + normal: Val, + eta: f32| + { + let output: Val = bevy::math::Vec3A::refract( + _self.into_inner(), + normal.into_inner(), + eta, + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: Val| { - let output: Val = >::div(_self.into_inner(), rhs.into_inner()) + "reject_from", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3A::reject_from( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "new", - |x: f32, y: f32, z: f32, w: f32| { - let output: Val = bevy::math::Vec4::new(x, y, z, w) + "reject_from_normalized", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3A::reject_from_normalized( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "splat", - |v: f32| { - let output: Val = bevy::math::Vec4::splat(v) + "rem", + |_self: Val, rhs: f32| { + let output: Val = >::rem(_self.into_inner(), rhs) .into(); output }, ) .register( - "select", - | - mask: Val, - if_true: Val, - if_false: Val| - { - let output: Val = bevy::math::Vec4::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), - ) + "rem", + |_self: Val, rhs: Ref| { + let output: Val = >::rem(_self.into_inner(), &rhs) .into(); output }, ) .register( - "from_array", - |a: [f32; 4]| { - let output: Val = bevy::math::Vec4::from_array(a) + "rem", + |_self: Val, rhs: Val| { + let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "to_array", - |_self: Ref| { - let output: [f32; 4] = bevy::math::Vec4::to_array(&_self).into(); - output - }, - ) - .register( - "truncate", - |_self: Val| { - let output: Val = bevy::math::Vec4::truncate( + "rem_euclid", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec3A::rem_euclid( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "with_x", - |_self: Val, x: f32| { - let output: Val = bevy::math::Vec4::with_x( + "round", + |_self: Val| { + let output: Val = bevy::math::Vec3A::round( _self.into_inner(), - x, ) .into(); output }, ) .register( - "with_y", - |_self: Val, y: f32| { - let output: Val = bevy::math::Vec4::with_y( - _self.into_inner(), - y, + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = bevy::math::Vec3A::select( + mask.into_inner(), + if_true.into_inner(), + if_false.into_inner(), ) .into(); output }, ) .register( - "with_z", - |_self: Val, z: f32| { - let output: Val = bevy::math::Vec4::with_z( + "signum", + |_self: Val| { + let output: Val = bevy::math::Vec3A::signum( _self.into_inner(), - z, ) .into(); output }, ) .register( - "with_w", - |_self: Val, w: f32| { - let output: Val = bevy::math::Vec4::with_w( - _self.into_inner(), - w, - ) + "splat", + |v: f32| { + let output: Val = bevy::math::Vec3A::splat(v) .into(); output }, ) .register( - "dot", - |_self: Val, rhs: Val| { - let output: f32 = bevy::math::Vec4::dot( - _self.into_inner(), - rhs.into_inner(), - ) + "sub", + |_self: Val, rhs: f32| { + let output: Val = >::sub(_self.into_inner(), rhs) .into(); output }, ) .register( - "dot_into_vec", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec4::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), - ) + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "min", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec4::min( - _self.into_inner(), - rhs.into_inner(), - ) + "sub", + |_self: Val, rhs: Ref| { + let output: Val = >::sub(_self.into_inner(), &rhs) .into(); output }, ) .register( - "max", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec4::max( + "to_array", + |_self: Ref| { + let output: [f32; 3] = bevy::math::Vec3A::to_array(&_self).into(); + output + }, + ) + .register( + "trunc", + |_self: Val| { + let output: Val = bevy::math::Vec3A::trunc( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "clamp", - | - _self: Val, - min: Val, - max: Val| - { - let output: Val = bevy::math::Vec4::clamp( + "truncate", + |_self: Val| { + let output: Val = bevy::math::Vec3A::truncate( _self.into_inner(), - min.into_inner(), - max.into_inner(), ) .into(); output }, ) .register( - "min_element", - |_self: Val| { - let output: f32 = bevy::math::Vec4::min_element(_self.into_inner()) + "with_x", + |_self: Val, x: f32| { + let output: Val = bevy::math::Vec3A::with_x( + _self.into_inner(), + x, + ) .into(); output }, ) .register( - "max_element", - |_self: Val| { - let output: f32 = bevy::math::Vec4::max_element(_self.into_inner()) + "with_y", + |_self: Val, y: f32| { + let output: Val = bevy::math::Vec3A::with_y( + _self.into_inner(), + y, + ) .into(); output }, ) .register( - "element_sum", - |_self: Val| { - let output: f32 = bevy::math::Vec4::element_sum(_self.into_inner()) + "with_z", + |_self: Val, z: f32| { + let output: Val = bevy::math::Vec3A::with_z( + _self.into_inner(), + z, + ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::Vec4>::new(world) .register( - "element_product", + "abs", |_self: Val| { - let output: f32 = bevy::math::Vec4::element_product( + let output: Val = bevy::math::Vec4::abs( _self.into_inner(), ) .into(); @@ -12613,106 +12268,105 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cmpeq", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec4::cmpeq( + "abs_diff_eq", + | + _self: Val, + rhs: Val, + max_abs_diff: f32| + { + let output: bool = bevy::math::Vec4::abs_diff_eq( _self.into_inner(), rhs.into_inner(), + max_abs_diff, ) .into(); output }, ) .register( - "cmpne", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec4::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) + "add", + |_self: Val, rhs: Ref| { + let output: Val = >::add(_self.into_inner(), &rhs) .into(); output }, ) .register( - "cmpge", + "add", |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec4::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "cmpgt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec4::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) + "add", + |_self: Val, rhs: f32| { + let output: Val = >::add(_self.into_inner(), rhs) .into(); output }, ) .register( - "cmple", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec4::cmple( - _self.into_inner(), - rhs.into_inner(), + "as_dvec4", + |_self: Ref| { + let output: Val = bevy::math::Vec4::as_dvec4( + &_self, ) .into(); output }, ) .register( - "cmplt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec4::cmplt( - _self.into_inner(), - rhs.into_inner(), + "as_i64vec4", + |_self: Ref| { + let output: Val = bevy::math::Vec4::as_i64vec4( + &_self, ) .into(); output }, ) .register( - "abs", - |_self: Val| { - let output: Val = bevy::math::Vec4::abs( - _self.into_inner(), + "as_ivec4", + |_self: Ref| { + let output: Val = bevy::math::Vec4::as_ivec4( + &_self, ) .into(); output }, ) .register( - "signum", - |_self: Val| { - let output: Val = bevy::math::Vec4::signum( - _self.into_inner(), + "as_u64vec4", + |_self: Ref| { + let output: Val = bevy::math::Vec4::as_u64vec4( + &_self, ) .into(); output }, ) .register( - "copysign", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec4::copysign( - _self.into_inner(), - rhs.into_inner(), + "as_uvec4", + |_self: Ref| { + let output: Val = bevy::math::Vec4::as_uvec4( + &_self, ) .into(); output }, ) .register( - "is_negative_bitmask", + "ceil", |_self: Val| { - let output: u32 = bevy::math::Vec4::is_negative_bitmask( + let output: Val = bevy::math::Vec4::ceil( _self.into_inner(), ) .into(); @@ -12720,71 +12374,91 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "is_finite", - |_self: Val| { - let output: bool = bevy::math::Vec4::is_finite(_self.into_inner()) + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = bevy::math::Vec4::clamp( + _self.into_inner(), + min.into_inner(), + max.into_inner(), + ) .into(); output }, ) .register( - "is_finite_mask", - |_self: Val| { - let output: Val = bevy::math::Vec4::is_finite_mask( + "clamp_length", + |_self: Val, min: f32, max: f32| { + let output: Val = bevy::math::Vec4::clamp_length( _self.into_inner(), + min, + max, ) .into(); output }, ) .register( - "is_nan", - |_self: Val| { - let output: bool = bevy::math::Vec4::is_nan(_self.into_inner()) + "clamp_length_max", + |_self: Val, max: f32| { + let output: Val = bevy::math::Vec4::clamp_length_max( + _self.into_inner(), + max, + ) .into(); output }, ) .register( - "is_nan_mask", - |_self: Val| { - let output: Val = bevy::math::Vec4::is_nan_mask( + "clamp_length_min", + |_self: Val, min: f32| { + let output: Val = bevy::math::Vec4::clamp_length_min( _self.into_inner(), + min, ) .into(); output }, ) .register( - "length", - |_self: Val| { - let output: f32 = bevy::math::Vec4::length(_self.into_inner()) + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) .into(); output }, ) .register( - "length_squared", - |_self: Val| { - let output: f32 = bevy::math::Vec4::length_squared( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec4::cmpeq( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "length_recip", - |_self: Val| { - let output: f32 = bevy::math::Vec4::length_recip(_self.into_inner()) + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec4::cmpge( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "distance", + "cmpgt", |_self: Val, rhs: Val| { - let output: f32 = bevy::math::Vec4::distance( + let output: Val = bevy::math::Vec4::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -12793,9 +12467,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "distance_squared", + "cmple", |_self: Val, rhs: Val| { - let output: f32 = bevy::math::Vec4::distance_squared( + let output: Val = bevy::math::Vec4::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -12804,9 +12478,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "div_euclid", + "cmplt", |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec4::div_euclid( + let output: Val = bevy::math::Vec4::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -12815,9 +12489,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "rem_euclid", + "cmpne", |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec4::rem_euclid( + let output: Val = bevy::math::Vec4::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -12826,61 +12500,72 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "normalize", - |_self: Val| { - let output: Val = bevy::math::Vec4::normalize( + "copysign", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec4::copysign( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "normalize_or", - |_self: Val, fallback: Val| { - let output: Val = bevy::math::Vec4::normalize_or( + "distance", + |_self: Val, rhs: Val| { + let output: f32 = bevy::math::Vec4::distance( _self.into_inner(), - fallback.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "normalize_or_zero", - |_self: Val| { - let output: Val = bevy::math::Vec4::normalize_or_zero( - _self.into_inner(), - ) + "distance_squared", + |_self: Val, rhs: Val| { + let output: f32 = bevy::math::Vec4::distance_squared( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "is_normalized", - |_self: Val| { - let output: bool = bevy::math::Vec4::is_normalized( - _self.into_inner(), - ) + "div", + |_self: Val, rhs: Ref| { + let output: Val = >::div(_self.into_inner(), &rhs) .into(); output }, ) .register( - "project_onto", + "div", |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec4::project_onto( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::div(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "reject_from", + "div", + |_self: Val, rhs: f32| { + let output: Val = >::div(_self.into_inner(), rhs) + .into(); + output + }, + ) + .register( + "div_euclid", |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec4::reject_from( + let output: Val = bevy::math::Vec4::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -12889,9 +12574,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "project_onto_normalized", + "dot", |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec4::project_onto_normalized( + let output: f32 = bevy::math::Vec4::dot( _self.into_inner(), rhs.into_inner(), ) @@ -12900,9 +12585,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "reject_from_normalized", + "dot_into_vec", |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec4::reject_from_normalized( + let output: Val = bevy::math::Vec4::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -12911,9 +12596,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "round", + "element_product", |_self: Val| { - let output: Val = bevy::math::Vec4::round( + let output: f32 = bevy::math::Vec4::element_product( _self.into_inner(), ) .into(); @@ -12921,29 +12606,27 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "floor", + "element_sum", |_self: Val| { - let output: Val = bevy::math::Vec4::floor( - _self.into_inner(), - ) + let output: f32 = bevy::math::Vec4::element_sum(_self.into_inner()) .into(); output }, ) .register( - "ceil", - |_self: Val| { - let output: Val = bevy::math::Vec4::ceil( - _self.into_inner(), - ) + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = >::eq(&_self, &rhs) .into(); output }, ) .register( - "trunc", + "exp", |_self: Val| { - let output: Val = bevy::math::Vec4::trunc( + let output: Val = bevy::math::Vec4::exp( _self.into_inner(), ) .into(); @@ -12951,9 +12634,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "fract", + "floor", |_self: Val| { - let output: Val = bevy::math::Vec4::fract( + let output: Val = bevy::math::Vec4::floor( _self.into_inner(), ) .into(); @@ -12961,9 +12644,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "fract_gl", + "fract", |_self: Val| { - let output: Val = bevy::math::Vec4::fract_gl( + let output: Val = bevy::math::Vec4::fract( _self.into_inner(), ) .into(); @@ -12971,9 +12654,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "exp", + "fract_gl", |_self: Val| { - let output: Val = bevy::math::Vec4::exp( + let output: Val = bevy::math::Vec4::fract_gl( _self.into_inner(), ) .into(); @@ -12981,800 +12664,823 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "powf", - |_self: Val, n: f32| { - let output: Val = bevy::math::Vec4::powf( - _self.into_inner(), - n, - ) + "from_array", + |a: [f32; 4]| { + let output: Val = bevy::math::Vec4::from_array(a) .into(); output }, ) .register( - "recip", + "is_finite", |_self: Val| { - let output: Val = bevy::math::Vec4::recip( - _self.into_inner(), - ) + let output: bool = bevy::math::Vec4::is_finite(_self.into_inner()) .into(); output }, ) .register( - "lerp", - |_self: Val, rhs: Val, s: f32| { - let output: Val = bevy::math::Vec4::lerp( + "is_finite_mask", + |_self: Val| { + let output: Val = bevy::math::Vec4::is_finite_mask( _self.into_inner(), - rhs.into_inner(), - s, ) .into(); output }, ) .register( - "move_towards", - |_self: Ref, rhs: Val, d: f32| { - let output: Val = bevy::math::Vec4::move_towards( - &_self, - rhs.into_inner(), - d, - ) + "is_nan", + |_self: Val| { + let output: bool = bevy::math::Vec4::is_nan(_self.into_inner()) .into(); output }, ) .register( - "midpoint", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::Vec4::midpoint( + "is_nan_mask", + |_self: Val| { + let output: Val = bevy::math::Vec4::is_nan_mask( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "abs_diff_eq", - | - _self: Val, - rhs: Val, - max_abs_diff: f32| - { - let output: bool = bevy::math::Vec4::abs_diff_eq( + "is_negative_bitmask", + |_self: Val| { + let output: u32 = bevy::math::Vec4::is_negative_bitmask( _self.into_inner(), - rhs.into_inner(), - max_abs_diff, ) .into(); output }, ) .register( - "clamp_length", - |_self: Val, min: f32, max: f32| { - let output: Val = bevy::math::Vec4::clamp_length( + "is_normalized", + |_self: Val| { + let output: bool = bevy::math::Vec4::is_normalized( _self.into_inner(), - min, - max, ) .into(); output }, ) .register( - "clamp_length_max", - |_self: Val, max: f32| { - let output: Val = bevy::math::Vec4::clamp_length_max( - _self.into_inner(), - max, - ) + "length", + |_self: Val| { + let output: f32 = bevy::math::Vec4::length(_self.into_inner()) .into(); output }, ) .register( - "clamp_length_min", - |_self: Val, min: f32| { - let output: Val = bevy::math::Vec4::clamp_length_min( - _self.into_inner(), - min, - ) + "length_recip", + |_self: Val| { + let output: f32 = bevy::math::Vec4::length_recip(_self.into_inner()) .into(); output }, ) .register( - "mul_add", - | - _self: Val, - a: Val, - b: Val| - { - let output: Val = bevy::math::Vec4::mul_add( + "length_squared", + |_self: Val| { + let output: f32 = bevy::math::Vec4::length_squared( _self.into_inner(), - a.into_inner(), - b.into_inner(), ) .into(); output }, ) .register( - "reflect", - |_self: Val, normal: Val| { - let output: Val = bevy::math::Vec4::reflect( + "lerp", + |_self: Val, rhs: Val, s: f32| { + let output: Val = bevy::math::Vec4::lerp( _self.into_inner(), - normal.into_inner(), + rhs.into_inner(), + s, ) .into(); output }, ) .register( - "refract", - |_self: Val, normal: Val, eta: f32| { - let output: Val = bevy::math::Vec4::refract( + "max", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec4::max( _self.into_inner(), - normal.into_inner(), - eta, + rhs.into_inner(), ) .into(); output }, ) .register( - "as_dvec4", - |_self: Ref| { - let output: Val = bevy::math::Vec4::as_dvec4( - &_self, - ) + "max_element", + |_self: Val| { + let output: f32 = bevy::math::Vec4::max_element(_self.into_inner()) .into(); output }, ) .register( - "as_ivec4", - |_self: Ref| { - let output: Val = bevy::math::Vec4::as_ivec4( - &_self, + "midpoint", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec4::midpoint( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "as_uvec4", - |_self: Ref| { - let output: Val = bevy::math::Vec4::as_uvec4( - &_self, + "min", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec4::min( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "as_i64vec4", - |_self: Ref| { - let output: Val = bevy::math::Vec4::as_i64vec4( - &_self, - ) + "min_element", + |_self: Val| { + let output: f32 = bevy::math::Vec4::min_element(_self.into_inner()) .into(); output }, ) .register( - "as_u64vec4", - |_self: Ref| { - let output: Val = bevy::math::Vec4::as_u64vec4( + "move_towards", + |_self: Ref, rhs: Val, d: f32| { + let output: Val = bevy::math::Vec4::move_towards( &_self, + rhs.into_inner(), + d, ) .into(); output }, ) .register( - "div", + "mul", |_self: Val, rhs: f32| { - let output: Val = = >::div(_self.into_inner(), rhs) + >>::mul(_self.into_inner(), rhs) .into(); output }, ) .register( - "add", - |_self: Val, rhs: f32| { - let output: Val = >::add(_self.into_inner(), rhs) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::BVec2>::new(world) + ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) + "mul", + |_self: Val, rhs: Ref| { + let output: Val = >::mul(_self.into_inner(), &rhs) .into(); output }, ) .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, + "mul_add", + | + _self: Val, + a: Val, + b: Val| + { + let output: Val = bevy::math::Vec4::mul_add( + _self.into_inner(), + a.into_inner(), + b.into_inner(), ) .into(); output }, ) .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) + "neg", + |_self: Val| { + let output: Val = ::neg( + _self.into_inner(), + ) .into(); output }, ) .register( "new", - |x: bool, y: bool| { - let output: Val = bevy::math::BVec2::new(x, y) + |x: f32, y: f32, z: f32, w: f32| { + let output: Val = bevy::math::Vec4::new(x, y, z, w) .into(); output }, ) .register( - "splat", - |v: bool| { - let output: Val = bevy::math::BVec2::splat(v) + "normalize", + |_self: Val| { + let output: Val = bevy::math::Vec4::normalize( + _self.into_inner(), + ) .into(); output }, ) .register( - "from_array", - |a: [bool; 2]| { - let output: Val = bevy::math::BVec2::from_array(a) + "normalize_or", + |_self: Val, fallback: Val| { + let output: Val = bevy::math::Vec4::normalize_or( + _self.into_inner(), + fallback.into_inner(), + ) .into(); output }, ) .register( - "bitmask", - |_self: Val| { - let output: u32 = bevy::math::BVec2::bitmask(_self.into_inner()) + "normalize_or_zero", + |_self: Val| { + let output: Val = bevy::math::Vec4::normalize_or_zero( + _self.into_inner(), + ) .into(); output }, ) .register( - "any", - |_self: Val| { - let output: bool = bevy::math::BVec2::any(_self.into_inner()).into(); + "powf", + |_self: Val, n: f32| { + let output: Val = bevy::math::Vec4::powf( + _self.into_inner(), + n, + ) + .into(); output }, ) .register( - "all", - |_self: Val| { - let output: bool = bevy::math::BVec2::all(_self.into_inner()).into(); + "project_onto", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec4::project_onto( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); output }, ) .register( - "test", - |_self: Ref, index: usize| { - let output: bool = bevy::math::BVec2::test(&_self, index).into(); + "project_onto_normalized", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec4::project_onto_normalized( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); output }, ) .register( - "set", - |mut _self: Mut, index: usize, value: bool| { - let output: () = bevy::math::BVec2::set(&mut _self, index, value) + "recip", + |_self: Val| { + let output: Val = bevy::math::Vec4::recip( + _self.into_inner(), + ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::BVec3>::new(world) + ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, + "reflect", + |_self: Val, normal: Val| { + let output: Val = bevy::math::Vec4::reflect( + _self.into_inner(), + normal.into_inner(), ) .into(); output }, ) .register( - "new", - |x: bool, y: bool, z: bool| { - let output: Val = bevy::math::BVec3::new(x, y, z) + "refract", + |_self: Val, normal: Val, eta: f32| { + let output: Val = bevy::math::Vec4::refract( + _self.into_inner(), + normal.into_inner(), + eta, + ) .into(); output }, ) .register( - "splat", - |v: bool| { - let output: Val = bevy::math::BVec3::splat(v) + "reject_from", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec4::reject_from( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "from_array", - |a: [bool; 3]| { - let output: Val = bevy::math::BVec3::from_array(a) + "reject_from_normalized", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec4::reject_from_normalized( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "bitmask", - |_self: Val| { - let output: u32 = bevy::math::BVec3::bitmask(_self.into_inner()) + "rem", + |_self: Val, rhs: f32| { + let output: Val = >::rem(_self.into_inner(), rhs) .into(); output }, ) .register( - "any", - |_self: Val| { - let output: bool = bevy::math::BVec3::any(_self.into_inner()).into(); + "rem", + |_self: Val, rhs: Ref| { + let output: Val = >::rem(_self.into_inner(), &rhs) + .into(); output }, ) .register( - "all", - |_self: Val| { - let output: bool = bevy::math::BVec3::all(_self.into_inner()).into(); + "rem", + |_self: Val, rhs: Val| { + let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) + .into(); output }, ) .register( - "test", - |_self: Ref, index: usize| { - let output: bool = bevy::math::BVec3::test(&_self, index).into(); + "rem_euclid", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::Vec4::rem_euclid( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); output }, ) .register( - "set", - |mut _self: Mut, index: usize, value: bool| { - let output: () = bevy::math::BVec3::set(&mut _self, index, value) + "round", + |_self: Val| { + let output: Val = bevy::math::Vec4::round( + _self.into_inner(), + ) .into(); output }, ) .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = bevy::math::Vec4::select( + mask.into_inner(), + if_true.into_inner(), + if_false.into_inner(), + ) .into(); output }, ) .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, + "signum", + |_self: Val| { + let output: Val = bevy::math::Vec4::signum( + _self.into_inner(), ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::BVec4>::new(world) + ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) + "splat", + |v: f32| { + let output: Val = bevy::math::Vec4::splat(v) .into(); output }, ) .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "new", - |x: bool, y: bool, z: bool, w: bool| { - let output: Val = bevy::math::BVec4::new( - x, - y, - z, - w, - ) + "sub", + |_self: Val, rhs: f32| { + let output: Val = >::sub(_self.into_inner(), rhs) .into(); output }, ) .register( - "splat", - |v: bool| { - let output: Val = bevy::math::BVec4::splat(v) + "sub", + |_self: Val, rhs: Ref| { + let output: Val = >::sub(_self.into_inner(), &rhs) .into(); output }, ) .register( - "from_array", - |a: [bool; 4]| { - let output: Val = bevy::math::BVec4::from_array(a) - .into(); + "to_array", + |_self: Ref| { + let output: [f32; 4] = bevy::math::Vec4::to_array(&_self).into(); output }, ) .register( - "bitmask", - |_self: Val| { - let output: u32 = bevy::math::BVec4::bitmask(_self.into_inner()) + "trunc", + |_self: Val| { + let output: Val = bevy::math::Vec4::trunc( + _self.into_inner(), + ) .into(); output }, ) .register( - "any", - |_self: Val| { - let output: bool = bevy::math::BVec4::any(_self.into_inner()).into(); + "truncate", + |_self: Val| { + let output: Val = bevy::math::Vec4::truncate( + _self.into_inner(), + ) + .into(); output }, ) .register( - "all", - |_self: Val| { - let output: bool = bevy::math::BVec4::all(_self.into_inner()).into(); + "with_w", + |_self: Val, w: f32| { + let output: Val = bevy::math::Vec4::with_w( + _self.into_inner(), + w, + ) + .into(); output }, ) .register( - "test", - |_self: Ref, index: usize| { - let output: bool = bevy::math::BVec4::test(&_self, index).into(); + "with_x", + |_self: Val, x: f32| { + let output: Val = bevy::math::Vec4::with_x( + _self.into_inner(), + x, + ) + .into(); output }, ) .register( - "set", - |mut _self: Mut, index: usize, value: bool| { - let output: () = bevy::math::BVec4::set(&mut _self, index, value) + "with_y", + |_self: Val, y: f32| { + let output: Val = bevy::math::Vec4::with_y( + _self.into_inner(), + y, + ) .into(); output }, ) .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, + "with_z", + |_self: Val, z: f32| { + let output: Val = bevy::math::Vec4::with_z( + _self.into_inner(), + z, ) .into(); output }, ); - NamespaceBuilder::<::bevy::math::DVec2>::new(world) + NamespaceBuilder::<::bevy::math::BVec2>::new(world) .register( - "rem", - |_self: Val, rhs: f64| { - let output: Val = >::rem(_self.into_inner(), rhs) - .into(); + "all", + |_self: Val| { + let output: bool = bevy::math::BVec2::all(_self.into_inner()).into(); output }, ) .register( - "div", - |_self: Val, rhs: Val| { - let output: Val = >::div(_self.into_inner(), rhs.into_inner()) - .into(); + "any", + |_self: Val| { + let output: bool = bevy::math::BVec2::any(_self.into_inner()).into(); output }, ) .register( - "add", - |_self: Val, rhs: Val| { - let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( + &_self, + ) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) + "bitmask", + |_self: Val| { + let output: u32 = bevy::math::BVec2::bitmask(_self.into_inner()) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Ref| { - let output: Val = >::rem(_self.into_inner(), &rhs) + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: f64| { - let output: Val = >::add(_self.into_inner(), rhs) + "eq", + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Ref| { - let output: Val = >::sub(_self.into_inner(), &rhs) + "from_array", + |a: [bool; 2]| { + let output: Val = bevy::math::BVec2::from_array(a) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + "new", + |x: bool, y: bool| { + let output: Val = bevy::math::BVec2::new(x, y) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "set", + |mut _self: Mut, index: usize, value: bool| { + let output: () = bevy::math::BVec2::set(&mut _self, index, value) .into(); output }, ) .register( - "neg", - |_self: Val| { - let output: Val = ::neg( - _self.into_inner(), - ) + "splat", + |v: bool| { + let output: Val = bevy::math::BVec2::splat(v) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Ref| { - let output: Val = >::add(_self.into_inner(), &rhs) - .into(); + "test", + |_self: Ref, index: usize| { + let output: bool = bevy::math::BVec2::test(&_self, index).into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::BVec3>::new(world) .register( - "div", - |_self: Val, rhs: Ref| { - let output: Val = >::div(_self.into_inner(), &rhs) - .into(); + "all", + |_self: Val| { + let output: bool = bevy::math::BVec3::all(_self.into_inner()).into(); output }, ) .register( - "mul", - |_self: Val, rhs: Ref| { - let output: Val = >::mul(_self.into_inner(), &rhs) - .into(); + "any", + |_self: Val| { + let output: bool = bevy::math::BVec3::any(_self.into_inner()).into(); output }, ) .register( - "new", - |x: f64, y: f64| { - let output: Val = bevy::math::DVec2::new(x, y) + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( + &_self, + ) .into(); output }, ) .register( - "splat", - |v: f64| { - let output: Val = bevy::math::DVec2::splat(v) + "bitmask", + |_self: Val| { + let output: u32 = bevy::math::BVec3::bitmask(_self.into_inner()) .into(); output }, ) .register( - "select", - | - mask: Val, - if_true: Val, - if_false: Val| - { - let output: Val = bevy::math::DVec2::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, ) .into(); output }, ) .register( - "from_array", - |a: [f64; 2]| { - let output: Val = bevy::math::DVec2::from_array(a) + "eq", + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "to_array", - |_self: Ref| { - let output: [f64; 2] = bevy::math::DVec2::to_array(&_self).into(); + "from_array", + |a: [bool; 3]| { + let output: Val = bevy::math::BVec3::from_array(a) + .into(); output }, ) .register( - "extend", - |_self: Val, z: f64| { - let output: Val = bevy::math::DVec2::extend( - _self.into_inner(), - z, - ) + "new", + |x: bool, y: bool, z: bool| { + let output: Val = bevy::math::BVec3::new(x, y, z) .into(); output }, ) .register( - "with_x", - |_self: Val, x: f64| { - let output: Val = bevy::math::DVec2::with_x( - _self.into_inner(), - x, - ) + "set", + |mut _self: Mut, index: usize, value: bool| { + let output: () = bevy::math::BVec3::set(&mut _self, index, value) .into(); output }, ) .register( - "with_y", - |_self: Val, y: f64| { - let output: Val = bevy::math::DVec2::with_y( - _self.into_inner(), - y, - ) + "splat", + |v: bool| { + let output: Val = bevy::math::BVec3::splat(v) .into(); output }, ) .register( - "dot", - |_self: Val, rhs: Val| { - let output: f64 = bevy::math::DVec2::dot( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); + "test", + |_self: Ref, index: usize| { + let output: bool = bevy::math::BVec3::test(&_self, index).into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::BVec4>::new(world) .register( - "dot_into_vec", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec2::dot_into_vec( - _self.into_inner(), - rhs.into_inner(), + "all", + |_self: Val| { + let output: bool = bevy::math::BVec4::all(_self.into_inner()).into(); + output + }, + ) + .register( + "any", + |_self: Val| { + let output: bool = bevy::math::BVec4::any(_self.into_inner()).into(); + output + }, + ) + .register( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( + &_self, ) .into(); output }, ) .register( - "min", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec2::min( - _self.into_inner(), - rhs.into_inner(), - ) + "bitmask", + |_self: Val| { + let output: u32 = bevy::math::BVec4::bitmask(_self.into_inner()) .into(); output }, ) .register( - "max", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec2::max( - _self.into_inner(), - rhs.into_inner(), + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, ) .into(); output }, ) .register( - "clamp", - | - _self: Val, - min: Val, - max: Val| - { - let output: Val = bevy::math::DVec2::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) + "eq", + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "min_element", - |_self: Val| { - let output: f64 = bevy::math::DVec2::min_element(_self.into_inner()) + "from_array", + |a: [bool; 4]| { + let output: Val = bevy::math::BVec4::from_array(a) .into(); output }, ) .register( - "max_element", - |_self: Val| { - let output: f64 = bevy::math::DVec2::max_element(_self.into_inner()) + "new", + |x: bool, y: bool, z: bool, w: bool| { + let output: Val = bevy::math::BVec4::new( + x, + y, + z, + w, + ) .into(); output }, ) .register( - "element_sum", - |_self: Val| { - let output: f64 = bevy::math::DVec2::element_sum(_self.into_inner()) + "set", + |mut _self: Mut, index: usize, value: bool| { + let output: () = bevy::math::BVec4::set(&mut _self, index, value) .into(); output }, ) .register( - "element_product", + "splat", + |v: bool| { + let output: Val = bevy::math::BVec4::splat(v) + .into(); + output + }, + ) + .register( + "test", + |_self: Ref, index: usize| { + let output: bool = bevy::math::BVec4::test(&_self, index).into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::DVec2>::new(world) + .register( + "abs", |_self: Val| { - let output: f64 = bevy::math::DVec2::element_product( + let output: Val = bevy::math::DVec2::abs( _self.into_inner(), ) .into(); @@ -13782,53 +13488,55 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cmpeq", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec2::cmpeq( + "abs_diff_eq", + | + _self: Val, + rhs: Val, + max_abs_diff: f64| + { + let output: bool = bevy::math::DVec2::abs_diff_eq( _self.into_inner(), rhs.into_inner(), + max_abs_diff, ) .into(); output }, ) .register( - "cmpne", + "add", |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec2::cmpne( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "cmpge", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec2::cmpge( - _self.into_inner(), - rhs.into_inner(), - ) + "add", + |_self: Val, rhs: f64| { + let output: Val = >::add(_self.into_inner(), rhs) .into(); output }, ) .register( - "cmpgt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec2::cmpgt( - _self.into_inner(), - rhs.into_inner(), - ) + "add", + |_self: Val, rhs: Ref| { + let output: Val = >::add(_self.into_inner(), &rhs) .into(); output }, ) .register( - "cmple", + "angle_between", |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec2::cmple( + let output: f64 = bevy::math::DVec2::angle_between( _self.into_inner(), rhs.into_inner(), ) @@ -13837,9 +13545,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "cmplt", + "angle_to", |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec2::cmplt( + let output: f64 = bevy::math::DVec2::angle_to( _self.into_inner(), rhs.into_inner(), ) @@ -13848,58 +13556,59 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "abs", - |_self: Val| { - let output: Val = bevy::math::DVec2::abs( - _self.into_inner(), + "as_i64vec2", + |_self: Ref| { + let output: Val = bevy::math::DVec2::as_i64vec2( + &_self, ) .into(); output }, ) .register( - "signum", - |_self: Val| { - let output: Val = bevy::math::DVec2::signum( - _self.into_inner(), + "as_ivec2", + |_self: Ref| { + let output: Val = bevy::math::DVec2::as_ivec2( + &_self, ) .into(); output }, ) .register( - "copysign", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec2::copysign( - _self.into_inner(), - rhs.into_inner(), + "as_u64vec2", + |_self: Ref| { + let output: Val = bevy::math::DVec2::as_u64vec2( + &_self, ) .into(); output }, ) .register( - "is_negative_bitmask", - |_self: Val| { - let output: u32 = bevy::math::DVec2::is_negative_bitmask( - _self.into_inner(), + "as_uvec2", + |_self: Ref| { + let output: Val = bevy::math::DVec2::as_uvec2( + &_self, ) .into(); output }, ) .register( - "is_finite", - |_self: Val| { - let output: bool = bevy::math::DVec2::is_finite(_self.into_inner()) + "as_vec2", + |_self: Ref| { + let output: Val = bevy::math::DVec2::as_vec2( + &_self, + ) .into(); output }, ) .register( - "is_finite_mask", + "ceil", |_self: Val| { - let output: Val = bevy::math::DVec2::is_finite_mask( + let output: Val = bevy::math::DVec2::ceil( _self.into_inner(), ) .into(); @@ -13907,53 +13616,69 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "is_nan", - |_self: Val| { - let output: bool = bevy::math::DVec2::is_nan(_self.into_inner()) + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = bevy::math::DVec2::clamp( + _self.into_inner(), + min.into_inner(), + max.into_inner(), + ) .into(); output }, ) .register( - "is_nan_mask", - |_self: Val| { - let output: Val = bevy::math::DVec2::is_nan_mask( + "clamp_length", + |_self: Val, min: f64, max: f64| { + let output: Val = bevy::math::DVec2::clamp_length( _self.into_inner(), + min, + max, ) .into(); output }, ) .register( - "length", - |_self: Val| { - let output: f64 = bevy::math::DVec2::length(_self.into_inner()) + "clamp_length_max", + |_self: Val, max: f64| { + let output: Val = bevy::math::DVec2::clamp_length_max( + _self.into_inner(), + max, + ) .into(); output }, ) .register( - "length_squared", - |_self: Val| { - let output: f64 = bevy::math::DVec2::length_squared( + "clamp_length_min", + |_self: Val, min: f64| { + let output: Val = bevy::math::DVec2::clamp_length_min( _self.into_inner(), + min, ) .into(); output }, ) .register( - "length_recip", - |_self: Val| { - let output: f64 = bevy::math::DVec2::length_recip(_self.into_inner()) + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) .into(); output }, ) .register( - "distance", + "cmpeq", |_self: Val, rhs: Val| { - let output: f64 = bevy::math::DVec2::distance( + let output: Val = bevy::math::DVec2::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -13962,9 +13687,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "distance_squared", + "cmpge", |_self: Val, rhs: Val| { - let output: f64 = bevy::math::DVec2::distance_squared( + let output: Val = bevy::math::DVec2::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -13973,9 +13698,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "div_euclid", + "cmpgt", |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec2::div_euclid( + let output: Val = bevy::math::DVec2::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -13984,9 +13709,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "rem_euclid", + "cmple", |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec2::rem_euclid( + let output: Val = bevy::math::DVec2::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -13995,50 +13720,53 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "normalize", - |_self: Val| { - let output: Val = bevy::math::DVec2::normalize( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec2::cmplt( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "normalize_or", - |_self: Val, fallback: Val| { - let output: Val = bevy::math::DVec2::normalize_or( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec2::cmpne( _self.into_inner(), - fallback.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "normalize_or_zero", - |_self: Val| { - let output: Val = bevy::math::DVec2::normalize_or_zero( + "copysign", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec2::copysign( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "is_normalized", - |_self: Val| { - let output: bool = bevy::math::DVec2::is_normalized( + "distance", + |_self: Val, rhs: Val| { + let output: f64 = bevy::math::DVec2::distance( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "project_onto", + "distance_squared", |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec2::project_onto( + let output: f64 = bevy::math::DVec2::distance_squared( _self.into_inner(), rhs.into_inner(), ) @@ -14047,9 +13775,39 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "reject_from", + "div", |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec2::reject_from( + let output: Val = >::div(_self.into_inner(), rhs.into_inner()) + .into(); + output + }, + ) + .register( + "div", + |_self: Val, rhs: Ref| { + let output: Val = >::div(_self.into_inner(), &rhs) + .into(); + output + }, + ) + .register( + "div", + |_self: Val, rhs: f64| { + let output: Val = >::div(_self.into_inner(), rhs) + .into(); + output + }, + ) + .register( + "div_euclid", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec2::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -14058,9 +13816,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "project_onto_normalized", + "dot", |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec2::project_onto_normalized( + let output: f64 = bevy::math::DVec2::dot( _self.into_inner(), rhs.into_inner(), ) @@ -14069,9 +13827,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "reject_from_normalized", + "dot_into_vec", |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec2::reject_from_normalized( + let output: Val = bevy::math::DVec2::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -14080,9 +13838,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "round", + "element_product", |_self: Val| { - let output: Val = bevy::math::DVec2::round( + let output: f64 = bevy::math::DVec2::element_product( _self.into_inner(), ) .into(); @@ -14090,9 +13848,27 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "floor", + "element_sum", |_self: Val| { - let output: Val = bevy::math::DVec2::floor( + let output: f64 = bevy::math::DVec2::element_sum(_self.into_inner()) + .into(); + output + }, + ) + .register( + "eq", + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) + .into(); + output + }, + ) + .register( + "exp", + |_self: Val| { + let output: Val = bevy::math::DVec2::exp( _self.into_inner(), ) .into(); @@ -14100,19 +13876,20 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "ceil", - |_self: Val| { - let output: Val = bevy::math::DVec2::ceil( + "extend", + |_self: Val, z: f64| { + let output: Val = bevy::math::DVec2::extend( _self.into_inner(), + z, ) .into(); output }, ) .register( - "trunc", + "floor", |_self: Val| { - let output: Val = bevy::math::DVec2::trunc( + let output: Val = bevy::math::DVec2::floor( _self.into_inner(), ) .into(); @@ -14140,186 +13917,140 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "exp", - |_self: Val| { - let output: Val = bevy::math::DVec2::exp( - _self.into_inner(), + "from_angle", + |angle: f64| { + let output: Val = bevy::math::DVec2::from_angle( + angle, ) .into(); output }, ) .register( - "powf", - |_self: Val, n: f64| { - let output: Val = bevy::math::DVec2::powf( - _self.into_inner(), - n, - ) + "from_array", + |a: [f64; 2]| { + let output: Val = bevy::math::DVec2::from_array(a) .into(); output }, ) .register( - "recip", + "is_finite", |_self: Val| { - let output: Val = bevy::math::DVec2::recip( - _self.into_inner(), - ) + let output: bool = bevy::math::DVec2::is_finite(_self.into_inner()) .into(); output }, ) .register( - "lerp", - |_self: Val, rhs: Val, s: f64| { - let output: Val = bevy::math::DVec2::lerp( + "is_finite_mask", + |_self: Val| { + let output: Val = bevy::math::DVec2::is_finite_mask( _self.into_inner(), - rhs.into_inner(), - s, ) .into(); output }, ) .register( - "move_towards", - |_self: Ref, rhs: Val, d: f64| { - let output: Val = bevy::math::DVec2::move_towards( - &_self, - rhs.into_inner(), - d, - ) + "is_nan", + |_self: Val| { + let output: bool = bevy::math::DVec2::is_nan(_self.into_inner()) .into(); output }, ) .register( - "midpoint", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec2::midpoint( + "is_nan_mask", + |_self: Val| { + let output: Val = bevy::math::DVec2::is_nan_mask( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "abs_diff_eq", - | - _self: Val, - rhs: Val, - max_abs_diff: f64| - { - let output: bool = bevy::math::DVec2::abs_diff_eq( + "is_negative_bitmask", + |_self: Val| { + let output: u32 = bevy::math::DVec2::is_negative_bitmask( _self.into_inner(), - rhs.into_inner(), - max_abs_diff, ) .into(); output }, ) .register( - "clamp_length", - |_self: Val, min: f64, max: f64| { - let output: Val = bevy::math::DVec2::clamp_length( + "is_normalized", + |_self: Val| { + let output: bool = bevy::math::DVec2::is_normalized( _self.into_inner(), - min, - max, ) .into(); output }, ) .register( - "clamp_length_max", - |_self: Val, max: f64| { - let output: Val = bevy::math::DVec2::clamp_length_max( - _self.into_inner(), - max, - ) + "length", + |_self: Val| { + let output: f64 = bevy::math::DVec2::length(_self.into_inner()) .into(); output }, ) .register( - "clamp_length_min", - |_self: Val, min: f64| { - let output: Val = bevy::math::DVec2::clamp_length_min( - _self.into_inner(), - min, - ) + "length_recip", + |_self: Val| { + let output: f64 = bevy::math::DVec2::length_recip(_self.into_inner()) .into(); output }, ) .register( - "mul_add", - | - _self: Val, - a: Val, - b: Val| - { - let output: Val = bevy::math::DVec2::mul_add( + "length_squared", + |_self: Val| { + let output: f64 = bevy::math::DVec2::length_squared( _self.into_inner(), - a.into_inner(), - b.into_inner(), ) .into(); output }, ) .register( - "reflect", - |_self: Val, normal: Val| { - let output: Val = bevy::math::DVec2::reflect( + "lerp", + |_self: Val, rhs: Val, s: f64| { + let output: Val = bevy::math::DVec2::lerp( _self.into_inner(), - normal.into_inner(), + rhs.into_inner(), + s, ) .into(); output }, ) .register( - "refract", - | - _self: Val, - normal: Val, - eta: f64| - { - let output: Val = bevy::math::DVec2::refract( + "max", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec2::max( _self.into_inner(), - normal.into_inner(), - eta, - ) - .into(); - output - }, - ) - .register( - "from_angle", - |angle: f64| { - let output: Val = bevy::math::DVec2::from_angle( - angle, + rhs.into_inner(), ) .into(); output }, ) .register( - "to_angle", + "max_element", |_self: Val| { - let output: f64 = bevy::math::DVec2::to_angle(_self.into_inner()) + let output: f64 = bevy::math::DVec2::max_element(_self.into_inner()) .into(); output }, ) .register( - "angle_between", + "midpoint", |_self: Val, rhs: Val| { - let output: f64 = bevy::math::DVec2::angle_between( + let output: Val = bevy::math::DVec2::midpoint( _self.into_inner(), rhs.into_inner(), ) @@ -14328,9 +14059,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "angle_to", + "min", |_self: Val, rhs: Val| { - let output: f64 = bevy::math::DVec2::angle_to( + let output: Val = bevy::math::DVec2::min( _self.into_inner(), rhs.into_inner(), ) @@ -14339,470 +14070,483 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "perp", + "min_element", |_self: Val| { - let output: Val = bevy::math::DVec2::perp( - _self.into_inner(), - ) + let output: f64 = bevy::math::DVec2::min_element(_self.into_inner()) .into(); output }, ) .register( - "perp_dot", - |_self: Val, rhs: Val| { - let output: f64 = bevy::math::DVec2::perp_dot( - _self.into_inner(), + "move_towards", + |_self: Ref, rhs: Val, d: f64| { + let output: Val = bevy::math::DVec2::move_towards( + &_self, rhs.into_inner(), + d, ) .into(); output }, ) .register( - "rotate", + "mul", |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec2::rotate( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "rotate_towards", - | - _self: Ref, - rhs: Val, - max_angle: f64| - { - let output: Val = bevy::math::DVec2::rotate_towards( - &_self, - rhs.into_inner(), - max_angle, - ) + "mul", + |_self: Val, rhs: Ref| { + let output: Val = >::mul(_self.into_inner(), &rhs) .into(); output }, ) .register( - "as_vec2", - |_self: Ref| { - let output: Val = bevy::math::DVec2::as_vec2( - &_self, - ) + "mul", + |_self: Val, rhs: f64| { + let output: Val = >::mul(_self.into_inner(), rhs) .into(); output }, ) .register( - "as_ivec2", - |_self: Ref| { - let output: Val = bevy::math::DVec2::as_ivec2( - &_self, + "mul_add", + | + _self: Val, + a: Val, + b: Val| + { + let output: Val = bevy::math::DVec2::mul_add( + _self.into_inner(), + a.into_inner(), + b.into_inner(), ) .into(); output }, ) .register( - "as_uvec2", - |_self: Ref| { - let output: Val = bevy::math::DVec2::as_uvec2( - &_self, + "neg", + |_self: Val| { + let output: Val = ::neg( + _self.into_inner(), ) .into(); output }, ) .register( - "as_i64vec2", - |_self: Ref| { - let output: Val = bevy::math::DVec2::as_i64vec2( - &_self, - ) + "new", + |x: f64, y: f64| { + let output: Val = bevy::math::DVec2::new(x, y) .into(); output }, ) .register( - "as_u64vec2", - |_self: Ref| { - let output: Val = bevy::math::DVec2::as_u64vec2( - &_self, + "normalize", + |_self: Val| { + let output: Val = bevy::math::DVec2::normalize( + _self.into_inner(), ) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Val| { - let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) + "normalize_or", + |_self: Val, fallback: Val| { + let output: Val = bevy::math::DVec2::normalize_or( + _self.into_inner(), + fallback.into_inner(), + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: f64| { - let output: Val = >::div(_self.into_inner(), rhs) + "normalize_or_zero", + |_self: Val| { + let output: Val = bevy::math::DVec2::normalize_or_zero( + _self.into_inner(), + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: f64| { - let output: Val = >::sub(_self.into_inner(), rhs) + "perp", + |_self: Val| { + let output: Val = bevy::math::DVec2::perp( + _self.into_inner(), + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: f64| { - let output: Val = >::mul(_self.into_inner(), rhs) + "perp_dot", + |_self: Val, rhs: Val| { + let output: f64 = bevy::math::DVec2::perp_dot( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) + "powf", + |_self: Val, n: f64| { + let output: Val = bevy::math::DVec2::powf( + _self.into_inner(), + n, + ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::DVec3>::new(world) + ) .register( - "neg", - |_self: Val| { - let output: Val = ::neg( + "project_onto", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec2::project_onto( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: Ref| { - let output: Val = >::div(_self.into_inner(), &rhs) + "project_onto_normalized", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec2::project_onto_normalized( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "new", - |x: f64, y: f64, z: f64| { - let output: Val = bevy::math::DVec3::new(x, y, z) + "recip", + |_self: Val| { + let output: Val = bevy::math::DVec2::recip( + _self.into_inner(), + ) .into(); output }, ) .register( - "splat", - |v: f64| { - let output: Val = bevy::math::DVec3::splat(v) + "reflect", + |_self: Val, normal: Val| { + let output: Val = bevy::math::DVec2::reflect( + _self.into_inner(), + normal.into_inner(), + ) .into(); output }, ) .register( - "select", + "refract", | - mask: Val, - if_true: Val, - if_false: Val| + _self: Val, + normal: Val, + eta: f64| { - let output: Val = bevy::math::DVec3::select( - mask.into_inner(), - if_true.into_inner(), - if_false.into_inner(), + let output: Val = bevy::math::DVec2::refract( + _self.into_inner(), + normal.into_inner(), + eta, ) .into(); output }, ) .register( - "from_array", - |a: [f64; 3]| { - let output: Val = bevy::math::DVec3::from_array(a) + "reject_from", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec2::reject_from( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "to_array", - |_self: Ref| { - let output: [f64; 3] = bevy::math::DVec3::to_array(&_self).into(); + "reject_from_normalized", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec2::reject_from_normalized( + _self.into_inner(), + rhs.into_inner(), + ) + .into(); output }, ) .register( - "extend", - |_self: Val, w: f64| { - let output: Val = bevy::math::DVec3::extend( - _self.into_inner(), - w, - ) + "rem", + |_self: Val, rhs: f64| { + let output: Val = >::rem(_self.into_inner(), rhs) .into(); output }, ) .register( - "truncate", - |_self: Val| { - let output: Val = bevy::math::DVec3::truncate( - _self.into_inner(), - ) + "rem", + |_self: Val, rhs: Ref| { + let output: Val = >::rem(_self.into_inner(), &rhs) .into(); output }, ) .register( - "with_x", - |_self: Val, x: f64| { - let output: Val = bevy::math::DVec3::with_x( - _self.into_inner(), - x, - ) + "rem", + |_self: Val, rhs: Val| { + let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "with_y", - |_self: Val, y: f64| { - let output: Val = bevy::math::DVec3::with_y( + "rem_euclid", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec2::rem_euclid( _self.into_inner(), - y, + rhs.into_inner(), ) .into(); output }, ) .register( - "with_z", - |_self: Val, z: f64| { - let output: Val = bevy::math::DVec3::with_z( + "rotate", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec2::rotate( _self.into_inner(), - z, + rhs.into_inner(), ) .into(); output }, ) .register( - "dot", - |_self: Val, rhs: Val| { - let output: f64 = bevy::math::DVec3::dot( - _self.into_inner(), + "rotate_towards", + | + _self: Ref, + rhs: Val, + max_angle: f64| + { + let output: Val = bevy::math::DVec2::rotate_towards( + &_self, rhs.into_inner(), + max_angle, ) .into(); output }, ) .register( - "dot_into_vec", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec3::dot_into_vec( + "round", + |_self: Val| { + let output: Val = bevy::math::DVec2::round( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "cross", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec3::cross( - _self.into_inner(), - rhs.into_inner(), + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = bevy::math::DVec2::select( + mask.into_inner(), + if_true.into_inner(), + if_false.into_inner(), ) .into(); output }, ) .register( - "min", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec3::min( + "signum", + |_self: Val| { + let output: Val = bevy::math::DVec2::signum( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "max", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec3::max( - _self.into_inner(), - rhs.into_inner(), - ) + "splat", + |v: f64| { + let output: Val = bevy::math::DVec2::splat(v) .into(); output }, ) .register( - "clamp", - | - _self: Val, - min: Val, - max: Val| - { - let output: Val = bevy::math::DVec3::clamp( - _self.into_inner(), - min.into_inner(), - max.into_inner(), - ) + "sub", + |_self: Val, rhs: Ref| { + let output: Val = >::sub(_self.into_inner(), &rhs) .into(); output }, ) .register( - "min_element", - |_self: Val| { - let output: f64 = bevy::math::DVec3::min_element(_self.into_inner()) + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "max_element", - |_self: Val| { - let output: f64 = bevy::math::DVec3::max_element(_self.into_inner()) + "sub", + |_self: Val, rhs: f64| { + let output: Val = >::sub(_self.into_inner(), rhs) .into(); output }, ) .register( - "element_sum", - |_self: Val| { - let output: f64 = bevy::math::DVec3::element_sum(_self.into_inner()) + "to_angle", + |_self: Val| { + let output: f64 = bevy::math::DVec2::to_angle(_self.into_inner()) .into(); output }, ) .register( - "element_product", - |_self: Val| { - let output: f64 = bevy::math::DVec3::element_product( - _self.into_inner(), - ) - .into(); + "to_array", + |_self: Ref| { + let output: [f64; 2] = bevy::math::DVec2::to_array(&_self).into(); output }, ) .register( - "cmpeq", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec3::cmpeq( + "trunc", + |_self: Val| { + let output: Val = bevy::math::DVec2::trunc( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "cmpne", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec3::cmpne( + "with_x", + |_self: Val, x: f64| { + let output: Val = bevy::math::DVec2::with_x( _self.into_inner(), - rhs.into_inner(), + x, ) .into(); output }, ) .register( - "cmpge", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec3::cmpge( + "with_y", + |_self: Val, y: f64| { + let output: Val = bevy::math::DVec2::with_y( _self.into_inner(), - rhs.into_inner(), + y, ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::DVec3>::new(world) .register( - "cmpgt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec3::cmpgt( + "abs", + |_self: Val| { + let output: Val = bevy::math::DVec3::abs( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "cmple", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec3::cmple( + "abs_diff_eq", + | + _self: Val, + rhs: Val, + max_abs_diff: f64| + { + let output: bool = bevy::math::DVec3::abs_diff_eq( _self.into_inner(), rhs.into_inner(), + max_abs_diff, ) .into(); output }, ) .register( - "cmplt", + "add", |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec3::cmplt( - _self.into_inner(), - rhs.into_inner(), - ) + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "abs", - |_self: Val| { - let output: Val = bevy::math::DVec3::abs( - _self.into_inner(), - ) + "add", + |_self: Val, rhs: f64| { + let output: Val = >::add(_self.into_inner(), rhs) .into(); output }, ) .register( - "signum", - |_self: Val| { - let output: Val = bevy::math::DVec3::signum( - _self.into_inner(), - ) + "add", + |_self: Val, rhs: Ref| { + let output: Val = >::add(_self.into_inner(), &rhs) .into(); output }, ) .register( - "copysign", + "angle_between", |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec3::copysign( + let output: f64 = bevy::math::DVec3::angle_between( _self.into_inner(), rhs.into_inner(), ) @@ -14811,166 +14555,181 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "is_negative_bitmask", - |_self: Val| { - let output: u32 = bevy::math::DVec3::is_negative_bitmask( - _self.into_inner(), + "any_orthogonal_vector", + |_self: Ref| { + let output: Val = bevy::math::DVec3::any_orthogonal_vector( + &_self, ) .into(); output }, ) .register( - "is_finite", - |_self: Val| { - let output: bool = bevy::math::DVec3::is_finite(_self.into_inner()) + "any_orthonormal_vector", + |_self: Ref| { + let output: Val = bevy::math::DVec3::any_orthonormal_vector( + &_self, + ) .into(); output }, ) .register( - "is_finite_mask", - |_self: Val| { - let output: Val = bevy::math::DVec3::is_finite_mask( - _self.into_inner(), + "as_i64vec3", + |_self: Ref| { + let output: Val = bevy::math::DVec3::as_i64vec3( + &_self, ) .into(); output }, ) .register( - "is_nan", - |_self: Val| { - let output: bool = bevy::math::DVec3::is_nan(_self.into_inner()) + "as_ivec3", + |_self: Ref| { + let output: Val = bevy::math::DVec3::as_ivec3( + &_self, + ) .into(); output }, ) .register( - "is_nan_mask", - |_self: Val| { - let output: Val = bevy::math::DVec3::is_nan_mask( - _self.into_inner(), + "as_u64vec3", + |_self: Ref| { + let output: Val = bevy::math::DVec3::as_u64vec3( + &_self, ) .into(); output }, ) .register( - "length", - |_self: Val| { - let output: f64 = bevy::math::DVec3::length(_self.into_inner()) + "as_uvec3", + |_self: Ref| { + let output: Val = bevy::math::DVec3::as_uvec3( + &_self, + ) .into(); output }, ) .register( - "length_squared", - |_self: Val| { - let output: f64 = bevy::math::DVec3::length_squared( - _self.into_inner(), + "as_vec3", + |_self: Ref| { + let output: Val = bevy::math::DVec3::as_vec3( + &_self, ) .into(); output }, ) .register( - "length_recip", - |_self: Val| { - let output: f64 = bevy::math::DVec3::length_recip(_self.into_inner()) + "as_vec3a", + |_self: Ref| { + let output: Val = bevy::math::DVec3::as_vec3a( + &_self, + ) .into(); output }, ) .register( - "distance", - |_self: Val, rhs: Val| { - let output: f64 = bevy::math::DVec3::distance( + "ceil", + |_self: Val| { + let output: Val = bevy::math::DVec3::ceil( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "distance_squared", - |_self: Val, rhs: Val| { - let output: f64 = bevy::math::DVec3::distance_squared( - _self.into_inner(), - rhs.into_inner(), + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = bevy::math::DVec3::clamp( + _self.into_inner(), + min.into_inner(), + max.into_inner(), ) .into(); output }, ) .register( - "div_euclid", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec3::div_euclid( + "clamp_length", + |_self: Val, min: f64, max: f64| { + let output: Val = bevy::math::DVec3::clamp_length( _self.into_inner(), - rhs.into_inner(), + min, + max, ) .into(); output }, ) .register( - "rem_euclid", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec3::rem_euclid( + "clamp_length_max", + |_self: Val, max: f64| { + let output: Val = bevy::math::DVec3::clamp_length_max( _self.into_inner(), - rhs.into_inner(), + max, ) .into(); output }, ) .register( - "normalize", - |_self: Val| { - let output: Val = bevy::math::DVec3::normalize( + "clamp_length_min", + |_self: Val, min: f64| { + let output: Val = bevy::math::DVec3::clamp_length_min( _self.into_inner(), + min, ) .into(); output }, ) .register( - "normalize_or", - |_self: Val, fallback: Val| { - let output: Val = bevy::math::DVec3::normalize_or( - _self.into_inner(), - fallback.into_inner(), + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, ) .into(); output }, ) .register( - "normalize_or_zero", - |_self: Val| { - let output: Val = bevy::math::DVec3::normalize_or_zero( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec3::cmpeq( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "is_normalized", - |_self: Val| { - let output: bool = bevy::math::DVec3::is_normalized( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec3::cmpge( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "project_onto", + "cmpgt", |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec3::project_onto( + let output: Val = bevy::math::DVec3::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -14979,9 +14738,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "reject_from", + "cmple", |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec3::reject_from( + let output: Val = bevy::math::DVec3::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -14990,9 +14749,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "project_onto_normalized", + "cmplt", |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec3::project_onto_normalized( + let output: Val = bevy::math::DVec3::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -15001,9 +14760,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "reject_from_normalized", + "cmpne", |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec3::reject_from_normalized( + let output: Val = bevy::math::DVec3::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -15012,361 +14771,350 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "round", - |_self: Val| { - let output: Val = bevy::math::DVec3::round( + "copysign", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec3::copysign( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "floor", - |_self: Val| { - let output: Val = bevy::math::DVec3::floor( + "cross", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec3::cross( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "ceil", - |_self: Val| { - let output: Val = bevy::math::DVec3::ceil( + "distance", + |_self: Val, rhs: Val| { + let output: f64 = bevy::math::DVec3::distance( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "trunc", - |_self: Val| { - let output: Val = bevy::math::DVec3::trunc( + "distance_squared", + |_self: Val, rhs: Val| { + let output: f64 = bevy::math::DVec3::distance_squared( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "fract", - |_self: Val| { - let output: Val = bevy::math::DVec3::fract( - _self.into_inner(), - ) + "div", + |_self: Val, rhs: Ref| { + let output: Val = >::div(_self.into_inner(), &rhs) .into(); output }, ) .register( - "fract_gl", - |_self: Val| { - let output: Val = bevy::math::DVec3::fract_gl( - _self.into_inner(), - ) + "div", + |_self: Val, rhs: f64| { + let output: Val = >::div(_self.into_inner(), rhs) .into(); output }, ) .register( - "exp", - |_self: Val| { - let output: Val = bevy::math::DVec3::exp( - _self.into_inner(), - ) + "div", + |_self: Val, rhs: Val| { + let output: Val = >::div(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "powf", - |_self: Val, n: f64| { - let output: Val = bevy::math::DVec3::powf( + "div_euclid", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec3::div_euclid( _self.into_inner(), - n, + rhs.into_inner(), ) .into(); output }, ) .register( - "recip", - |_self: Val| { - let output: Val = bevy::math::DVec3::recip( + "dot", + |_self: Val, rhs: Val| { + let output: f64 = bevy::math::DVec3::dot( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "lerp", - |_self: Val, rhs: Val, s: f64| { - let output: Val = bevy::math::DVec3::lerp( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec3::dot_into_vec( _self.into_inner(), rhs.into_inner(), - s, ) .into(); output }, ) .register( - "move_towards", - |_self: Ref, rhs: Val, d: f64| { - let output: Val = bevy::math::DVec3::move_towards( - &_self, - rhs.into_inner(), - d, + "element_product", + |_self: Val| { + let output: f64 = bevy::math::DVec3::element_product( + _self.into_inner(), ) .into(); output }, ) .register( - "midpoint", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec3::midpoint( - _self.into_inner(), - rhs.into_inner(), - ) + "element_sum", + |_self: Val| { + let output: f64 = bevy::math::DVec3::element_sum(_self.into_inner()) .into(); output }, ) .register( - "abs_diff_eq", - | - _self: Val, - rhs: Val, - max_abs_diff: f64| - { - let output: bool = bevy::math::DVec3::abs_diff_eq( - _self.into_inner(), - rhs.into_inner(), - max_abs_diff, - ) + "eq", + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "clamp_length", - |_self: Val, min: f64, max: f64| { - let output: Val = bevy::math::DVec3::clamp_length( + "exp", + |_self: Val| { + let output: Val = bevy::math::DVec3::exp( _self.into_inner(), - min, - max, ) .into(); output }, ) .register( - "clamp_length_max", - |_self: Val, max: f64| { - let output: Val = bevy::math::DVec3::clamp_length_max( + "extend", + |_self: Val, w: f64| { + let output: Val = bevy::math::DVec3::extend( _self.into_inner(), - max, + w, ) .into(); output }, ) .register( - "clamp_length_min", - |_self: Val, min: f64| { - let output: Val = bevy::math::DVec3::clamp_length_min( + "floor", + |_self: Val| { + let output: Val = bevy::math::DVec3::floor( _self.into_inner(), - min, ) .into(); output }, ) .register( - "mul_add", - | - _self: Val, - a: Val, - b: Val| - { - let output: Val = bevy::math::DVec3::mul_add( + "fract", + |_self: Val| { + let output: Val = bevy::math::DVec3::fract( _self.into_inner(), - a.into_inner(), - b.into_inner(), ) .into(); output }, ) .register( - "reflect", - |_self: Val, normal: Val| { - let output: Val = bevy::math::DVec3::reflect( + "fract_gl", + |_self: Val| { + let output: Val = bevy::math::DVec3::fract_gl( _self.into_inner(), - normal.into_inner(), ) .into(); output }, ) .register( - "refract", - | - _self: Val, - normal: Val, - eta: f64| - { - let output: Val = bevy::math::DVec3::refract( - _self.into_inner(), - normal.into_inner(), - eta, - ) + "from_array", + |a: [f64; 3]| { + let output: Val = bevy::math::DVec3::from_array(a) .into(); output }, ) .register( - "angle_between", - |_self: Val, rhs: Val| { - let output: f64 = bevy::math::DVec3::angle_between( - _self.into_inner(), - rhs.into_inner(), - ) + "is_finite", + |_self: Val| { + let output: bool = bevy::math::DVec3::is_finite(_self.into_inner()) .into(); output }, ) .register( - "any_orthogonal_vector", - |_self: Ref| { - let output: Val = bevy::math::DVec3::any_orthogonal_vector( - &_self, + "is_finite_mask", + |_self: Val| { + let output: Val = bevy::math::DVec3::is_finite_mask( + _self.into_inner(), ) .into(); output }, ) .register( - "any_orthonormal_vector", - |_self: Ref| { - let output: Val = bevy::math::DVec3::any_orthonormal_vector( - &_self, - ) + "is_nan", + |_self: Val| { + let output: bool = bevy::math::DVec3::is_nan(_self.into_inner()) .into(); output }, ) .register( - "as_vec3", - |_self: Ref| { - let output: Val = bevy::math::DVec3::as_vec3( - &_self, + "is_nan_mask", + |_self: Val| { + let output: Val = bevy::math::DVec3::is_nan_mask( + _self.into_inner(), ) .into(); output }, ) .register( - "as_vec3a", - |_self: Ref| { - let output: Val = bevy::math::DVec3::as_vec3a( - &_self, + "is_negative_bitmask", + |_self: Val| { + let output: u32 = bevy::math::DVec3::is_negative_bitmask( + _self.into_inner(), ) .into(); output }, ) .register( - "as_ivec3", - |_self: Ref| { - let output: Val = bevy::math::DVec3::as_ivec3( - &_self, + "is_normalized", + |_self: Val| { + let output: bool = bevy::math::DVec3::is_normalized( + _self.into_inner(), ) .into(); output }, ) .register( - "as_uvec3", - |_self: Ref| { - let output: Val = bevy::math::DVec3::as_uvec3( - &_self, - ) + "length", + |_self: Val| { + let output: f64 = bevy::math::DVec3::length(_self.into_inner()) .into(); output }, ) .register( - "as_i64vec3", - |_self: Ref| { - let output: Val = bevy::math::DVec3::as_i64vec3( - &_self, + "length_recip", + |_self: Val| { + let output: f64 = bevy::math::DVec3::length_recip(_self.into_inner()) + .into(); + output + }, + ) + .register( + "length_squared", + |_self: Val| { + let output: f64 = bevy::math::DVec3::length_squared( + _self.into_inner(), ) .into(); output }, ) .register( - "as_u64vec3", - |_self: Ref| { - let output: Val = bevy::math::DVec3::as_u64vec3( - &_self, + "lerp", + |_self: Val, rhs: Val, s: f64| { + let output: Val = bevy::math::DVec3::lerp( + _self.into_inner(), + rhs.into_inner(), + s, ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Ref| { - let output: Val = >::sub(_self.into_inner(), &rhs) + "max", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec3::max( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Ref| { - let output: Val = >::rem(_self.into_inner(), &rhs) + "max_element", + |_self: Val| { + let output: f64 = bevy::math::DVec3::max_element(_self.into_inner()) .into(); output }, ) .register( - "add", + "midpoint", |_self: Val, rhs: Val| { - let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + let output: Val = bevy::math::DVec3::midpoint( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "sub", + "min", |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + let output: Val = bevy::math::DVec3::min( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: f64| { - let output: Val = >::add(_self.into_inner(), rhs) + "min_element", + |_self: Val| { + let output: f64 = bevy::math::DVec3::min_element(_self.into_inner()) + .into(); + output + }, + ) + .register( + "move_towards", + |_self: Ref, rhs: Val, d: f64| { + let output: Val = bevy::math::DVec3::move_towards( + &_self, + rhs.into_inner(), + d, + ) .into(); output }, @@ -15392,203 +15140,219 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "rem", - |_self: Val, rhs: f64| { - let output: Val = >::rem(_self.into_inner(), rhs) + "mul", + |_self: Val, rhs: Ref| { + let output: Val = >::mul(_self.into_inner(), &rhs) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, + "mul_add", + | + _self: Val, + a: Val, + b: Val| + { + let output: Val = bevy::math::DVec3::mul_add( + _self.into_inner(), + a.into_inner(), + b.into_inner(), ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: f64| { - let output: Val = >::div(_self.into_inner(), rhs) + "neg", + |_self: Val| { + let output: Val = ::neg( + _self.into_inner(), + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: f64| { - let output: Val = >::sub(_self.into_inner(), rhs) + "new", + |x: f64, y: f64, z: f64| { + let output: Val = bevy::math::DVec3::new(x, y, z) .into(); output }, ) .register( - "div", - |_self: Val, rhs: Val| { - let output: Val = >::div(_self.into_inner(), rhs.into_inner()) + "normalize", + |_self: Val| { + let output: Val = bevy::math::DVec3::normalize( + _self.into_inner(), + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Ref| { - let output: Val = >::mul(_self.into_inner(), &rhs) + "normalize_or", + |_self: Val, fallback: Val| { + let output: Val = bevy::math::DVec3::normalize_or( + _self.into_inner(), + fallback.into_inner(), + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Ref| { - let output: Val = >::add(_self.into_inner(), &rhs) + "normalize_or_zero", + |_self: Val| { + let output: Val = bevy::math::DVec3::normalize_or_zero( + _self.into_inner(), + ) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Val| { - let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) + "powf", + |_self: Val, n: f64| { + let output: Val = bevy::math::DVec3::powf( + _self.into_inner(), + n, + ) .into(); output }, ) .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) - .into(); - output - }, - ); - NamespaceBuilder::<::bevy::math::DVec4>::new(world) - .register( - "rem", - |_self: Val, rhs: Val| { - let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) + "project_onto", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec3::project_onto( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Ref| { - let output: Val = >::sub(_self.into_inner(), &rhs) + "project_onto_normalized", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec3::project_onto_normalized( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: Ref| { - let output: Val = >::rem(_self.into_inner(), &rhs) + "recip", + |_self: Val| { + let output: Val = bevy::math::DVec3::recip( + _self.into_inner(), + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + "reflect", + |_self: Val, normal: Val| { + let output: Val = bevy::math::DVec3::reflect( + _self.into_inner(), + normal.into_inner(), + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: Ref| { - let output: Val = >::div(_self.into_inner(), &rhs) + "refract", + | + _self: Val, + normal: Val, + eta: f64| + { + let output: Val = bevy::math::DVec3::refract( + _self.into_inner(), + normal.into_inner(), + eta, + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: Val| { - let output: Val = >::div(_self.into_inner(), rhs.into_inner()) + "reject_from", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec3::reject_from( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Val| { - let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + "reject_from_normalized", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec3::reject_from_normalized( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) + "rem", + |_self: Val, rhs: Ref| { + let output: Val = >::rem(_self.into_inner(), &rhs) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Ref| { - let output: Val = >::add(_self.into_inner(), &rhs) + "rem", + |_self: Val, rhs: f64| { + let output: Val = >::rem(_self.into_inner(), rhs) .into(); output }, ) .register( - "new", - |x: f64, y: f64, z: f64, w: f64| { - let output: Val = bevy::math::DVec4::new( - x, - y, - z, - w, + "rem", + |_self: Val, rhs: Val| { + let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) + .into(); + output + }, + ) + .register( + "rem_euclid", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec3::rem_euclid( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "splat", - |v: f64| { - let output: Val = bevy::math::DVec4::splat(v) + "round", + |_self: Val| { + let output: Val = bevy::math::DVec3::round( + _self.into_inner(), + ) .into(); output }, @@ -15596,11 +15360,11 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { .register( "select", | - mask: Val, - if_true: Val, - if_false: Val| + mask: Val, + if_true: Val, + if_false: Val| { - let output: Val = bevy::math::DVec4::select( + let output: Val = bevy::math::DVec3::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -15610,341 +15374,338 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_array", - |a: [f64; 4]| { - let output: Val = bevy::math::DVec4::from_array(a) + "signum", + |_self: Val| { + let output: Val = bevy::math::DVec3::signum( + _self.into_inner(), + ) .into(); output }, ) .register( - "to_array", - |_self: Ref| { - let output: [f64; 4] = bevy::math::DVec4::to_array(&_self).into(); + "splat", + |v: f64| { + let output: Val = bevy::math::DVec3::splat(v) + .into(); output }, ) .register( - "truncate", - |_self: Val| { - let output: Val = bevy::math::DVec4::truncate( - _self.into_inner(), - ) + "sub", + |_self: Val, rhs: Ref| { + let output: Val = >::sub(_self.into_inner(), &rhs) .into(); output }, ) .register( - "with_x", - |_self: Val, x: f64| { - let output: Val = bevy::math::DVec4::with_x( - _self.into_inner(), - x, - ) + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "with_y", - |_self: Val, y: f64| { - let output: Val = bevy::math::DVec4::with_y( - _self.into_inner(), - y, - ) + "sub", + |_self: Val, rhs: f64| { + let output: Val = >::sub(_self.into_inner(), rhs) .into(); output }, ) .register( - "with_z", - |_self: Val, z: f64| { - let output: Val = bevy::math::DVec4::with_z( + "to_array", + |_self: Ref| { + let output: [f64; 3] = bevy::math::DVec3::to_array(&_self).into(); + output + }, + ) + .register( + "trunc", + |_self: Val| { + let output: Val = bevy::math::DVec3::trunc( _self.into_inner(), - z, ) .into(); output }, ) .register( - "with_w", - |_self: Val, w: f64| { - let output: Val = bevy::math::DVec4::with_w( + "truncate", + |_self: Val| { + let output: Val = bevy::math::DVec3::truncate( _self.into_inner(), - w, ) .into(); output }, ) .register( - "dot", - |_self: Val, rhs: Val| { - let output: f64 = bevy::math::DVec4::dot( + "with_x", + |_self: Val, x: f64| { + let output: Val = bevy::math::DVec3::with_x( _self.into_inner(), - rhs.into_inner(), + x, ) .into(); output }, ) .register( - "dot_into_vec", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec4::dot_into_vec( + "with_y", + |_self: Val, y: f64| { + let output: Val = bevy::math::DVec3::with_y( _self.into_inner(), - rhs.into_inner(), + y, ) .into(); output }, ) .register( - "min", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec4::min( + "with_z", + |_self: Val, z: f64| { + let output: Val = bevy::math::DVec3::with_z( _self.into_inner(), - rhs.into_inner(), + z, ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::DVec4>::new(world) .register( - "max", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec4::max( + "abs", + |_self: Val| { + let output: Val = bevy::math::DVec4::abs( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "clamp", + "abs_diff_eq", | _self: Val, - min: Val, - max: Val| + rhs: Val, + max_abs_diff: f64| { - let output: Val = bevy::math::DVec4::clamp( + let output: bool = bevy::math::DVec4::abs_diff_eq( _self.into_inner(), - min.into_inner(), - max.into_inner(), + rhs.into_inner(), + max_abs_diff, ) .into(); output }, ) .register( - "min_element", - |_self: Val| { - let output: f64 = bevy::math::DVec4::min_element(_self.into_inner()) + "add", + |_self: Val, rhs: Val| { + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "max_element", - |_self: Val| { - let output: f64 = bevy::math::DVec4::max_element(_self.into_inner()) + "add", + |_self: Val, rhs: Ref| { + let output: Val = >::add(_self.into_inner(), &rhs) .into(); output }, ) .register( - "element_sum", - |_self: Val| { - let output: f64 = bevy::math::DVec4::element_sum(_self.into_inner()) + "add", + |_self: Val, rhs: f64| { + let output: Val = >::add(_self.into_inner(), rhs) .into(); output }, ) .register( - "element_product", - |_self: Val| { - let output: f64 = bevy::math::DVec4::element_product( - _self.into_inner(), + "as_i64vec4", + |_self: Ref| { + let output: Val = bevy::math::DVec4::as_i64vec4( + &_self, ) .into(); output }, ) .register( - "cmpeq", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec4::cmpeq( - _self.into_inner(), - rhs.into_inner(), + "as_ivec4", + |_self: Ref| { + let output: Val = bevy::math::DVec4::as_ivec4( + &_self, ) .into(); output }, ) .register( - "cmpne", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec4::cmpne( - _self.into_inner(), - rhs.into_inner(), + "as_u64vec4", + |_self: Ref| { + let output: Val = bevy::math::DVec4::as_u64vec4( + &_self, ) .into(); output }, ) .register( - "cmpge", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec4::cmpge( - _self.into_inner(), - rhs.into_inner(), + "as_uvec4", + |_self: Ref| { + let output: Val = bevy::math::DVec4::as_uvec4( + &_self, ) .into(); output }, ) .register( - "cmpgt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec4::cmpgt( - _self.into_inner(), - rhs.into_inner(), + "as_vec4", + |_self: Ref| { + let output: Val = bevy::math::DVec4::as_vec4( + &_self, ) .into(); output }, ) .register( - "cmple", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec4::cmple( + "ceil", + |_self: Val| { + let output: Val = bevy::math::DVec4::ceil( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "cmplt", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec4::cmplt( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = bevy::math::DVec4::clamp( _self.into_inner(), - rhs.into_inner(), + min.into_inner(), + max.into_inner(), ) .into(); output }, ) .register( - "abs", - |_self: Val| { - let output: Val = bevy::math::DVec4::abs( + "clamp_length", + |_self: Val, min: f64, max: f64| { + let output: Val = bevy::math::DVec4::clamp_length( _self.into_inner(), + min, + max, ) .into(); output }, ) .register( - "signum", - |_self: Val| { - let output: Val = bevy::math::DVec4::signum( + "clamp_length_max", + |_self: Val, max: f64| { + let output: Val = bevy::math::DVec4::clamp_length_max( _self.into_inner(), + max, ) .into(); output }, ) .register( - "copysign", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec4::copysign( + "clamp_length_min", + |_self: Val, min: f64| { + let output: Val = bevy::math::DVec4::clamp_length_min( _self.into_inner(), - rhs.into_inner(), + min, ) .into(); output }, ) .register( - "is_negative_bitmask", - |_self: Val| { - let output: u32 = bevy::math::DVec4::is_negative_bitmask( - _self.into_inner(), + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, ) .into(); output }, ) .register( - "is_finite", - |_self: Val| { - let output: bool = bevy::math::DVec4::is_finite(_self.into_inner()) - .into(); - output - }, - ) - .register( - "is_finite_mask", - |_self: Val| { - let output: Val = bevy::math::DVec4::is_finite_mask( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec4::cmpeq( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "is_nan", - |_self: Val| { - let output: bool = bevy::math::DVec4::is_nan(_self.into_inner()) - .into(); - output - }, - ) - .register( - "is_nan_mask", - |_self: Val| { - let output: Val = bevy::math::DVec4::is_nan_mask( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec4::cmpge( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "length", - |_self: Val| { - let output: f64 = bevy::math::DVec4::length(_self.into_inner()) - .into(); - output - }, - ) - .register( - "length_squared", - |_self: Val| { - let output: f64 = bevy::math::DVec4::length_squared( + "cmpgt", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec4::cmpgt( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "length_recip", - |_self: Val| { - let output: f64 = bevy::math::DVec4::length_recip(_self.into_inner()) + "cmple", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec4::cmple( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "distance", + "cmplt", |_self: Val, rhs: Val| { - let output: f64 = bevy::math::DVec4::distance( + let output: Val = bevy::math::DVec4::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -15953,9 +15714,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "distance_squared", + "cmpne", |_self: Val, rhs: Val| { - let output: f64 = bevy::math::DVec4::distance_squared( + let output: Val = bevy::math::DVec4::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -15964,9 +15725,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "div_euclid", + "copysign", |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec4::div_euclid( + let output: Val = bevy::math::DVec4::copysign( _self.into_inner(), rhs.into_inner(), ) @@ -15975,9 +15736,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "rem_euclid", + "distance", |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec4::rem_euclid( + let output: f64 = bevy::math::DVec4::distance( _self.into_inner(), rhs.into_inner(), ) @@ -15986,50 +15747,50 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "normalize", - |_self: Val| { - let output: Val = bevy::math::DVec4::normalize( + "distance_squared", + |_self: Val, rhs: Val| { + let output: f64 = bevy::math::DVec4::distance_squared( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "normalize_or", - |_self: Val, fallback: Val| { - let output: Val = bevy::math::DVec4::normalize_or( - _self.into_inner(), - fallback.into_inner(), - ) + "div", + |_self: Val, rhs: Ref| { + let output: Val = >::div(_self.into_inner(), &rhs) .into(); output }, ) .register( - "normalize_or_zero", - |_self: Val| { - let output: Val = bevy::math::DVec4::normalize_or_zero( - _self.into_inner(), - ) + "div", + |_self: Val, rhs: Val| { + let output: Val = >::div(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "is_normalized", - |_self: Val| { - let output: bool = bevy::math::DVec4::is_normalized( - _self.into_inner(), - ) + "div", + |_self: Val, rhs: f64| { + let output: Val = >::div(_self.into_inner(), rhs) .into(); output }, ) .register( - "project_onto", + "div_euclid", |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec4::project_onto( + let output: Val = bevy::math::DVec4::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -16038,9 +15799,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "reject_from", + "dot", |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec4::reject_from( + let output: f64 = bevy::math::DVec4::dot( _self.into_inner(), rhs.into_inner(), ) @@ -16049,9 +15810,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "project_onto_normalized", + "dot_into_vec", |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec4::project_onto_normalized( + let output: Val = bevy::math::DVec4::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -16060,40 +15821,37 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "reject_from_normalized", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec4::reject_from_normalized( + "element_product", + |_self: Val| { + let output: f64 = bevy::math::DVec4::element_product( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "round", + "element_sum", |_self: Val| { - let output: Val = bevy::math::DVec4::round( - _self.into_inner(), - ) + let output: f64 = bevy::math::DVec4::element_sum(_self.into_inner()) .into(); output }, ) .register( - "floor", - |_self: Val| { - let output: Val = bevy::math::DVec4::floor( - _self.into_inner(), - ) + "eq", + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "ceil", + "exp", |_self: Val| { - let output: Val = bevy::math::DVec4::ceil( + let output: Val = bevy::math::DVec4::exp( _self.into_inner(), ) .into(); @@ -16101,9 +15859,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "trunc", + "floor", |_self: Val| { - let output: Val = bevy::math::DVec4::trunc( + let output: Val = bevy::math::DVec4::floor( _self.into_inner(), ) .into(); @@ -16131,30 +15889,25 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "exp", - |_self: Val| { - let output: Val = bevy::math::DVec4::exp( - _self.into_inner(), - ) + "from_array", + |a: [f64; 4]| { + let output: Val = bevy::math::DVec4::from_array(a) .into(); output }, ) .register( - "powf", - |_self: Val, n: f64| { - let output: Val = bevy::math::DVec4::powf( - _self.into_inner(), - n, - ) + "is_finite", + |_self: Val| { + let output: bool = bevy::math::DVec4::is_finite(_self.into_inner()) .into(); output }, ) .register( - "recip", + "is_finite_mask", |_self: Val| { - let output: Val = bevy::math::DVec4::recip( + let output: Val = bevy::math::DVec4::is_finite_mask( _self.into_inner(), ) .into(); @@ -16162,504 +15915,528 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "lerp", - |_self: Val, rhs: Val, s: f64| { - let output: Val = bevy::math::DVec4::lerp( - _self.into_inner(), - rhs.into_inner(), - s, - ) + "is_nan", + |_self: Val| { + let output: bool = bevy::math::DVec4::is_nan(_self.into_inner()) .into(); output }, ) .register( - "move_towards", - |_self: Ref, rhs: Val, d: f64| { - let output: Val = bevy::math::DVec4::move_towards( - &_self, - rhs.into_inner(), - d, + "is_nan_mask", + |_self: Val| { + let output: Val = bevy::math::DVec4::is_nan_mask( + _self.into_inner(), ) .into(); output }, ) .register( - "midpoint", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DVec4::midpoint( + "is_negative_bitmask", + |_self: Val| { + let output: u32 = bevy::math::DVec4::is_negative_bitmask( _self.into_inner(), - rhs.into_inner(), ) .into(); output }, ) .register( - "abs_diff_eq", - | - _self: Val, - rhs: Val, - max_abs_diff: f64| - { - let output: bool = bevy::math::DVec4::abs_diff_eq( + "is_normalized", + |_self: Val| { + let output: bool = bevy::math::DVec4::is_normalized( _self.into_inner(), - rhs.into_inner(), - max_abs_diff, ) .into(); output }, ) .register( - "clamp_length", - |_self: Val, min: f64, max: f64| { - let output: Val = bevy::math::DVec4::clamp_length( - _self.into_inner(), - min, - max, - ) + "length", + |_self: Val| { + let output: f64 = bevy::math::DVec4::length(_self.into_inner()) .into(); output }, ) .register( - "clamp_length_max", - |_self: Val, max: f64| { - let output: Val = bevy::math::DVec4::clamp_length_max( - _self.into_inner(), - max, - ) + "length_recip", + |_self: Val| { + let output: f64 = bevy::math::DVec4::length_recip(_self.into_inner()) .into(); output }, ) .register( - "clamp_length_min", - |_self: Val, min: f64| { - let output: Val = bevy::math::DVec4::clamp_length_min( + "length_squared", + |_self: Val| { + let output: f64 = bevy::math::DVec4::length_squared( _self.into_inner(), - min, ) .into(); output }, ) .register( - "mul_add", - | - _self: Val, - a: Val, - b: Val| - { - let output: Val = bevy::math::DVec4::mul_add( + "lerp", + |_self: Val, rhs: Val, s: f64| { + let output: Val = bevy::math::DVec4::lerp( _self.into_inner(), - a.into_inner(), - b.into_inner(), + rhs.into_inner(), + s, ) .into(); output }, ) .register( - "reflect", - |_self: Val, normal: Val| { - let output: Val = bevy::math::DVec4::reflect( + "max", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec4::max( _self.into_inner(), - normal.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "refract", - | - _self: Val, - normal: Val, - eta: f64| - { - let output: Val = bevy::math::DVec4::refract( - _self.into_inner(), - normal.into_inner(), - eta, - ) + "max_element", + |_self: Val| { + let output: f64 = bevy::math::DVec4::max_element(_self.into_inner()) .into(); output }, ) .register( - "as_vec4", - |_self: Ref| { - let output: Val = bevy::math::DVec4::as_vec4( - &_self, + "midpoint", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec4::midpoint( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "as_ivec4", - |_self: Ref| { - let output: Val = bevy::math::DVec4::as_ivec4( - &_self, + "min", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec4::min( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "as_uvec4", - |_self: Ref| { - let output: Val = bevy::math::DVec4::as_uvec4( - &_self, - ) + "min_element", + |_self: Val| { + let output: f64 = bevy::math::DVec4::min_element(_self.into_inner()) .into(); output }, ) .register( - "as_i64vec4", - |_self: Ref| { - let output: Val = bevy::math::DVec4::as_i64vec4( + "move_towards", + |_self: Ref, rhs: Val, d: f64| { + let output: Val = bevy::math::DVec4::move_towards( &_self, + rhs.into_inner(), + d, ) .into(); output }, ) .register( - "as_u64vec4", - |_self: Ref| { - let output: Val = bevy::math::DVec4::as_u64vec4( - &_self, - ) + "mul", + |_self: Val, rhs: Ref| { + let output: Val = >::mul(_self.into_inner(), &rhs) .into(); output }, ) .register( - "add", + "mul", |_self: Val, rhs: f64| { - let output: Val = = >::add(_self.into_inner(), rhs) + >>::mul(_self.into_inner(), rhs) .into(); output }, ) .register( "mul", - |_self: Val, rhs: Ref| { + |_self: Val, rhs: Val| { let output: Val = >::mul(_self.into_inner(), &rhs) + bevy::math::DVec4, + >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "neg", - |_self: Val| { - let output: Val = ::neg( + "mul_add", + | + _self: Val, + a: Val, + b: Val| + { + let output: Val = bevy::math::DVec4::mul_add( _self.into_inner(), + a.into_inner(), + b.into_inner(), ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: f64| { - let output: Val = >::div(_self.into_inner(), rhs) + "neg", + |_self: Val| { + let output: Val = ::neg( + _self.into_inner(), + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: f64| { - let output: Val = >::sub(_self.into_inner(), rhs) + "new", + |x: f64, y: f64, z: f64, w: f64| { + let output: Val = bevy::math::DVec4::new( + x, + y, + z, + w, + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: f64| { - let output: Val = >::mul(_self.into_inner(), rhs) + "normalize", + |_self: Val| { + let output: Val = bevy::math::DVec4::normalize( + _self.into_inner(), + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "normalize_or", + |_self: Val, fallback: Val| { + let output: Val = bevy::math::DVec4::normalize_or( + _self.into_inner(), + fallback.into_inner(), + ) .into(); output }, ) .register( - "rem", - |_self: Val, rhs: f64| { - let output: Val = >::rem(_self.into_inner(), rhs) + "normalize_or_zero", + |_self: Val| { + let output: Val = bevy::math::DVec4::normalize_or_zero( + _self.into_inner(), + ) .into(); output }, ) .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) + "powf", + |_self: Val, n: f64| { + let output: Val = bevy::math::DVec4::powf( + _self.into_inner(), + n, + ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::Mat2>::new(world) + ) .register( - "from_cols", - |x_axis: Val, y_axis: Val| { - let output: Val = bevy::math::Mat2::from_cols( - x_axis.into_inner(), - y_axis.into_inner(), + "project_onto", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec4::project_onto( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "to_cols_array", - |_self: Ref| { - let output: [f32; 4] = bevy::math::Mat2::to_cols_array(&_self) + "project_onto_normalized", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec4::project_onto_normalized( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "to_cols_array_2d", - |_self: Ref| { - let output: [[f32; 2]; 2] = bevy::math::Mat2::to_cols_array_2d( - &_self, + "recip", + |_self: Val| { + let output: Val = bevy::math::DVec4::recip( + _self.into_inner(), ) .into(); output }, ) .register( - "from_diagonal", - |diagonal: Val| { - let output: Val = bevy::math::Mat2::from_diagonal( - diagonal.into_inner(), + "reflect", + |_self: Val, normal: Val| { + let output: Val = bevy::math::DVec4::reflect( + _self.into_inner(), + normal.into_inner(), ) .into(); output }, ) .register( - "from_scale_angle", - |scale: Val, angle: f32| { - let output: Val = bevy::math::Mat2::from_scale_angle( - scale.into_inner(), - angle, + "refract", + | + _self: Val, + normal: Val, + eta: f64| + { + let output: Val = bevy::math::DVec4::refract( + _self.into_inner(), + normal.into_inner(), + eta, ) .into(); output }, ) .register( - "from_angle", - |angle: f32| { - let output: Val = bevy::math::Mat2::from_angle( - angle, + "reject_from", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec4::reject_from( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "from_mat3", - |m: Val| { - let output: Val = bevy::math::Mat2::from_mat3( - m.into_inner(), + "reject_from_normalized", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec4::reject_from_normalized( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "from_mat3_minor", - |m: Val, i: usize, j: usize| { - let output: Val = bevy::math::Mat2::from_mat3_minor( - m.into_inner(), - i, - j, - ) + "rem", + |_self: Val, rhs: Val| { + let output: Val = >::rem(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "from_mat3a", - |m: Val| { - let output: Val = bevy::math::Mat2::from_mat3a( - m.into_inner(), - ) + "rem", + |_self: Val, rhs: Ref| { + let output: Val = >::rem(_self.into_inner(), &rhs) .into(); output }, ) .register( - "from_mat3a_minor", - |m: Val, i: usize, j: usize| { - let output: Val = bevy::math::Mat2::from_mat3a_minor( - m.into_inner(), - i, - j, + "rem", + |_self: Val, rhs: f64| { + let output: Val = >::rem(_self.into_inner(), rhs) + .into(); + output + }, + ) + .register( + "rem_euclid", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DVec4::rem_euclid( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "col", - |_self: Ref, index: usize| { - let output: Val = bevy::math::Mat2::col( - &_self, - index, + "round", + |_self: Val| { + let output: Val = bevy::math::DVec4::round( + _self.into_inner(), ) .into(); output }, ) .register( - "row", - |_self: Ref, index: usize| { - let output: Val = bevy::math::Mat2::row( - &_self, - index, + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = bevy::math::DVec4::select( + mask.into_inner(), + if_true.into_inner(), + if_false.into_inner(), ) .into(); output }, ) .register( - "is_finite", - |_self: Ref| { - let output: bool = bevy::math::Mat2::is_finite(&_self).into(); + "signum", + |_self: Val| { + let output: Val = bevy::math::DVec4::signum( + _self.into_inner(), + ) + .into(); output }, ) .register( - "is_nan", - |_self: Ref| { - let output: bool = bevy::math::Mat2::is_nan(&_self).into(); + "splat", + |v: f64| { + let output: Val = bevy::math::DVec4::splat(v) + .into(); output }, ) .register( - "transpose", - |_self: Ref| { - let output: Val = bevy::math::Mat2::transpose( - &_self, - ) + "sub", + |_self: Val, rhs: Ref| { + let output: Val = >::sub(_self.into_inner(), &rhs) .into(); output }, ) .register( - "determinant", - |_self: Ref| { - let output: f32 = bevy::math::Mat2::determinant(&_self).into(); + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + .into(); output }, ) .register( - "inverse", - |_self: Ref| { - let output: Val = bevy::math::Mat2::inverse(&_self) + "sub", + |_self: Val, rhs: f64| { + let output: Val = >::sub(_self.into_inner(), rhs) .into(); output }, ) .register( - "mul_vec2", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::Mat2::mul_vec2( - &_self, - rhs.into_inner(), + "to_array", + |_self: Ref| { + let output: [f64; 4] = bevy::math::DVec4::to_array(&_self).into(); + output + }, + ) + .register( + "trunc", + |_self: Val| { + let output: Val = bevy::math::DVec4::trunc( + _self.into_inner(), ) .into(); output }, ) .register( - "mul_mat2", - |_self: Ref, rhs: Ref| { - let output: Val = bevy::math::Mat2::mul_mat2( - &_self, - &rhs, + "truncate", + |_self: Val| { + let output: Val = bevy::math::DVec4::truncate( + _self.into_inner(), ) .into(); output }, ) .register( - "add_mat2", - |_self: Ref, rhs: Ref| { - let output: Val = bevy::math::Mat2::add_mat2( - &_self, - &rhs, + "with_w", + |_self: Val, w: f64| { + let output: Val = bevy::math::DVec4::with_w( + _self.into_inner(), + w, ) .into(); output }, ) .register( - "sub_mat2", - |_self: Ref, rhs: Ref| { - let output: Val = bevy::math::Mat2::sub_mat2( - &_self, - &rhs, + "with_x", + |_self: Val, x: f64| { + let output: Val = bevy::math::DVec4::with_x( + _self.into_inner(), + x, ) .into(); output }, ) .register( - "mul_scalar", - |_self: Ref, rhs: f32| { - let output: Val = bevy::math::Mat2::mul_scalar( - &_self, - rhs, + "with_y", + |_self: Val, y: f64| { + let output: Val = bevy::math::DVec4::with_y( + _self.into_inner(), + y, ) .into(); output }, ) .register( - "div_scalar", - |_self: Ref, rhs: f32| { - let output: Val = bevy::math::Mat2::div_scalar( - &_self, - rhs, + "with_z", + |_self: Val, z: f64| { + let output: Val = bevy::math::DVec4::with_z( + _self.into_inner(), + z, ) .into(); output }, + ); + NamespaceBuilder::<::bevy::math::Mat2>::new(world) + .register( + "abs", + |_self: Ref| { + let output: Val = bevy::math::Mat2::abs(&_self) + .into(); + output + }, ) .register( "abs_diff_eq", @@ -16678,9 +16455,22 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "abs", - |_self: Ref| { - let output: Val = bevy::math::Mat2::abs(&_self) + "add", + |_self: Val, rhs: Val| { + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + .into(); + output + }, + ) + .register( + "add_mat2", + |_self: Ref, rhs: Ref| { + let output: Val = bevy::math::Mat2::add_mat2( + &_self, + &rhs, + ) .into(); output }, @@ -16706,22 +16496,20 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "col", + |_self: Ref, index: usize| { + let output: Val = bevy::math::Mat2::col( + &_self, + index, + ) .into(); output }, ) .register( - "neg", - |_self: Val| { - let output: Val = ::neg( - _self.into_inner(), - ) - .into(); + "determinant", + |_self: Ref| { + let output: f32 = bevy::math::Mat2::determinant(&_self).into(); output }, ) @@ -16736,31 +16524,12 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "sub", - |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) - .into(); - output - }, - ) - .register( - "mul", - |_self: Val, rhs: f32| { - let output: Val = >::mul(_self.into_inner(), rhs) - .into(); - output - }, - ) - .register( - "add", - |_self: Val, rhs: Val| { - let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + "div_scalar", + |_self: Ref, rhs: f32| { + let output: Val = bevy::math::Mat2::div_scalar( + &_self, + rhs, + ) .into(); output }, @@ -16776,64 +16545,62 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "from_angle", + |angle: f32| { + let output: Val = bevy::math::Mat2::from_angle( + angle, + ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::Mat3>::new(world) + ) .register( "from_cols", - | - x_axis: Val, - y_axis: Val, - z_axis: Val| - { - let output: Val = bevy::math::Mat3::from_cols( + |x_axis: Val, y_axis: Val| { + let output: Val = bevy::math::Mat2::from_cols( x_axis.into_inner(), y_axis.into_inner(), - z_axis.into_inner(), ) .into(); output }, ) .register( - "to_cols_array", - |_self: Ref| { - let output: [f32; 9] = bevy::math::Mat3::to_cols_array(&_self) + "from_diagonal", + |diagonal: Val| { + let output: Val = bevy::math::Mat2::from_diagonal( + diagonal.into_inner(), + ) .into(); output }, ) .register( - "to_cols_array_2d", - |_self: Ref| { - let output: [[f32; 3]; 3] = bevy::math::Mat3::to_cols_array_2d( - &_self, + "from_mat3", + |m: Val| { + let output: Val = bevy::math::Mat2::from_mat3( + m.into_inner(), ) .into(); output }, ) .register( - "from_diagonal", - |diagonal: Val| { - let output: Val = bevy::math::Mat3::from_diagonal( - diagonal.into_inner(), + "from_mat3_minor", + |m: Val, i: usize, j: usize| { + let output: Val = bevy::math::Mat2::from_mat3_minor( + m.into_inner(), + i, + j, ) .into(); output }, ) .register( - "from_mat4", - |m: Val| { - let output: Val = bevy::math::Mat3::from_mat4( + "from_mat3a", + |m: Val| { + let output: Val = bevy::math::Mat2::from_mat3a( m.into_inner(), ) .into(); @@ -16841,9 +16608,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_mat4_minor", - |m: Val, i: usize, j: usize| { - let output: Val = bevy::math::Mat3::from_mat4_minor( + "from_mat3a_minor", + |m: Val, i: usize, j: usize| { + let output: Val = bevy::math::Mat2::from_mat3a_minor( m.into_inner(), i, j, @@ -16853,281 +16620,261 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_quat", - |rotation: Val| { - let output: Val = bevy::math::Mat3::from_quat( - rotation.into_inner(), + "from_scale_angle", + |scale: Val, angle: f32| { + let output: Val = bevy::math::Mat2::from_scale_angle( + scale.into_inner(), + angle, ) .into(); output }, ) .register( - "from_axis_angle", - |axis: Val, angle: f32| { - let output: Val = bevy::math::Mat3::from_axis_angle( - axis.into_inner(), - angle, - ) + "inverse", + |_self: Ref| { + let output: Val = bevy::math::Mat2::inverse(&_self) .into(); output }, ) .register( - "from_euler", - |order: Val, a: f32, b: f32, c: f32| { - let output: Val = bevy::math::Mat3::from_euler( - order.into_inner(), - a, - b, - c, - ) - .into(); + "is_finite", + |_self: Ref| { + let output: bool = bevy::math::Mat2::is_finite(&_self).into(); output }, ) .register( - "to_euler", - |_self: Ref, order: Val| { - let output: (f32, f32, f32) = bevy::math::Mat3::to_euler( - &_self, - order.into_inner(), - ) - .into(); + "is_nan", + |_self: Ref| { + let output: bool = bevy::math::Mat2::is_nan(&_self).into(); output }, ) .register( - "from_rotation_x", - |angle: f32| { - let output: Val = bevy::math::Mat3::from_rotation_x( - angle, - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "from_rotation_y", - |angle: f32| { - let output: Val = bevy::math::Mat3::from_rotation_y( - angle, - ) + "mul", + |_self: Val, rhs: f32| { + let output: Val = >::mul(_self.into_inner(), rhs) .into(); output }, ) .register( - "from_rotation_z", - |angle: f32| { - let output: Val = bevy::math::Mat3::from_rotation_z( - angle, - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "from_translation", - |translation: Val| { - let output: Val = bevy::math::Mat3::from_translation( - translation.into_inner(), + "mul_mat2", + |_self: Ref, rhs: Ref| { + let output: Val = bevy::math::Mat2::mul_mat2( + &_self, + &rhs, ) .into(); output }, ) .register( - "from_angle", - |angle: f32| { - let output: Val = bevy::math::Mat3::from_angle( - angle, + "mul_scalar", + |_self: Ref, rhs: f32| { + let output: Val = bevy::math::Mat2::mul_scalar( + &_self, + rhs, ) .into(); output }, ) .register( - "from_scale_angle_translation", - | - scale: Val, - angle: f32, - translation: Val| - { - let output: Val = bevy::math::Mat3::from_scale_angle_translation( - scale.into_inner(), - angle, - translation.into_inner(), + "mul_vec2", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::Mat2::mul_vec2( + &_self, + rhs.into_inner(), ) .into(); output }, ) .register( - "from_scale", - |scale: Val| { - let output: Val = bevy::math::Mat3::from_scale( - scale.into_inner(), + "neg", + |_self: Val| { + let output: Val = ::neg( + _self.into_inner(), ) .into(); output }, ) .register( - "from_mat2", - |m: Val| { - let output: Val = bevy::math::Mat3::from_mat2( - m.into_inner(), + "row", + |_self: Ref, index: usize| { + let output: Val = bevy::math::Mat2::row( + &_self, + index, ) .into(); output }, ) .register( - "col", - |_self: Ref, index: usize| { - let output: Val = bevy::math::Mat3::col( - &_self, - index, - ) + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "row", - |_self: Ref, index: usize| { - let output: Val = bevy::math::Mat3::row( + "sub_mat2", + |_self: Ref, rhs: Ref| { + let output: Val = bevy::math::Mat2::sub_mat2( &_self, - index, + &rhs, ) .into(); output }, ) .register( - "is_finite", - |_self: Ref| { - let output: bool = bevy::math::Mat3::is_finite(&_self).into(); + "to_cols_array", + |_self: Ref| { + let output: [f32; 4] = bevy::math::Mat2::to_cols_array(&_self) + .into(); output }, ) .register( - "is_nan", - |_self: Ref| { - let output: bool = bevy::math::Mat3::is_nan(&_self).into(); + "to_cols_array_2d", + |_self: Ref| { + let output: [[f32; 2]; 2] = bevy::math::Mat2::to_cols_array_2d( + &_self, + ) + .into(); output }, ) .register( "transpose", - |_self: Ref| { - let output: Val = bevy::math::Mat3::transpose( + |_self: Ref| { + let output: Val = bevy::math::Mat2::transpose( &_self, ) .into(); output }, - ) - .register( - "determinant", - |_self: Ref| { - let output: f32 = bevy::math::Mat3::determinant(&_self).into(); - output - }, - ) + ); + NamespaceBuilder::<::bevy::math::Mat3>::new(world) .register( - "inverse", + "abs", |_self: Ref| { - let output: Val = bevy::math::Mat3::inverse(&_self) + let output: Val = bevy::math::Mat3::abs(&_self) .into(); output }, ) .register( - "transform_point2", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::Mat3::transform_point2( + "abs_diff_eq", + | + _self: Ref, + rhs: Val, + max_abs_diff: f32| + { + let output: bool = bevy::math::Mat3::abs_diff_eq( &_self, rhs.into_inner(), + max_abs_diff, ) .into(); output }, ) .register( - "transform_vector2", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::Mat3::transform_vector2( - &_self, - rhs.into_inner(), - ) + "add", + |_self: Val, rhs: Val| { + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "mul_vec3", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::Mat3::mul_vec3( + "add_mat3", + |_self: Ref, rhs: Ref| { + let output: Val = bevy::math::Mat3::add_mat3( &_self, - rhs.into_inner(), + &rhs, ) .into(); output }, ) .register( - "mul_vec3a", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::Mat3::mul_vec3a( + "as_dmat3", + |_self: Ref| { + let output: Val = bevy::math::Mat3::as_dmat3( &_self, - rhs.into_inner(), ) .into(); output }, ) .register( - "mul_mat3", - |_self: Ref, rhs: Ref| { - let output: Val = bevy::math::Mat3::mul_mat3( + "clone", + |_self: Ref| { + let output: Val = ::clone( &_self, - &rhs, ) .into(); output }, ) .register( - "add_mat3", - |_self: Ref, rhs: Ref| { - let output: Val = bevy::math::Mat3::add_mat3( + "col", + |_self: Ref, index: usize| { + let output: Val = bevy::math::Mat3::col( &_self, - &rhs, + index, ) .into(); output }, ) .register( - "sub_mat3", - |_self: Ref, rhs: Ref| { - let output: Val = bevy::math::Mat3::sub_mat3( - &_self, - &rhs, - ) - .into(); + "determinant", + |_self: Ref| { + let output: f32 = bevy::math::Mat3::determinant(&_self).into(); output }, ) .register( - "mul_scalar", - |_self: Ref, rhs: f32| { - let output: Val = bevy::math::Mat3::mul_scalar( - &_self, - rhs, - ) + "div", + |_self: Val, rhs: f32| { + let output: Val = >::div(_self.into_inner(), rhs) .into(); output }, @@ -17144,165 +16891,422 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "abs_diff_eq", - | - _self: Ref, - rhs: Val, - max_abs_diff: f32| - { - let output: bool = bevy::math::Mat3::abs_diff_eq( - &_self, - rhs.into_inner(), - max_abs_diff, - ) + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = >::eq(&_self, &rhs) .into(); output }, ) .register( - "abs", - |_self: Ref| { - let output: Val = bevy::math::Mat3::abs(&_self) + "from_angle", + |angle: f32| { + let output: Val = bevy::math::Mat3::from_angle( + angle, + ) .into(); output }, ) .register( - "as_dmat3", - |_self: Ref| { - let output: Val = bevy::math::Mat3::as_dmat3( - &_self, + "from_axis_angle", + |axis: Val, angle: f32| { + let output: Val = bevy::math::Mat3::from_axis_angle( + axis.into_inner(), + angle, ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: f32| { - let output: Val = >::mul(_self.into_inner(), rhs) + "from_cols", + | + x_axis: Val, + y_axis: Val, + z_axis: Val| + { + let output: Val = bevy::math::Mat3::from_cols( + x_axis.into_inner(), + y_axis.into_inner(), + z_axis.into_inner(), + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Val| { - let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + "from_diagonal", + |diagonal: Val| { + let output: Val = bevy::math::Mat3::from_diagonal( + diagonal.into_inner(), + ) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, + "from_euler", + |order: Val, a: f32, b: f32, c: f32| { + let output: Val = bevy::math::Mat3::from_euler( + order.into_inner(), + a, + b, + c, ) .into(); output }, ) .register( - "neg", - |_self: Val| { - let output: Val = ::neg( - _self.into_inner(), + "from_mat2", + |m: Val| { + let output: Val = bevy::math::Mat3::from_mat2( + m.into_inner(), ) .into(); output }, ) .register( - "eq", - |_self: Ref, rhs: Ref| { - let output: bool = >::eq(&_self, &rhs) + "from_mat4", + |m: Val| { + let output: Val = bevy::math::Mat3::from_mat4( + m.into_inner(), + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "from_mat4_minor", + |m: Val, i: usize, j: usize| { + let output: Val = bevy::math::Mat3::from_mat4_minor( + m.into_inner(), + i, + j, + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: f32| { - let output: Val = >::div(_self.into_inner(), rhs) + "from_quat", + |rotation: Val| { + let output: Val = bevy::math::Mat3::from_quat( + rotation.into_inner(), + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "from_rotation_x", + |angle: f32| { + let output: Val = bevy::math::Mat3::from_rotation_x( + angle, + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "from_rotation_y", + |angle: f32| { + let output: Val = bevy::math::Mat3::from_rotation_y( + angle, + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "from_rotation_z", + |angle: f32| { + let output: Val = bevy::math::Mat3::from_rotation_z( + angle, + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + "from_scale", + |scale: Val| { + let output: Val = bevy::math::Mat3::from_scale( + scale.into_inner(), + ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::Mat3A>::new(world) + ) .register( - "sub", - |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) - .into(); + "from_scale_angle_translation", + | + scale: Val, + angle: f32, + translation: Val| + { + let output: Val = bevy::math::Mat3::from_scale_angle_translation( + scale.into_inner(), + angle, + translation.into_inner(), + ) + .into(); output }, ) .register( - "clone", + "from_translation", + |translation: Val| { + let output: Val = bevy::math::Mat3::from_translation( + translation.into_inner(), + ) + .into(); + output + }, + ) + .register( + "inverse", + |_self: Ref| { + let output: Val = bevy::math::Mat3::inverse(&_self) + .into(); + output + }, + ) + .register( + "is_finite", + |_self: Ref| { + let output: bool = bevy::math::Mat3::is_finite(&_self).into(); + output + }, + ) + .register( + "is_nan", + |_self: Ref| { + let output: bool = bevy::math::Mat3::is_nan(&_self).into(); + output + }, + ) + .register( + "mul", + |_self: Val, rhs: f32| { + let output: Val = >::mul(_self.into_inner(), rhs) + .into(); + output + }, + ) + .register( + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + .into(); + output + }, + ) + .register( + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + .into(); + output + }, + ) + .register( + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + .into(); + output + }, + ) + .register( + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + .into(); + output + }, + ) + .register( + "mul_mat3", + |_self: Ref, rhs: Ref| { + let output: Val = bevy::math::Mat3::mul_mat3( + &_self, + &rhs, + ) + .into(); + output + }, + ) + .register( + "mul_scalar", + |_self: Ref, rhs: f32| { + let output: Val = bevy::math::Mat3::mul_scalar( + &_self, + rhs, + ) + .into(); + output + }, + ) + .register( + "mul_vec3", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::Mat3::mul_vec3( + &_self, + rhs.into_inner(), + ) + .into(); + output + }, + ) + .register( + "mul_vec3a", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::Mat3::mul_vec3a( + &_self, + rhs.into_inner(), + ) + .into(); + output + }, + ) + .register( + "neg", + |_self: Val| { + let output: Val = ::neg( + _self.into_inner(), + ) + .into(); + output + }, + ) + .register( + "row", + |_self: Ref, index: usize| { + let output: Val = bevy::math::Mat3::row( + &_self, + index, + ) + .into(); + output + }, + ) + .register( + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + .into(); + output + }, + ) + .register( + "sub_mat3", + |_self: Ref, rhs: Ref| { + let output: Val = bevy::math::Mat3::sub_mat3( + &_self, + &rhs, + ) + .into(); + output + }, + ) + .register( + "to_cols_array", + |_self: Ref| { + let output: [f32; 9] = bevy::math::Mat3::to_cols_array(&_self) + .into(); + output + }, + ) + .register( + "to_cols_array_2d", + |_self: Ref| { + let output: [[f32; 3]; 3] = bevy::math::Mat3::to_cols_array_2d( + &_self, + ) + .into(); + output + }, + ) + .register( + "to_euler", + |_self: Ref, order: Val| { + let output: (f32, f32, f32) = bevy::math::Mat3::to_euler( + &_self, + order.into_inner(), + ) + .into(); + output + }, + ) + .register( + "transform_point2", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::Mat3::transform_point2( + &_self, + rhs.into_inner(), + ) + .into(); + output + }, + ) + .register( + "transform_vector2", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::Mat3::transform_vector2( + &_self, + rhs.into_inner(), + ) + .into(); + output + }, + ) + .register( + "transpose", + |_self: Ref| { + let output: Val = bevy::math::Mat3::transpose( + &_self, + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::Mat3A>::new(world) + .register( + "abs", |_self: Ref| { - let output: Val = ::clone( + let output: Val = bevy::math::Mat3A::abs(&_self) + .into(); + output + }, + ) + .register( + "abs_diff_eq", + | + _self: Ref, + rhs: Val, + max_abs_diff: f32| + { + let output: bool = bevy::math::Mat3A::abs_diff_eq( &_self, + rhs.into_inner(), + max_abs_diff, ) .into(); output @@ -17319,45 +17323,54 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "eq", + "add_mat3", |_self: Ref, rhs: Ref| { - let output: bool = >::eq(&_self, &rhs) + let output: Val = bevy::math::Mat3A::add_mat3( + &_self, + &rhs, + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: f32| { - let output: Val = >::mul(_self.into_inner(), rhs) + "as_dmat3", + |_self: Ref| { + let output: Val = bevy::math::Mat3A::as_dmat3( + &_self, + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) .into(); output }, ) .register( - "neg", - |_self: Val| { - let output: Val = ::neg( - _self.into_inner(), + "col", + |_self: Ref, index: usize| { + let output: Val = bevy::math::Mat3A::col( + &_self, + index, ) .into(); output }, ) + .register( + "determinant", + |_self: Ref| { + let output: f32 = bevy::math::Mat3A::determinant(&_self).into(); + output + }, + ) .register( "div", |_self: Val, rhs: f32| { @@ -17369,31 +17382,43 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "div_scalar", + |_self: Ref, rhs: f32| { + let output: Val = bevy::math::Mat3A::div_scalar( + &_self, + rhs, + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = , rhs: Ref| { + let output: bool = >::mul(_self.into_inner(), rhs.into_inner()) + >>::eq(&_self, &rhs) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "from_angle", + |angle: f32| { + let output: Val = bevy::math::Mat3A::from_angle( + angle, + ) + .into(); + output + }, + ) + .register( + "from_axis_angle", + |axis: Val, angle: f32| { + let output: Val = bevy::math::Mat3A::from_axis_angle( + axis.into_inner(), + angle, + ) .into(); output }, @@ -17415,192 +17440,259 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "to_cols_array", - |_self: Ref| { - let output: [f32; 9] = bevy::math::Mat3A::to_cols_array(&_self) + "from_diagonal", + |diagonal: Val| { + let output: Val = bevy::math::Mat3A::from_diagonal( + diagonal.into_inner(), + ) .into(); output }, ) .register( - "to_cols_array_2d", - |_self: Ref| { - let output: [[f32; 3]; 3] = bevy::math::Mat3A::to_cols_array_2d( - &_self, + "from_euler", + |order: Val, a: f32, b: f32, c: f32| { + let output: Val = bevy::math::Mat3A::from_euler( + order.into_inner(), + a, + b, + c, + ) + .into(); + output + }, + ) + .register( + "from_mat2", + |m: Val| { + let output: Val = bevy::math::Mat3A::from_mat2( + m.into_inner(), + ) + .into(); + output + }, + ) + .register( + "from_mat4", + |m: Val| { + let output: Val = bevy::math::Mat3A::from_mat4( + m.into_inner(), + ) + .into(); + output + }, + ) + .register( + "from_mat4_minor", + |m: Val, i: usize, j: usize| { + let output: Val = bevy::math::Mat3A::from_mat4_minor( + m.into_inner(), + i, + j, + ) + .into(); + output + }, + ) + .register( + "from_quat", + |rotation: Val| { + let output: Val = bevy::math::Mat3A::from_quat( + rotation.into_inner(), + ) + .into(); + output + }, + ) + .register( + "from_rotation_x", + |angle: f32| { + let output: Val = bevy::math::Mat3A::from_rotation_x( + angle, + ) + .into(); + output + }, + ) + .register( + "from_rotation_y", + |angle: f32| { + let output: Val = bevy::math::Mat3A::from_rotation_y( + angle, + ) + .into(); + output + }, + ) + .register( + "from_rotation_z", + |angle: f32| { + let output: Val = bevy::math::Mat3A::from_rotation_z( + angle, ) .into(); output }, ) .register( - "from_diagonal", - |diagonal: Val| { - let output: Val = bevy::math::Mat3A::from_diagonal( - diagonal.into_inner(), + "from_scale", + |scale: Val| { + let output: Val = bevy::math::Mat3A::from_scale( + scale.into_inner(), ) .into(); output }, ) .register( - "from_mat4", - |m: Val| { - let output: Val = bevy::math::Mat3A::from_mat4( - m.into_inner(), + "from_scale_angle_translation", + | + scale: Val, + angle: f32, + translation: Val| + { + let output: Val = bevy::math::Mat3A::from_scale_angle_translation( + scale.into_inner(), + angle, + translation.into_inner(), ) .into(); output }, ) .register( - "from_mat4_minor", - |m: Val, i: usize, j: usize| { - let output: Val = bevy::math::Mat3A::from_mat4_minor( - m.into_inner(), - i, - j, + "from_translation", + |translation: Val| { + let output: Val = bevy::math::Mat3A::from_translation( + translation.into_inner(), ) .into(); output }, ) .register( - "from_quat", - |rotation: Val| { - let output: Val = bevy::math::Mat3A::from_quat( - rotation.into_inner(), + "inverse", + |_self: Ref| { + let output: Val = bevy::math::Mat3A::inverse( + &_self, ) .into(); output }, ) .register( - "from_axis_angle", - |axis: Val, angle: f32| { - let output: Val = bevy::math::Mat3A::from_axis_angle( - axis.into_inner(), - angle, - ) - .into(); + "is_finite", + |_self: Ref| { + let output: bool = bevy::math::Mat3A::is_finite(&_self).into(); output }, ) .register( - "from_euler", - |order: Val, a: f32, b: f32, c: f32| { - let output: Val = bevy::math::Mat3A::from_euler( - order.into_inner(), - a, - b, - c, - ) - .into(); + "is_nan", + |_self: Ref| { + let output: bool = bevy::math::Mat3A::is_nan(&_self).into(); output }, ) .register( - "to_euler", - |_self: Ref, order: Val| { - let output: (f32, f32, f32) = bevy::math::Mat3A::to_euler( - &_self, - order.into_inner(), - ) + "mul", + |_self: Val, rhs: f32| { + let output: Val = >::mul(_self.into_inner(), rhs) .into(); output }, ) .register( - "from_rotation_x", - |angle: f32| { - let output: Val = bevy::math::Mat3A::from_rotation_x( - angle, - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "from_rotation_y", - |angle: f32| { - let output: Val = bevy::math::Mat3A::from_rotation_y( - angle, - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "from_rotation_z", - |angle: f32| { - let output: Val = bevy::math::Mat3A::from_rotation_z( - angle, - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "from_translation", - |translation: Val| { - let output: Val = bevy::math::Mat3A::from_translation( - translation.into_inner(), - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "from_angle", - |angle: f32| { - let output: Val = bevy::math::Mat3A::from_angle( - angle, + "mul_mat3", + |_self: Ref, rhs: Ref| { + let output: Val = bevy::math::Mat3A::mul_mat3( + &_self, + &rhs, ) .into(); output }, ) .register( - "from_scale_angle_translation", - | - scale: Val, - angle: f32, - translation: Val| - { - let output: Val = bevy::math::Mat3A::from_scale_angle_translation( - scale.into_inner(), - angle, - translation.into_inner(), + "mul_scalar", + |_self: Ref, rhs: f32| { + let output: Val = bevy::math::Mat3A::mul_scalar( + &_self, + rhs, ) .into(); output }, ) .register( - "from_scale", - |scale: Val| { - let output: Val = bevy::math::Mat3A::from_scale( - scale.into_inner(), + "mul_vec3", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::Mat3A::mul_vec3( + &_self, + rhs.into_inner(), ) .into(); output }, ) .register( - "from_mat2", - |m: Val| { - let output: Val = bevy::math::Mat3A::from_mat2( - m.into_inner(), + "mul_vec3a", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::Mat3A::mul_vec3a( + &_self, + rhs.into_inner(), ) .into(); output }, ) .register( - "col", - |_self: Ref, index: usize| { - let output: Val = bevy::math::Mat3A::col( - &_self, - index, + "neg", + |_self: Val| { + let output: Val = ::neg( + _self.into_inner(), ) .into(); output @@ -17618,41 +17710,50 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "is_finite", - |_self: Ref| { - let output: bool = bevy::math::Mat3A::is_finite(&_self).into(); + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + .into(); output }, ) .register( - "is_nan", - |_self: Ref| { - let output: bool = bevy::math::Mat3A::is_nan(&_self).into(); + "sub_mat3", + |_self: Ref, rhs: Ref| { + let output: Val = bevy::math::Mat3A::sub_mat3( + &_self, + &rhs, + ) + .into(); output }, ) .register( - "transpose", + "to_cols_array", |_self: Ref| { - let output: Val = bevy::math::Mat3A::transpose( - &_self, - ) + let output: [f32; 9] = bevy::math::Mat3A::to_cols_array(&_self) .into(); output }, ) .register( - "determinant", + "to_cols_array_2d", |_self: Ref| { - let output: f32 = bevy::math::Mat3A::determinant(&_self).into(); + let output: [[f32; 3]; 3] = bevy::math::Mat3A::to_cols_array_2d( + &_self, + ) + .into(); output }, ) .register( - "inverse", - |_self: Ref| { - let output: Val = bevy::math::Mat3A::inverse( + "to_euler", + |_self: Ref, order: Val| { + let output: (f32, f32, f32) = bevy::math::Mat3A::to_euler( &_self, + order.into_inner(), ) .into(); output @@ -17681,31 +17782,54 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "mul_vec3", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::Mat3A::mul_vec3( + "transpose", + |_self: Ref| { + let output: Val = bevy::math::Mat3A::transpose( &_self, - rhs.into_inner(), ) .into(); output }, + ); + NamespaceBuilder::<::bevy::math::Mat4>::new(world) + .register( + "abs", + |_self: Ref| { + let output: Val = bevy::math::Mat4::abs(&_self) + .into(); + output + }, ) .register( - "mul_vec3a", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::Mat3A::mul_vec3a( + "abs_diff_eq", + | + _self: Ref, + rhs: Val, + max_abs_diff: f32| + { + let output: bool = bevy::math::Mat4::abs_diff_eq( &_self, rhs.into_inner(), + max_abs_diff, ) .into(); output }, ) .register( - "mul_mat3", - |_self: Ref, rhs: Ref| { - let output: Val = bevy::math::Mat3A::mul_mat3( + "add", + |_self: Val, rhs: Val| { + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + .into(); + output + }, + ) + .register( + "add_mat4", + |_self: Ref, rhs: Ref| { + let output: Val = bevy::math::Mat4::add_mat4( &_self, &rhs, ) @@ -17714,84 +17838,85 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "add_mat3", - |_self: Ref, rhs: Ref| { - let output: Val = bevy::math::Mat3A::add_mat3( + "as_dmat4", + |_self: Ref| { + let output: Val = bevy::math::Mat4::as_dmat4( + &_self, + ) + .into(); + output + }, + ) + .register( + "clone", + |_self: Ref| { + let output: Val = ::clone( &_self, - &rhs, ) .into(); output }, ) .register( - "sub_mat3", - |_self: Ref, rhs: Ref| { - let output: Val = bevy::math::Mat3A::sub_mat3( + "col", + |_self: Ref, index: usize| { + let output: Val = bevy::math::Mat4::col( &_self, - &rhs, + index, ) .into(); output }, ) .register( - "mul_scalar", - |_self: Ref, rhs: f32| { - let output: Val = bevy::math::Mat3A::mul_scalar( - &_self, - rhs, - ) - .into(); + "determinant", + |_self: Ref| { + let output: f32 = bevy::math::Mat4::determinant(&_self).into(); output }, ) .register( - "div_scalar", - |_self: Ref, rhs: f32| { - let output: Val = bevy::math::Mat3A::div_scalar( - &_self, - rhs, - ) + "div", + |_self: Val, rhs: f32| { + let output: Val = >::div(_self.into_inner(), rhs) .into(); output }, ) .register( - "abs_diff_eq", - | - _self: Ref, - rhs: Val, - max_abs_diff: f32| - { - let output: bool = bevy::math::Mat3A::abs_diff_eq( + "div_scalar", + |_self: Ref, rhs: f32| { + let output: Val = bevy::math::Mat4::div_scalar( &_self, - rhs.into_inner(), - max_abs_diff, + rhs, ) .into(); output }, ) .register( - "abs", - |_self: Ref| { - let output: Val = bevy::math::Mat3A::abs(&_self) + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = >::eq(&_self, &rhs) .into(); output }, ) .register( - "as_dmat3", - |_self: Ref| { - let output: Val = bevy::math::Mat3A::as_dmat3( - &_self, + "from_axis_angle", + |axis: Val, angle: f32| { + let output: Val = bevy::math::Mat4::from_axis_angle( + axis.into_inner(), + angle, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::Mat4>::new(world) + ) .register( "from_cols", | @@ -17810,24 +17935,6 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { output }, ) - .register( - "to_cols_array", - |_self: Ref| { - let output: [f32; 16] = bevy::math::Mat4::to_cols_array(&_self) - .into(); - output - }, - ) - .register( - "to_cols_array_2d", - |_self: Ref| { - let output: [[f32; 4]; 4] = bevy::math::Mat4::to_cols_array_2d( - &_self, - ) - .into(); - output - }, - ) .register( "from_diagonal", |diagonal: Val| { @@ -17839,37 +17946,13 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_scale_rotation_translation", - | - scale: Val, - rotation: Val, - translation: Val| - { - let output: Val = bevy::math::Mat4::from_scale_rotation_translation( - scale.into_inner(), - rotation.into_inner(), - translation.into_inner(), - ) - .into(); - output - }, - ) - .register( - "from_rotation_translation", - |rotation: Val, translation: Val| { - let output: Val = bevy::math::Mat4::from_rotation_translation( - rotation.into_inner(), - translation.into_inner(), - ) - .into(); - output - }, - ) - .register( - "from_quat", - |rotation: Val| { - let output: Val = bevy::math::Mat4::from_quat( - rotation.into_inner(), + "from_euler", + |order: Val, a: f32, b: f32, c: f32| { + let output: Val = bevy::math::Mat4::from_euler( + order.into_inner(), + a, + b, + c, ) .into(); output @@ -17896,45 +17979,21 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_translation", - |translation: Val| { - let output: Val = bevy::math::Mat4::from_translation( - translation.into_inner(), - ) - .into(); - output - }, - ) - .register( - "from_axis_angle", - |axis: Val, angle: f32| { - let output: Val = bevy::math::Mat4::from_axis_angle( - axis.into_inner(), - angle, - ) - .into(); - output - }, - ) - .register( - "from_euler", - |order: Val, a: f32, b: f32, c: f32| { - let output: Val = bevy::math::Mat4::from_euler( - order.into_inner(), - a, - b, - c, + "from_quat", + |rotation: Val| { + let output: Val = bevy::math::Mat4::from_quat( + rotation.into_inner(), ) .into(); output }, ) .register( - "to_euler", - |_self: Ref, order: Val| { - let output: (f32, f32, f32) = bevy::math::Mat4::to_euler( - &_self, - order.into_inner(), + "from_rotation_translation", + |rotation: Val, translation: Val| { + let output: Val = bevy::math::Mat4::from_rotation_translation( + rotation.into_inner(), + translation.into_inner(), ) .into(); output @@ -17981,76 +18040,63 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "col", - |_self: Ref, index: usize| { - let output: Val = bevy::math::Mat4::col( - &_self, - index, + "from_scale_rotation_translation", + | + scale: Val, + rotation: Val, + translation: Val| + { + let output: Val = bevy::math::Mat4::from_scale_rotation_translation( + scale.into_inner(), + rotation.into_inner(), + translation.into_inner(), ) .into(); output }, ) .register( - "row", - |_self: Ref, index: usize| { - let output: Val = bevy::math::Mat4::row( - &_self, - index, + "from_translation", + |translation: Val| { + let output: Val = bevy::math::Mat4::from_translation( + translation.into_inner(), ) .into(); output }, ) .register( - "is_finite", - |_self: Ref| { - let output: bool = bevy::math::Mat4::is_finite(&_self).into(); - output - }, - ) - .register( - "is_nan", - |_self: Ref| { - let output: bool = bevy::math::Mat4::is_nan(&_self).into(); - output - }, - ) - .register( - "transpose", + "inverse", |_self: Ref| { - let output: Val = bevy::math::Mat4::transpose( - &_self, - ) + let output: Val = bevy::math::Mat4::inverse(&_self) .into(); output }, ) .register( - "determinant", + "is_finite", |_self: Ref| { - let output: f32 = bevy::math::Mat4::determinant(&_self).into(); + let output: bool = bevy::math::Mat4::is_finite(&_self).into(); output }, ) .register( - "inverse", + "is_nan", |_self: Ref| { - let output: Val = bevy::math::Mat4::inverse(&_self) - .into(); + let output: bool = bevy::math::Mat4::is_nan(&_self).into(); output }, ) .register( - "look_to_lh", + "look_at_lh", | eye: Val, - dir: Val, + center: Val, up: Val| { - let output: Val = bevy::math::Mat4::look_to_lh( + let output: Val = bevy::math::Mat4::look_at_lh( eye.into_inner(), - dir.into_inner(), + center.into_inner(), up.into_inner(), ) .into(); @@ -18058,15 +18104,15 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "look_to_rh", + "look_at_rh", | eye: Val, - dir: Val, + center: Val, up: Val| { - let output: Val = bevy::math::Mat4::look_to_rh( + let output: Val = bevy::math::Mat4::look_at_rh( eye.into_inner(), - dir.into_inner(), + center.into_inner(), up.into_inner(), ) .into(); @@ -18074,15 +18120,15 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "look_at_lh", + "look_to_lh", | eye: Val, - center: Val, + dir: Val, up: Val| { - let output: Val = bevy::math::Mat4::look_at_lh( + let output: Val = bevy::math::Mat4::look_to_lh( eye.into_inner(), - center.into_inner(), + dir.into_inner(), up.into_inner(), ) .into(); @@ -18090,15 +18136,15 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "look_at_rh", + "look_to_rh", | eye: Val, - center: Val, + dir: Val, up: Val| { - let output: Val = bevy::math::Mat4::look_at_rh( + let output: Val = bevy::math::Mat4::look_to_rh( eye.into_inner(), - center.into_inner(), + dir.into_inner(), up.into_inner(), ) .into(); @@ -18106,96 +18152,92 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "perspective_rh_gl", - |fov_y_radians: f32, aspect_ratio: f32, z_near: f32, z_far: f32| { - let output: Val = bevy::math::Mat4::perspective_rh_gl( - fov_y_radians, - aspect_ratio, - z_near, - z_far, - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + .into(); + output + }, + ) + .register( + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "perspective_lh", - |fov_y_radians: f32, aspect_ratio: f32, z_near: f32, z_far: f32| { - let output: Val = bevy::math::Mat4::perspective_lh( - fov_y_radians, - aspect_ratio, - z_near, - z_far, - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "perspective_rh", - |fov_y_radians: f32, aspect_ratio: f32, z_near: f32, z_far: f32| { - let output: Val = bevy::math::Mat4::perspective_rh( - fov_y_radians, - aspect_ratio, - z_near, - z_far, - ) + "mul", + |_self: Val, rhs: f32| { + let output: Val = >::mul(_self.into_inner(), rhs) .into(); output }, ) .register( - "perspective_infinite_lh", - |fov_y_radians: f32, aspect_ratio: f32, z_near: f32| { - let output: Val = bevy::math::Mat4::perspective_infinite_lh( - fov_y_radians, - aspect_ratio, - z_near, + "mul_mat4", + |_self: Ref, rhs: Ref| { + let output: Val = bevy::math::Mat4::mul_mat4( + &_self, + &rhs, ) .into(); output }, ) .register( - "perspective_infinite_reverse_lh", - |fov_y_radians: f32, aspect_ratio: f32, z_near: f32| { - let output: Val = bevy::math::Mat4::perspective_infinite_reverse_lh( - fov_y_radians, - aspect_ratio, - z_near, + "mul_scalar", + |_self: Ref, rhs: f32| { + let output: Val = bevy::math::Mat4::mul_scalar( + &_self, + rhs, ) .into(); output }, ) .register( - "perspective_infinite_rh", - |fov_y_radians: f32, aspect_ratio: f32, z_near: f32| { - let output: Val = bevy::math::Mat4::perspective_infinite_rh( - fov_y_radians, - aspect_ratio, - z_near, + "mul_vec4", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::Mat4::mul_vec4( + &_self, + rhs.into_inner(), ) .into(); output }, ) .register( - "perspective_infinite_reverse_rh", - |fov_y_radians: f32, aspect_ratio: f32, z_near: f32| { - let output: Val = bevy::math::Mat4::perspective_infinite_reverse_rh( - fov_y_radians, - aspect_ratio, - z_near, + "neg", + |_self: Val| { + let output: Val = ::neg( + _self.into_inner(), ) .into(); output }, ) .register( - "orthographic_rh_gl", + "orthographic_lh", |left: f32, right: f32, bottom: f32, top: f32, near: f32, far: f32| { - let output: Val = bevy::math::Mat4::orthographic_rh_gl( + let output: Val = bevy::math::Mat4::orthographic_lh( left, right, bottom, @@ -18208,9 +18250,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "orthographic_lh", + "orthographic_rh", |left: f32, right: f32, bottom: f32, top: f32, near: f32, far: f32| { - let output: Val = bevy::math::Mat4::orthographic_lh( + let output: Val = bevy::math::Mat4::orthographic_rh( left, right, bottom, @@ -18223,9 +18265,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "orthographic_rh", + "orthographic_rh_gl", |left: f32, right: f32, bottom: f32, top: f32, near: f32, far: f32| { - let output: Val = bevy::math::Mat4::orthographic_rh( + let output: Val = bevy::math::Mat4::orthographic_rh_gl( left, right, bottom, @@ -18238,272 +18280,285 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "project_point3", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::Mat4::project_point3( - &_self, - rhs.into_inner(), + "perspective_infinite_lh", + |fov_y_radians: f32, aspect_ratio: f32, z_near: f32| { + let output: Val = bevy::math::Mat4::perspective_infinite_lh( + fov_y_radians, + aspect_ratio, + z_near, ) .into(); output }, ) .register( - "transform_point3", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::Mat4::transform_point3( - &_self, - rhs.into_inner(), + "perspective_infinite_reverse_lh", + |fov_y_radians: f32, aspect_ratio: f32, z_near: f32| { + let output: Val = bevy::math::Mat4::perspective_infinite_reverse_lh( + fov_y_radians, + aspect_ratio, + z_near, ) .into(); output }, ) .register( - "transform_vector3", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::Mat4::transform_vector3( - &_self, - rhs.into_inner(), + "perspective_infinite_reverse_rh", + |fov_y_radians: f32, aspect_ratio: f32, z_near: f32| { + let output: Val = bevy::math::Mat4::perspective_infinite_reverse_rh( + fov_y_radians, + aspect_ratio, + z_near, ) .into(); output }, ) .register( - "project_point3a", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::Mat4::project_point3a( - &_self, - rhs.into_inner(), + "perspective_infinite_rh", + |fov_y_radians: f32, aspect_ratio: f32, z_near: f32| { + let output: Val = bevy::math::Mat4::perspective_infinite_rh( + fov_y_radians, + aspect_ratio, + z_near, ) .into(); output }, ) .register( - "transform_point3a", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::Mat4::transform_point3a( - &_self, - rhs.into_inner(), + "perspective_lh", + |fov_y_radians: f32, aspect_ratio: f32, z_near: f32, z_far: f32| { + let output: Val = bevy::math::Mat4::perspective_lh( + fov_y_radians, + aspect_ratio, + z_near, + z_far, ) .into(); output }, ) .register( - "transform_vector3a", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::Mat4::transform_vector3a( - &_self, - rhs.into_inner(), + "perspective_rh", + |fov_y_radians: f32, aspect_ratio: f32, z_near: f32, z_far: f32| { + let output: Val = bevy::math::Mat4::perspective_rh( + fov_y_radians, + aspect_ratio, + z_near, + z_far, ) .into(); output }, ) .register( - "mul_vec4", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::Mat4::mul_vec4( - &_self, - rhs.into_inner(), + "perspective_rh_gl", + |fov_y_radians: f32, aspect_ratio: f32, z_near: f32, z_far: f32| { + let output: Val = bevy::math::Mat4::perspective_rh_gl( + fov_y_radians, + aspect_ratio, + z_near, + z_far, ) .into(); output }, ) .register( - "mul_mat4", - |_self: Ref, rhs: Ref| { - let output: Val = bevy::math::Mat4::mul_mat4( + "project_point3", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::Mat4::project_point3( &_self, - &rhs, + rhs.into_inner(), ) .into(); output }, ) .register( - "add_mat4", - |_self: Ref, rhs: Ref| { - let output: Val = bevy::math::Mat4::add_mat4( + "project_point3a", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::Mat4::project_point3a( &_self, - &rhs, + rhs.into_inner(), ) .into(); output }, ) .register( - "sub_mat4", - |_self: Ref, rhs: Ref| { - let output: Val = bevy::math::Mat4::sub_mat4( + "row", + |_self: Ref, index: usize| { + let output: Val = bevy::math::Mat4::row( &_self, - &rhs, + index, ) .into(); output }, ) .register( - "mul_scalar", - |_self: Ref, rhs: f32| { - let output: Val = bevy::math::Mat4::mul_scalar( - &_self, - rhs, - ) + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "div_scalar", - |_self: Ref, rhs: f32| { - let output: Val = bevy::math::Mat4::div_scalar( + "sub_mat4", + |_self: Ref, rhs: Ref| { + let output: Val = bevy::math::Mat4::sub_mat4( &_self, - rhs, + &rhs, ) .into(); output }, ) .register( - "abs_diff_eq", - | - _self: Ref, - rhs: Val, - max_abs_diff: f32| - { - let output: bool = bevy::math::Mat4::abs_diff_eq( - &_self, - rhs.into_inner(), - max_abs_diff, - ) + "to_cols_array", + |_self: Ref| { + let output: [f32; 16] = bevy::math::Mat4::to_cols_array(&_self) .into(); output }, ) .register( - "abs", + "to_cols_array_2d", |_self: Ref| { - let output: Val = bevy::math::Mat4::abs(&_self) + let output: [[f32; 4]; 4] = bevy::math::Mat4::to_cols_array_2d( + &_self, + ) .into(); output }, ) .register( - "as_dmat4", - |_self: Ref| { - let output: Val = bevy::math::Mat4::as_dmat4( + "to_euler", + |_self: Ref, order: Val| { + let output: (f32, f32, f32) = bevy::math::Mat4::to_euler( &_self, + order.into_inner(), ) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( + "transform_point3", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::Mat4::transform_point3( &_self, + rhs.into_inner(), ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "transform_point3a", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::Mat4::transform_point3a( + &_self, + rhs.into_inner(), + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "transform_vector3", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::Mat4::transform_vector3( + &_self, + rhs.into_inner(), + ) .into(); output }, ) .register( - "eq", - |_self: Ref, rhs: Ref| { - let output: bool = >::eq(&_self, &rhs) + "transform_vector3a", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::Mat4::transform_vector3a( + &_self, + rhs.into_inner(), + ) .into(); output }, ) .register( - "neg", - |_self: Val| { - let output: Val = ::neg( - _self.into_inner(), + "transpose", + |_self: Ref| { + let output: Val = bevy::math::Mat4::transpose( + &_self, ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::DMat2>::new(world) .register( - "sub", - |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + "abs", + |_self: Ref| { + let output: Val = bevy::math::DMat2::abs(&_self) .into(); output }, ) .register( - "div", - |_self: Val, rhs: f32| { - let output: Val = >::div(_self.into_inner(), rhs) + "abs_diff_eq", + | + _self: Ref, + rhs: Val, + max_abs_diff: f64| + { + let output: bool = bevy::math::DMat2::abs_diff_eq( + &_self, + rhs.into_inner(), + max_abs_diff, + ) .into(); output }, ) .register( "add", - |_self: Val, rhs: Val| { - let output: Val = , rhs: Val| { + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "add_mat2", + |_self: Ref, rhs: Ref| { + let output: Val = bevy::math::DMat2::add_mat2( + &_self, + &rhs, + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: f32| { - let output: Val = >::mul(_self.into_inner(), rhs) + "as_mat2", + |_self: Ref| { + let output: Val = bevy::math::DMat2::as_mat2( + &_self, + ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::DMat2>::new(world) + ) .register( "clone", |_self: Ref| { @@ -18515,51 +18570,50 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_cols", - |x_axis: Val, y_axis: Val| { - let output: Val = bevy::math::DMat2::from_cols( - x_axis.into_inner(), - y_axis.into_inner(), + "col", + |_self: Ref, index: usize| { + let output: Val = bevy::math::DMat2::col( + &_self, + index, ) .into(); output }, ) .register( - "to_cols_array", + "determinant", |_self: Ref| { - let output: [f64; 4] = bevy::math::DMat2::to_cols_array(&_self) - .into(); + let output: f64 = bevy::math::DMat2::determinant(&_self).into(); output }, ) .register( - "to_cols_array_2d", - |_self: Ref| { - let output: [[f64; 2]; 2] = bevy::math::DMat2::to_cols_array_2d( - &_self, - ) + "div", + |_self: Val, rhs: f64| { + let output: Val = >::div(_self.into_inner(), rhs) .into(); output }, ) .register( - "from_diagonal", - |diagonal: Val| { - let output: Val = bevy::math::DMat2::from_diagonal( - diagonal.into_inner(), + "div_scalar", + |_self: Ref, rhs: f64| { + let output: Val = bevy::math::DMat2::div_scalar( + &_self, + rhs, ) .into(); output }, ) .register( - "from_scale_angle", - |scale: Val, angle: f64| { - let output: Val = bevy::math::DMat2::from_scale_angle( - scale.into_inner(), - angle, - ) + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = >::eq(&_self, &rhs) .into(); output }, @@ -18574,6 +18628,27 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { output }, ) + .register( + "from_cols", + |x_axis: Val, y_axis: Val| { + let output: Val = bevy::math::DMat2::from_cols( + x_axis.into_inner(), + y_axis.into_inner(), + ) + .into(); + output + }, + ) + .register( + "from_diagonal", + |diagonal: Val| { + let output: Val = bevy::math::DMat2::from_diagonal( + diagonal.into_inner(), + ) + .into(); + output + }, + ) .register( "from_mat3", |m: Val| { @@ -18597,22 +18672,21 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "col", - |_self: Ref, index: usize| { - let output: Val = bevy::math::DMat2::col( - &_self, - index, + "from_scale_angle", + |scale: Val, angle: f64| { + let output: Val = bevy::math::DMat2::from_scale_angle( + scale.into_inner(), + angle, ) .into(); output }, ) .register( - "row", - |_self: Ref, index: usize| { - let output: Val = bevy::math::DMat2::row( + "inverse", + |_self: Ref| { + let output: Val = bevy::math::DMat2::inverse( &_self, - index, ) .into(); output @@ -18633,27 +18707,52 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "transpose", - |_self: Ref| { - let output: Val = bevy::math::DMat2::transpose( - &_self, - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "determinant", - |_self: Ref| { - let output: f64 = bevy::math::DMat2::determinant(&_self).into(); + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + .into(); output }, ) .register( - "inverse", - |_self: Ref| { - let output: Val = bevy::math::DMat2::inverse( + "mul", + |_self: Val, rhs: f64| { + let output: Val = >::mul(_self.into_inner(), rhs) + .into(); + output + }, + ) + .register( + "mul_mat2", + |_self: Ref, rhs: Ref| { + let output: Val = bevy::math::DMat2::mul_mat2( + &_self, + &rhs, + ) + .into(); + output + }, + ) + .register( + "mul_scalar", + |_self: Ref, rhs: f64| { + let output: Val = bevy::math::DMat2::mul_scalar( &_self, + rhs, ) .into(); output @@ -18671,27 +18770,36 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "mul_mat2", - |_self: Ref, rhs: Ref| { - let output: Val = bevy::math::DMat2::mul_mat2( - &_self, - &rhs, + "neg", + |_self: Val| { + let output: Val = ::neg( + _self.into_inner(), ) .into(); output }, ) .register( - "add_mat2", - |_self: Ref, rhs: Ref| { - let output: Val = bevy::math::DMat2::add_mat2( + "row", + |_self: Ref, index: usize| { + let output: Val = bevy::math::DMat2::row( &_self, - &rhs, + index, ) .into(); output }, ) + .register( + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + .into(); + output + }, + ) .register( "sub_mat2", |_self: Ref, rhs: Ref| { @@ -18704,148 +18812,134 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "mul_scalar", - |_self: Ref, rhs: f64| { - let output: Val = bevy::math::DMat2::mul_scalar( - &_self, - rhs, - ) + "to_cols_array", + |_self: Ref| { + let output: [f64; 4] = bevy::math::DMat2::to_cols_array(&_self) .into(); output }, ) .register( - "div_scalar", - |_self: Ref, rhs: f64| { - let output: Val = bevy::math::DMat2::div_scalar( + "to_cols_array_2d", + |_self: Ref| { + let output: [[f64; 2]; 2] = bevy::math::DMat2::to_cols_array_2d( &_self, - rhs, ) .into(); output }, ) .register( - "abs_diff_eq", - | - _self: Ref, - rhs: Val, - max_abs_diff: f64| - { - let output: bool = bevy::math::DMat2::abs_diff_eq( + "transpose", + |_self: Ref| { + let output: Val = bevy::math::DMat2::transpose( &_self, - rhs.into_inner(), - max_abs_diff, ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::DMat3>::new(world) .register( "abs", - |_self: Ref| { - let output: Val = bevy::math::DMat2::abs(&_self) + |_self: Ref| { + let output: Val = bevy::math::DMat3::abs(&_self) .into(); output }, ) .register( - "as_mat2", - |_self: Ref| { - let output: Val = bevy::math::DMat2::as_mat2( + "abs_diff_eq", + | + _self: Ref, + rhs: Val, + max_abs_diff: f64| + { + let output: bool = bevy::math::DMat3::abs_diff_eq( &_self, + rhs.into_inner(), + max_abs_diff, ) .into(); output }, ) - .register( - "div", - |_self: Val, rhs: f64| { - let output: Val = >::div(_self.into_inner(), rhs) - .into(); - output - }, - ) .register( "add", - |_self: Val, rhs: Val| { - let output: Val = , rhs: Val| { + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "add_mat3", + |_self: Ref, rhs: Ref| { + let output: Val = bevy::math::DMat3::add_mat3( + &_self, + &rhs, + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "as_mat3", + |_self: Ref| { + let output: Val = bevy::math::DMat3::as_mat3( + &_self, + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: f64| { - let output: Val = >::mul(_self.into_inner(), rhs) + "col", + |_self: Ref, index: usize| { + let output: Val = bevy::math::DMat3::col( + &_self, + index, + ) .into(); output }, ) .register( - "neg", - |_self: Val| { - let output: Val = ::neg( - _self.into_inner(), - ) - .into(); + "determinant", + |_self: Ref| { + let output: f64 = bevy::math::DMat3::determinant(&_self).into(); output }, ) .register( - "eq", - |_self: Ref, rhs: Ref| { - let output: bool = >::eq(&_self, &rhs) + "div", + |_self: Val, rhs: f64| { + let output: Val = >::div(_self.into_inner(), rhs) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::DMat3>::new(world) + ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "div_scalar", + |_self: Ref, rhs: f64| { + let output: Val = bevy::math::DMat3::div_scalar( + &_self, + rhs, + ) .into(); output }, @@ -18861,21 +18955,22 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "add", - |_self: Val, rhs: Val| { - let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + "from_angle", + |angle: f64| { + let output: Val = bevy::math::DMat3::from_angle( + angle, + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + "from_axis_angle", + |axis: Val, angle: f64| { + let output: Val = bevy::math::DMat3::from_axis_angle( + axis.into_inner(), + angle, + ) .into(); output }, @@ -18897,28 +18992,33 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "to_cols_array", - |_self: Ref| { - let output: [f64; 9] = bevy::math::DMat3::to_cols_array(&_self) + "from_diagonal", + |diagonal: Val| { + let output: Val = bevy::math::DMat3::from_diagonal( + diagonal.into_inner(), + ) .into(); output }, ) .register( - "to_cols_array_2d", - |_self: Ref| { - let output: [[f64; 3]; 3] = bevy::math::DMat3::to_cols_array_2d( - &_self, + "from_euler", + |order: Val, a: f64, b: f64, c: f64| { + let output: Val = bevy::math::DMat3::from_euler( + order.into_inner(), + a, + b, + c, ) .into(); output }, ) .register( - "from_diagonal", - |diagonal: Val| { - let output: Val = bevy::math::DMat3::from_diagonal( - diagonal.into_inner(), + "from_mat2", + |m: Val| { + let output: Val = bevy::math::DMat3::from_mat2( + m.into_inner(), ) .into(); output @@ -18956,85 +19056,20 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { output }, ) - .register( - "from_axis_angle", - |axis: Val, angle: f64| { - let output: Val = bevy::math::DMat3::from_axis_angle( - axis.into_inner(), - angle, - ) - .into(); - output - }, - ) - .register( - "from_euler", - |order: Val, a: f64, b: f64, c: f64| { - let output: Val = bevy::math::DMat3::from_euler( - order.into_inner(), - a, - b, - c, - ) - .into(); - output - }, - ) - .register( - "to_euler", - |_self: Ref, order: Val| { - let output: (f64, f64, f64) = bevy::math::DMat3::to_euler( - &_self, - order.into_inner(), - ) - .into(); - output - }, - ) - .register( - "from_rotation_x", - |angle: f64| { - let output: Val = bevy::math::DMat3::from_rotation_x( - angle, - ) - .into(); - output - }, - ) - .register( - "from_rotation_y", - |angle: f64| { - let output: Val = bevy::math::DMat3::from_rotation_y( - angle, - ) - .into(); - output - }, - ) - .register( - "from_rotation_z", - |angle: f64| { - let output: Val = bevy::math::DMat3::from_rotation_z( - angle, - ) - .into(); - output - }, - ) - .register( - "from_translation", - |translation: Val| { - let output: Val = bevy::math::DMat3::from_translation( - translation.into_inner(), + .register( + "from_rotation_x", + |angle: f64| { + let output: Val = bevy::math::DMat3::from_rotation_x( + angle, ) .into(); output }, ) .register( - "from_angle", + "from_rotation_y", |angle: f64| { - let output: Val = bevy::math::DMat3::from_angle( + let output: Val = bevy::math::DMat3::from_rotation_y( angle, ) .into(); @@ -19042,16 +19077,10 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_scale_angle_translation", - | - scale: Val, - angle: f64, - translation: Val| - { - let output: Val = bevy::math::DMat3::from_scale_angle_translation( - scale.into_inner(), + "from_rotation_z", + |angle: f64| { + let output: Val = bevy::math::DMat3::from_rotation_z( angle, - translation.into_inner(), ) .into(); output @@ -19068,32 +19097,36 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_mat2", - |m: Val| { - let output: Val = bevy::math::DMat3::from_mat2( - m.into_inner(), + "from_scale_angle_translation", + | + scale: Val, + angle: f64, + translation: Val| + { + let output: Val = bevy::math::DMat3::from_scale_angle_translation( + scale.into_inner(), + angle, + translation.into_inner(), ) .into(); output }, ) .register( - "col", - |_self: Ref, index: usize| { - let output: Val = bevy::math::DMat3::col( - &_self, - index, + "from_translation", + |translation: Val| { + let output: Val = bevy::math::DMat3::from_translation( + translation.into_inner(), ) .into(); output }, ) .register( - "row", - |_self: Ref, index: usize| { - let output: Val = bevy::math::DMat3::row( + "inverse", + |_self: Ref| { + let output: Val = bevy::math::DMat3::inverse( &_self, - index, ) .into(); output @@ -19114,49 +19147,62 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "transpose", - |_self: Ref| { - let output: Val = bevy::math::DMat3::transpose( - &_self, - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "determinant", - |_self: Ref| { - let output: f64 = bevy::math::DMat3::determinant(&_self).into(); + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + .into(); output }, ) .register( - "inverse", - |_self: Ref| { - let output: Val = bevy::math::DMat3::inverse( - &_self, - ) + "mul", + |_self: Val, rhs: f64| { + let output: Val = >::mul(_self.into_inner(), rhs) .into(); output }, ) .register( - "transform_point2", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::DMat3::transform_point2( + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + .into(); + output + }, + ) + .register( + "mul_mat3", + |_self: Ref, rhs: Ref| { + let output: Val = bevy::math::DMat3::mul_mat3( &_self, - rhs.into_inner(), + &rhs, ) .into(); output }, ) .register( - "transform_vector2", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::DMat3::transform_vector2( + "mul_scalar", + |_self: Ref, rhs: f64| { + let output: Val = bevy::math::DMat3::mul_scalar( &_self, - rhs.into_inner(), + rhs, ) .into(); output @@ -19174,27 +19220,36 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "mul_mat3", - |_self: Ref, rhs: Ref| { - let output: Val = bevy::math::DMat3::mul_mat3( - &_self, - &rhs, + "neg", + |_self: Val| { + let output: Val = ::neg( + _self.into_inner(), ) .into(); output }, ) .register( - "add_mat3", - |_self: Ref, rhs: Ref| { - let output: Val = bevy::math::DMat3::add_mat3( + "row", + |_self: Ref, index: usize| { + let output: Val = bevy::math::DMat3::row( &_self, - &rhs, + index, ) .into(); output }, ) + .register( + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + .into(); + output + }, + ) .register( "sub_mat3", |_self: Ref, rhs: Ref| { @@ -19207,35 +19262,83 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "mul_scalar", - |_self: Ref, rhs: f64| { - let output: Val = bevy::math::DMat3::mul_scalar( + "to_cols_array", + |_self: Ref| { + let output: [f64; 9] = bevy::math::DMat3::to_cols_array(&_self) + .into(); + output + }, + ) + .register( + "to_cols_array_2d", + |_self: Ref| { + let output: [[f64; 3]; 3] = bevy::math::DMat3::to_cols_array_2d( &_self, - rhs, ) .into(); output }, ) .register( - "div_scalar", - |_self: Ref, rhs: f64| { - let output: Val = bevy::math::DMat3::div_scalar( + "to_euler", + |_self: Ref, order: Val| { + let output: (f64, f64, f64) = bevy::math::DMat3::to_euler( + &_self, + order.into_inner(), + ) + .into(); + output + }, + ) + .register( + "transform_point2", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::DMat3::transform_point2( + &_self, + rhs.into_inner(), + ) + .into(); + output + }, + ) + .register( + "transform_vector2", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::DMat3::transform_vector2( + &_self, + rhs.into_inner(), + ) + .into(); + output + }, + ) + .register( + "transpose", + |_self: Ref| { + let output: Val = bevy::math::DMat3::transpose( &_self, - rhs, ) .into(); output }, + ); + NamespaceBuilder::<::bevy::math::DMat4>::new(world) + .register( + "abs", + |_self: Ref| { + let output: Val = bevy::math::DMat4::abs(&_self) + .into(); + output + }, ) .register( "abs_diff_eq", | - _self: Ref, - rhs: Val, + _self: Ref, + rhs: Val, max_abs_diff: f64| { - let output: bool = bevy::math::DMat3::abs_diff_eq( + let output: bool = bevy::math::DMat4::abs_diff_eq( &_self, rhs.into_inner(), max_abs_diff, @@ -19245,100 +19348,102 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "abs", - |_self: Ref| { - let output: Val = bevy::math::DMat3::abs(&_self) + "add", + |_self: Val, rhs: Val| { + let output: Val = >::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "as_mat3", - |_self: Ref| { - let output: Val = bevy::math::DMat3::as_mat3( + "add_mat4", + |_self: Ref, rhs: Ref| { + let output: Val = bevy::math::DMat4::add_mat4( &_self, + &rhs, ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "as_mat4", + |_self: Ref| { + let output: Val = bevy::math::DMat4::as_mat4( + &_self, + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: f64| { - let output: Val = >::mul(_self.into_inner(), rhs) + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) .into(); output }, ) .register( - "div", - |_self: Val, rhs: f64| { - let output: Val = >::div(_self.into_inner(), rhs) + "col", + |_self: Ref, index: usize| { + let output: Val = bevy::math::DMat4::col( + &_self, + index, + ) .into(); output }, ) - .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) - .into(); + .register( + "determinant", + |_self: Ref| { + let output: f64 = bevy::math::DMat4::determinant(&_self).into(); output }, ) .register( - "neg", - |_self: Val| { - let output: Val = ::neg( - _self.into_inner(), - ) + "div", + |_self: Val, rhs: f64| { + let output: Val = >::div(_self.into_inner(), rhs) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( + "div_scalar", + |_self: Ref, rhs: f64| { + let output: Val = bevy::math::DMat4::div_scalar( &_self, + rhs, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::DMat4>::new(world) + ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = , rhs: Ref| { + let output: bool = >::mul(_self.into_inner(), rhs.into_inner()) + >>::eq(&_self, &rhs) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "from_axis_angle", + |axis: Val, angle: f64| { + let output: Val = bevy::math::DMat4::from_axis_angle( + axis.into_inner(), + angle, + ) .into(); output }, @@ -19361,24 +19466,6 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { output }, ) - .register( - "to_cols_array", - |_self: Ref| { - let output: [f64; 16] = bevy::math::DMat4::to_cols_array(&_self) - .into(); - output - }, - ) - .register( - "to_cols_array_2d", - |_self: Ref| { - let output: [[f64; 4]; 4] = bevy::math::DMat4::to_cols_array_2d( - &_self, - ) - .into(); - output - }, - ) .register( "from_diagonal", |diagonal: Val| { @@ -19390,27 +19477,23 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_scale_rotation_translation", - | - scale: Val, - rotation: Val, - translation: Val| - { - let output: Val = bevy::math::DMat4::from_scale_rotation_translation( - scale.into_inner(), - rotation.into_inner(), - translation.into_inner(), + "from_euler", + |order: Val, a: f64, b: f64, c: f64| { + let output: Val = bevy::math::DMat4::from_euler( + order.into_inner(), + a, + b, + c, ) .into(); output }, ) .register( - "from_rotation_translation", - |rotation: Val, translation: Val| { - let output: Val = bevy::math::DMat4::from_rotation_translation( - rotation.into_inner(), - translation.into_inner(), + "from_mat3", + |m: Val| { + let output: Val = bevy::math::DMat4::from_mat3( + m.into_inner(), ) .into(); output @@ -19427,60 +19510,16 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_mat3", - |m: Val| { - let output: Val = bevy::math::DMat4::from_mat3( - m.into_inner(), - ) - .into(); - output - }, - ) - .register( - "from_translation", - |translation: Val| { - let output: Val = bevy::math::DMat4::from_translation( + "from_rotation_translation", + |rotation: Val, translation: Val| { + let output: Val = bevy::math::DMat4::from_rotation_translation( + rotation.into_inner(), translation.into_inner(), ) .into(); output }, ) - .register( - "from_axis_angle", - |axis: Val, angle: f64| { - let output: Val = bevy::math::DMat4::from_axis_angle( - axis.into_inner(), - angle, - ) - .into(); - output - }, - ) - .register( - "from_euler", - |order: Val, a: f64, b: f64, c: f64| { - let output: Val = bevy::math::DMat4::from_euler( - order.into_inner(), - a, - b, - c, - ) - .into(); - output - }, - ) - .register( - "to_euler", - |_self: Ref, order: Val| { - let output: (f64, f64, f64) = bevy::math::DMat4::to_euler( - &_self, - order.into_inner(), - ) - .into(); - output - }, - ) .register( "from_rotation_x", |angle: f64| { @@ -19522,45 +19561,35 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "col", - |_self: Ref, index: usize| { - let output: Val = bevy::math::DMat4::col( - &_self, - index, + "from_scale_rotation_translation", + | + scale: Val, + rotation: Val, + translation: Val| + { + let output: Val = bevy::math::DMat4::from_scale_rotation_translation( + scale.into_inner(), + rotation.into_inner(), + translation.into_inner(), ) .into(); output }, ) .register( - "row", - |_self: Ref, index: usize| { - let output: Val = bevy::math::DMat4::row( - &_self, - index, + "from_translation", + |translation: Val| { + let output: Val = bevy::math::DMat4::from_translation( + translation.into_inner(), ) .into(); output }, ) .register( - "is_finite", - |_self: Ref| { - let output: bool = bevy::math::DMat4::is_finite(&_self).into(); - output - }, - ) - .register( - "is_nan", - |_self: Ref| { - let output: bool = bevy::math::DMat4::is_nan(&_self).into(); - output - }, - ) - .register( - "transpose", + "inverse", |_self: Ref| { - let output: Val = bevy::math::DMat4::transpose( + let output: Val = bevy::math::DMat4::inverse( &_self, ) .into(); @@ -19568,32 +19597,29 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "determinant", + "is_finite", |_self: Ref| { - let output: f64 = bevy::math::DMat4::determinant(&_self).into(); + let output: bool = bevy::math::DMat4::is_finite(&_self).into(); output }, ) .register( - "inverse", + "is_nan", |_self: Ref| { - let output: Val = bevy::math::DMat4::inverse( - &_self, - ) - .into(); + let output: bool = bevy::math::DMat4::is_nan(&_self).into(); output }, ) .register( - "look_to_lh", + "look_at_lh", | eye: Val, - dir: Val, + center: Val, up: Val| { - let output: Val = bevy::math::DMat4::look_to_lh( + let output: Val = bevy::math::DMat4::look_at_lh( eye.into_inner(), - dir.into_inner(), + center.into_inner(), up.into_inner(), ) .into(); @@ -19601,15 +19627,15 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "look_to_rh", + "look_at_rh", | eye: Val, - dir: Val, + center: Val, up: Val| { - let output: Val = bevy::math::DMat4::look_to_rh( + let output: Val = bevy::math::DMat4::look_at_rh( eye.into_inner(), - dir.into_inner(), + center.into_inner(), up.into_inner(), ) .into(); @@ -19617,15 +19643,15 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "look_at_lh", + "look_to_lh", | eye: Val, - center: Val, + dir: Val, up: Val| { - let output: Val = bevy::math::DMat4::look_at_lh( + let output: Val = bevy::math::DMat4::look_to_lh( eye.into_inner(), - center.into_inner(), + dir.into_inner(), up.into_inner(), ) .into(); @@ -19633,15 +19659,15 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "look_at_rh", + "look_to_rh", | eye: Val, - center: Val, + dir: Val, up: Val| { - let output: Val = bevy::math::DMat4::look_at_rh( + let output: Val = bevy::math::DMat4::look_to_rh( eye.into_inner(), - center.into_inner(), + dir.into_inner(), up.into_inner(), ) .into(); @@ -19649,96 +19675,92 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "perspective_rh_gl", - |fov_y_radians: f64, aspect_ratio: f64, z_near: f64, z_far: f64| { - let output: Val = bevy::math::DMat4::perspective_rh_gl( - fov_y_radians, - aspect_ratio, - z_near, - z_far, - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "perspective_lh", - |fov_y_radians: f64, aspect_ratio: f64, z_near: f64, z_far: f64| { - let output: Val = bevy::math::DMat4::perspective_lh( - fov_y_radians, - aspect_ratio, - z_near, - z_far, - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + .into(); + output + }, + ) + .register( + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "perspective_rh", - |fov_y_radians: f64, aspect_ratio: f64, z_near: f64, z_far: f64| { - let output: Val = bevy::math::DMat4::perspective_rh( - fov_y_radians, - aspect_ratio, - z_near, - z_far, - ) + "mul", + |_self: Val, rhs: f64| { + let output: Val = >::mul(_self.into_inner(), rhs) .into(); output }, ) .register( - "perspective_infinite_lh", - |fov_y_radians: f64, aspect_ratio: f64, z_near: f64| { - let output: Val = bevy::math::DMat4::perspective_infinite_lh( - fov_y_radians, - aspect_ratio, - z_near, + "mul_mat4", + |_self: Ref, rhs: Ref| { + let output: Val = bevy::math::DMat4::mul_mat4( + &_self, + &rhs, ) .into(); output }, ) .register( - "perspective_infinite_reverse_lh", - |fov_y_radians: f64, aspect_ratio: f64, z_near: f64| { - let output: Val = bevy::math::DMat4::perspective_infinite_reverse_lh( - fov_y_radians, - aspect_ratio, - z_near, + "mul_scalar", + |_self: Ref, rhs: f64| { + let output: Val = bevy::math::DMat4::mul_scalar( + &_self, + rhs, ) .into(); output }, ) .register( - "perspective_infinite_rh", - |fov_y_radians: f64, aspect_ratio: f64, z_near: f64| { - let output: Val = bevy::math::DMat4::perspective_infinite_rh( - fov_y_radians, - aspect_ratio, - z_near, + "mul_vec4", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::DMat4::mul_vec4( + &_self, + rhs.into_inner(), ) .into(); output }, ) .register( - "perspective_infinite_reverse_rh", - |fov_y_radians: f64, aspect_ratio: f64, z_near: f64| { - let output: Val = bevy::math::DMat4::perspective_infinite_reverse_rh( - fov_y_radians, - aspect_ratio, - z_near, + "neg", + |_self: Val| { + let output: Val = ::neg( + _self.into_inner(), ) .into(); output }, ) .register( - "orthographic_rh_gl", + "orthographic_lh", |left: f64, right: f64, bottom: f64, top: f64, near: f64, far: f64| { - let output: Val = bevy::math::DMat4::orthographic_rh_gl( + let output: Val = bevy::math::DMat4::orthographic_lh( left, right, bottom, @@ -19751,9 +19773,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "orthographic_lh", + "orthographic_rh", |left: f64, right: f64, bottom: f64, top: f64, near: f64, far: f64| { - let output: Val = bevy::math::DMat4::orthographic_lh( + let output: Val = bevy::math::DMat4::orthographic_rh( left, right, bottom, @@ -19766,9 +19788,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "orthographic_rh", + "orthographic_rh_gl", |left: f64, right: f64, bottom: f64, top: f64, near: f64, far: f64| { - let output: Val = bevy::math::DMat4::orthographic_rh( + let output: Val = bevy::math::DMat4::orthographic_rh_gl( left, right, bottom, @@ -19781,219 +19803,223 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "project_point3", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::DMat4::project_point3( - &_self, - rhs.into_inner(), - ) - .into(); - output - }, - ) - .register( - "transform_point3", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::DMat4::transform_point3( - &_self, - rhs.into_inner(), + "perspective_infinite_lh", + |fov_y_radians: f64, aspect_ratio: f64, z_near: f64| { + let output: Val = bevy::math::DMat4::perspective_infinite_lh( + fov_y_radians, + aspect_ratio, + z_near, ) .into(); output }, ) .register( - "transform_vector3", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::DMat4::transform_vector3( - &_self, - rhs.into_inner(), + "perspective_infinite_reverse_lh", + |fov_y_radians: f64, aspect_ratio: f64, z_near: f64| { + let output: Val = bevy::math::DMat4::perspective_infinite_reverse_lh( + fov_y_radians, + aspect_ratio, + z_near, ) .into(); output }, ) .register( - "mul_vec4", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::DMat4::mul_vec4( - &_self, - rhs.into_inner(), + "perspective_infinite_reverse_rh", + |fov_y_radians: f64, aspect_ratio: f64, z_near: f64| { + let output: Val = bevy::math::DMat4::perspective_infinite_reverse_rh( + fov_y_radians, + aspect_ratio, + z_near, ) .into(); output }, ) .register( - "mul_mat4", - |_self: Ref, rhs: Ref| { - let output: Val = bevy::math::DMat4::mul_mat4( - &_self, - &rhs, + "perspective_infinite_rh", + |fov_y_radians: f64, aspect_ratio: f64, z_near: f64| { + let output: Val = bevy::math::DMat4::perspective_infinite_rh( + fov_y_radians, + aspect_ratio, + z_near, ) .into(); output }, ) .register( - "add_mat4", - |_self: Ref, rhs: Ref| { - let output: Val = bevy::math::DMat4::add_mat4( - &_self, - &rhs, + "perspective_lh", + |fov_y_radians: f64, aspect_ratio: f64, z_near: f64, z_far: f64| { + let output: Val = bevy::math::DMat4::perspective_lh( + fov_y_radians, + aspect_ratio, + z_near, + z_far, ) .into(); output }, ) .register( - "sub_mat4", - |_self: Ref, rhs: Ref| { - let output: Val = bevy::math::DMat4::sub_mat4( - &_self, - &rhs, + "perspective_rh", + |fov_y_radians: f64, aspect_ratio: f64, z_near: f64, z_far: f64| { + let output: Val = bevy::math::DMat4::perspective_rh( + fov_y_radians, + aspect_ratio, + z_near, + z_far, ) .into(); output }, ) .register( - "mul_scalar", - |_self: Ref, rhs: f64| { - let output: Val = bevy::math::DMat4::mul_scalar( - &_self, - rhs, + "perspective_rh_gl", + |fov_y_radians: f64, aspect_ratio: f64, z_near: f64, z_far: f64| { + let output: Val = bevy::math::DMat4::perspective_rh_gl( + fov_y_radians, + aspect_ratio, + z_near, + z_far, ) .into(); output }, ) .register( - "div_scalar", - |_self: Ref, rhs: f64| { - let output: Val = bevy::math::DMat4::div_scalar( + "project_point3", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::DMat4::project_point3( &_self, - rhs, + rhs.into_inner(), ) .into(); output }, ) .register( - "abs_diff_eq", - | - _self: Ref, - rhs: Val, - max_abs_diff: f64| - { - let output: bool = bevy::math::DMat4::abs_diff_eq( + "row", + |_self: Ref, index: usize| { + let output: Val = bevy::math::DMat4::row( &_self, - rhs.into_inner(), - max_abs_diff, + index, ) .into(); output }, ) .register( - "abs", - |_self: Ref| { - let output: Val = bevy::math::DMat4::abs(&_self) + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "as_mat4", - |_self: Ref| { - let output: Val = bevy::math::DMat4::as_mat4( + "sub_mat4", + |_self: Ref, rhs: Ref| { + let output: Val = bevy::math::DMat4::sub_mat4( &_self, + &rhs, ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Val| { - let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + "to_cols_array", + |_self: Ref| { + let output: [f64; 16] = bevy::math::DMat4::to_cols_array(&_self) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "to_cols_array_2d", + |_self: Ref| { + let output: [[f64; 4]; 4] = bevy::math::DMat4::to_cols_array_2d( + &_self, + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: f64| { - let output: Val = >::mul(_self.into_inner(), rhs) + "to_euler", + |_self: Ref, order: Val| { + let output: (f64, f64, f64) = bevy::math::DMat4::to_euler( + &_self, + order.into_inner(), + ) .into(); output }, ) .register( - "sub", - |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + "transform_point3", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::DMat4::transform_point3( + &_self, + rhs.into_inner(), + ) .into(); output }, ) .register( - "neg", - |_self: Val| { - let output: Val = ::neg( - _self.into_inner(), + "transform_vector3", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::DMat4::transform_vector3( + &_self, + rhs.into_inner(), ) .into(); output }, ) .register( - "eq", - |_self: Ref, rhs: Ref| { - let output: bool = >::eq(&_self, &rhs) + "transpose", + |_self: Ref| { + let output: Val = bevy::math::DMat4::transpose( + &_self, + ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::Affine2>::new(world) .register( - "div", - |_self: Val, rhs: f64| { - let output: Val = >::div(_self.into_inner(), rhs) + "abs_diff_eq", + | + _self: Ref, + rhs: Val, + max_abs_diff: f32| + { + let output: bool = bevy::math::Affine2::abs_diff_eq( + &_self, + rhs.into_inner(), + max_abs_diff, + ) .into(); output }, ) .register( "clone", - |_self: Ref| { - let output: Val = ::clone( + |_self: Ref| { + let output: Val = ::clone( &_self, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::Affine2>::new(world) + ) .register( "eq", |_self: Ref, rhs: Ref| { @@ -20005,21 +20031,22 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "from_angle", + |angle: f32| { + let output: Val = bevy::math::Affine2::from_angle( + angle, + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "from_angle_translation", + |angle: f32, translation: Val| { + let output: Val = bevy::math::Affine2::from_angle_translation( + angle, + translation.into_inner(), + ) .into(); output }, @@ -20041,69 +20068,51 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "to_cols_array", - |_self: Ref| { - let output: [f32; 6] = bevy::math::Affine2::to_cols_array(&_self) - .into(); - output - }, - ) - .register( - "to_cols_array_2d", - |_self: Ref| { - let output: [[f32; 2]; 3] = bevy::math::Affine2::to_cols_array_2d( - &_self, - ) - .into(); - output - }, - ) - .register( - "from_scale", - |scale: Val| { - let output: Val = bevy::math::Affine2::from_scale( - scale.into_inner(), + "from_mat2", + |matrix2: Val| { + let output: Val = bevy::math::Affine2::from_mat2( + matrix2.into_inner(), ) .into(); output }, ) .register( - "from_angle", - |angle: f32| { - let output: Val = bevy::math::Affine2::from_angle( - angle, + "from_mat2_translation", + |matrix2: Val, translation: Val| { + let output: Val = bevy::math::Affine2::from_mat2_translation( + matrix2.into_inner(), + translation.into_inner(), ) .into(); output }, ) .register( - "from_translation", - |translation: Val| { - let output: Val = bevy::math::Affine2::from_translation( - translation.into_inner(), + "from_mat3", + |m: Val| { + let output: Val = bevy::math::Affine2::from_mat3( + m.into_inner(), ) .into(); output }, ) .register( - "from_mat2", - |matrix2: Val| { - let output: Val = bevy::math::Affine2::from_mat2( - matrix2.into_inner(), + "from_mat3a", + |m: Val| { + let output: Val = bevy::math::Affine2::from_mat3a( + m.into_inner(), ) .into(); output }, ) .register( - "from_mat2_translation", - |matrix2: Val, translation: Val| { - let output: Val = bevy::math::Affine2::from_mat2_translation( - matrix2.into_inner(), - translation.into_inner(), + "from_scale", + |scale: Val| { + let output: Val = bevy::math::Affine2::from_scale( + scale.into_inner(), ) .into(); output @@ -20126,10 +20135,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_angle_translation", - |angle: f32, translation: Val| { - let output: Val = bevy::math::Affine2::from_angle_translation( - angle, + "from_translation", + |translation: Val| { + let output: Val = bevy::math::Affine2::from_translation( translation.into_inner(), ) .into(); @@ -20137,81 +20145,71 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_mat3", - |m: Val| { - let output: Val = bevy::math::Affine2::from_mat3( - m.into_inner(), + "inverse", + |_self: Ref| { + let output: Val = bevy::math::Affine2::inverse( + &_self, ) .into(); output }, ) .register( - "from_mat3a", - |m: Val| { - let output: Val = bevy::math::Affine2::from_mat3a( - m.into_inner(), - ) - .into(); + "is_finite", + |_self: Ref| { + let output: bool = bevy::math::Affine2::is_finite(&_self).into(); output }, ) .register( - "transform_point2", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::Affine2::transform_point2( - &_self, - rhs.into_inner(), - ) - .into(); + "is_nan", + |_self: Ref| { + let output: bool = bevy::math::Affine2::is_nan(&_self).into(); output }, ) .register( - "transform_vector2", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::Affine2::transform_vector2( - &_self, - rhs.into_inner(), - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "is_finite", - |_self: Ref| { - let output: bool = bevy::math::Affine2::is_finite(&_self).into(); + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + .into(); output }, ) .register( - "is_nan", - |_self: Ref| { - let output: bool = bevy::math::Affine2::is_nan(&_self).into(); + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + .into(); output }, ) .register( - "abs_diff_eq", - | - _self: Ref, - rhs: Val, - max_abs_diff: f32| - { - let output: bool = bevy::math::Affine2::abs_diff_eq( - &_self, - rhs.into_inner(), - max_abs_diff, - ) + "to_cols_array", + |_self: Ref| { + let output: [f32; 6] = bevy::math::Affine2::to_cols_array(&_self) .into(); output }, ) .register( - "inverse", + "to_cols_array_2d", |_self: Ref| { - let output: Val = bevy::math::Affine2::inverse( + let output: [[f32; 2]; 3] = bevy::math::Affine2::to_cols_array_2d( &_self, ) .into(); @@ -20219,26 +20217,44 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( + "transform_point2", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::Affine2::transform_point2( &_self, + rhs.into_inner(), ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "transform_vector2", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::Affine2::transform_vector2( + &_self, + rhs.into_inner(), + ) .into(); output }, ); NamespaceBuilder::<::bevy::math::Affine3A>::new(world) + .register( + "abs_diff_eq", + | + _self: Ref, + rhs: Val, + max_abs_diff: f32| + { + let output: bool = bevy::math::Affine3A::abs_diff_eq( + &_self, + rhs.into_inner(), + max_abs_diff, + ) + .into(); + output + }, + ) .register( "clone", |_self: Ref| { @@ -20250,11 +20266,22 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = , rhs: Ref| { + let output: bool = >::mul(_self.into_inner(), rhs.into_inner()) + >>::eq(&_self, &rhs) + .into(); + output + }, + ) + .register( + "from_axis_angle", + |axis: Val, angle: f32| { + let output: Val = bevy::math::Affine3A::from_axis_angle( + axis.into_inner(), + angle, + ) .into(); output }, @@ -20278,28 +20305,31 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "to_cols_array", - |_self: Ref| { - let output: [f32; 12] = bevy::math::Affine3A::to_cols_array(&_self) + "from_mat3", + |mat3: Val| { + let output: Val = bevy::math::Affine3A::from_mat3( + mat3.into_inner(), + ) .into(); output }, ) .register( - "to_cols_array_2d", - |_self: Ref| { - let output: [[f32; 3]; 4] = bevy::math::Affine3A::to_cols_array_2d( - &_self, + "from_mat3_translation", + |mat3: Val, translation: Val| { + let output: Val = bevy::math::Affine3A::from_mat3_translation( + mat3.into_inner(), + translation.into_inner(), ) .into(); output }, ) .register( - "from_scale", - |scale: Val| { - let output: Val = bevy::math::Affine3A::from_scale( - scale.into_inner(), + "from_mat4", + |m: Val| { + let output: Val = bevy::math::Affine3A::from_mat4( + m.into_inner(), ) .into(); output @@ -20316,11 +20346,11 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_axis_angle", - |axis: Val, angle: f32| { - let output: Val = bevy::math::Affine3A::from_axis_angle( - axis.into_inner(), - angle, + "from_rotation_translation", + |rotation: Val, translation: Val| { + let output: Val = bevy::math::Affine3A::from_rotation_translation( + rotation.into_inner(), + translation.into_inner(), ) .into(); output @@ -20357,31 +20387,10 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_translation", - |translation: Val| { - let output: Val = bevy::math::Affine3A::from_translation( - translation.into_inner(), - ) - .into(); - output - }, - ) - .register( - "from_mat3", - |mat3: Val| { - let output: Val = bevy::math::Affine3A::from_mat3( - mat3.into_inner(), - ) - .into(); - output - }, - ) - .register( - "from_mat3_translation", - |mat3: Val, translation: Val| { - let output: Val = bevy::math::Affine3A::from_mat3_translation( - mat3.into_inner(), - translation.into_inner(), + "from_scale", + |scale: Val| { + let output: Val = bevy::math::Affine3A::from_scale( + scale.into_inner(), ) .into(); output @@ -20404,10 +20413,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_rotation_translation", - |rotation: Val, translation: Val| { - let output: Val = bevy::math::Affine3A::from_rotation_translation( - rotation.into_inner(), + "from_translation", + |translation: Val| { + let output: Val = bevy::math::Affine3A::from_translation( translation.into_inner(), ) .into(); @@ -20415,25 +20423,39 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_mat4", - |m: Val| { - let output: Val = bevy::math::Affine3A::from_mat4( - m.into_inner(), + "inverse", + |_self: Ref| { + let output: Val = bevy::math::Affine3A::inverse( + &_self, ) .into(); output }, ) .register( - "look_to_lh", + "is_finite", + |_self: Ref| { + let output: bool = bevy::math::Affine3A::is_finite(&_self).into(); + output + }, + ) + .register( + "is_nan", + |_self: Ref| { + let output: bool = bevy::math::Affine3A::is_nan(&_self).into(); + output + }, + ) + .register( + "look_at_lh", | eye: Val, - dir: Val, + center: Val, up: Val| { - let output: Val = bevy::math::Affine3A::look_to_lh( + let output: Val = bevy::math::Affine3A::look_at_lh( eye.into_inner(), - dir.into_inner(), + center.into_inner(), up.into_inner(), ) .into(); @@ -20441,15 +20463,15 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "look_to_rh", + "look_at_rh", | eye: Val, - dir: Val, + center: Val, up: Val| { - let output: Val = bevy::math::Affine3A::look_to_rh( + let output: Val = bevy::math::Affine3A::look_at_rh( eye.into_inner(), - dir.into_inner(), + center.into_inner(), up.into_inner(), ) .into(); @@ -20457,15 +20479,15 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "look_at_lh", + "look_to_lh", | eye: Val, - center: Val, + dir: Val, up: Val| { - let output: Val = bevy::math::Affine3A::look_at_lh( + let output: Val = bevy::math::Affine3A::look_to_lh( eye.into_inner(), - center.into_inner(), + dir.into_inner(), up.into_inner(), ) .into(); @@ -20473,15 +20495,15 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "look_at_rh", + "look_to_rh", | eye: Val, - center: Val, + dir: Val, up: Val| { - let output: Val = bevy::math::Affine3A::look_at_rh( + let output: Val = bevy::math::Affine3A::look_to_rh( eye.into_inner(), - center.into_inner(), + dir.into_inner(), up.into_inner(), ) .into(); @@ -20489,20 +20511,47 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "transform_point3", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::Affine3A::transform_point3( + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + .into(); + output + }, + ) + .register( + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + .into(); + output + }, + ) + .register( + "to_cols_array", + |_self: Ref| { + let output: [f32; 12] = bevy::math::Affine3A::to_cols_array(&_self) + .into(); + output + }, + ) + .register( + "to_cols_array_2d", + |_self: Ref| { + let output: [[f32; 3]; 4] = bevy::math::Affine3A::to_cols_array_2d( &_self, - rhs.into_inner(), ) .into(); output }, ) .register( - "transform_vector3", + "transform_point3", |_self: Ref, rhs: Val| { - let output: Val = bevy::math::Affine3A::transform_vector3( + let output: Val = bevy::math::Affine3A::transform_point3( &_self, rhs.into_inner(), ) @@ -20522,9 +20571,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "transform_vector3a", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::Affine3A::transform_vector3a( + "transform_vector3", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::Affine3A::transform_vector3( &_self, rhs.into_inner(), ) @@ -20533,27 +20582,25 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "is_finite", - |_self: Ref| { - let output: bool = bevy::math::Affine3A::is_finite(&_self).into(); - output - }, - ) - .register( - "is_nan", - |_self: Ref| { - let output: bool = bevy::math::Affine3A::is_nan(&_self).into(); + "transform_vector3a", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::Affine3A::transform_vector3a( + &_self, + rhs.into_inner(), + ) + .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::DAffine2>::new(world) .register( "abs_diff_eq", | - _self: Ref, - rhs: Val, - max_abs_diff: f32| + _self: Ref, + rhs: Val, + max_abs_diff: f64| { - let output: bool = bevy::math::Affine3A::abs_diff_eq( + let output: bool = bevy::math::DAffine2::abs_diff_eq( &_self, rhs.into_inner(), max_abs_diff, @@ -20563,9 +20610,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "inverse", - |_self: Ref| { - let output: Val = bevy::math::Affine3A::inverse( + "clone", + |_self: Ref| { + let output: Val = ::clone( &_self, ) .into(); @@ -20574,51 +20621,31 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { ) .register( "eq", - |_self: Ref, rhs: Ref| { - let output: bool = >::eq(&_self, &rhs) - .into(); - output - }, - ) - .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) - .into(); - output - }, - ); - NamespaceBuilder::<::bevy::math::DAffine2>::new(world) - .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = , rhs: Ref| { + let output: bool = >::mul(_self.into_inner(), rhs.into_inner()) + >>::eq(&_self, &rhs) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, + "from_angle", + |angle: f64| { + let output: Val = bevy::math::DAffine2::from_angle( + angle, ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "from_angle_translation", + |angle: f64, translation: Val| { + let output: Val = bevy::math::DAffine2::from_angle_translation( + angle, + translation.into_inner(), + ) .into(); output }, @@ -20640,18 +20667,31 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "to_cols_array", - |_self: Ref| { - let output: [f64; 6] = bevy::math::DAffine2::to_cols_array(&_self) + "from_mat2", + |matrix2: Val| { + let output: Val = bevy::math::DAffine2::from_mat2( + matrix2.into_inner(), + ) + .into(); + output + }, + ) + .register( + "from_mat2_translation", + |matrix2: Val, translation: Val| { + let output: Val = bevy::math::DAffine2::from_mat2_translation( + matrix2.into_inner(), + translation.into_inner(), + ) .into(); output }, ) .register( - "to_cols_array_2d", - |_self: Ref| { - let output: [[f64; 2]; 3] = bevy::math::DAffine2::to_cols_array_2d( - &_self, + "from_mat3", + |m: Val| { + let output: Val = bevy::math::DAffine2::from_mat3( + m.into_inner(), ) .into(); output @@ -20668,10 +20708,16 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_angle", - |angle: f64| { - let output: Val = bevy::math::DAffine2::from_angle( + "from_scale_angle_translation", + | + scale: Val, + angle: f64, + translation: Val| + { + let output: Val = bevy::math::DAffine2::from_scale_angle_translation( + scale.into_inner(), angle, + translation.into_inner(), ) .into(); output @@ -20688,58 +20734,62 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_mat2", - |matrix2: Val| { - let output: Val = bevy::math::DAffine2::from_mat2( - matrix2.into_inner(), + "inverse", + |_self: Ref| { + let output: Val = bevy::math::DAffine2::inverse( + &_self, ) .into(); output }, ) .register( - "from_mat2_translation", - |matrix2: Val, translation: Val| { - let output: Val = bevy::math::DAffine2::from_mat2_translation( - matrix2.into_inner(), - translation.into_inner(), - ) + "is_finite", + |_self: Ref| { + let output: bool = bevy::math::DAffine2::is_finite(&_self).into(); + output + }, + ) + .register( + "is_nan", + |_self: Ref| { + let output: bool = bevy::math::DAffine2::is_nan(&_self).into(); + output + }, + ) + .register( + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "from_scale_angle_translation", - | - scale: Val, - angle: f64, - translation: Val| - { - let output: Val = bevy::math::DAffine2::from_scale_angle_translation( - scale.into_inner(), - angle, - translation.into_inner(), - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "from_angle_translation", - |angle: f64, translation: Val| { - let output: Val = bevy::math::DAffine2::from_angle_translation( - angle, - translation.into_inner(), - ) + "to_cols_array", + |_self: Ref| { + let output: [f64; 6] = bevy::math::DAffine2::to_cols_array(&_self) .into(); output }, ) .register( - "from_mat3", - |m: Val| { - let output: Val = bevy::math::DAffine2::from_mat3( - m.into_inner(), + "to_cols_array_2d", + |_self: Ref| { + let output: [[f64; 2]; 3] = bevy::math::DAffine2::to_cols_array_2d( + &_self, ) .into(); output @@ -20766,29 +20816,16 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { .into(); output }, - ) - .register( - "is_finite", - |_self: Ref| { - let output: bool = bevy::math::DAffine2::is_finite(&_self).into(); - output - }, - ) - .register( - "is_nan", - |_self: Ref| { - let output: bool = bevy::math::DAffine2::is_nan(&_self).into(); - output - }, - ) + ); + NamespaceBuilder::<::bevy::math::DAffine3>::new(world) .register( "abs_diff_eq", | - _self: Ref, - rhs: Val, + _self: Ref, + rhs: Val, max_abs_diff: f64| { - let output: bool = bevy::math::DAffine2::abs_diff_eq( + let output: bool = bevy::math::DAffine3::abs_diff_eq( &_self, rhs.into_inner(), max_abs_diff, @@ -20797,27 +20834,6 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { output }, ) - .register( - "inverse", - |_self: Ref| { - let output: Val = bevy::math::DAffine2::inverse( - &_self, - ) - .into(); - output - }, - ) - .register( - "eq", - |_self: Ref, rhs: Ref| { - let output: bool = >::eq(&_self, &rhs) - .into(); - output - }, - ); - NamespaceBuilder::<::bevy::math::DAffine3>::new(world) .register( "clone", |_self: Ref| { @@ -20839,11 +20855,12 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "from_axis_angle", + |axis: Val, angle: f64| { + let output: Val = bevy::math::DAffine3::from_axis_angle( + axis.into_inner(), + angle, + ) .into(); output }, @@ -20867,28 +20884,31 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "to_cols_array", - |_self: Ref| { - let output: [f64; 12] = bevy::math::DAffine3::to_cols_array(&_self) + "from_mat3", + |mat3: Val| { + let output: Val = bevy::math::DAffine3::from_mat3( + mat3.into_inner(), + ) .into(); output }, ) .register( - "to_cols_array_2d", - |_self: Ref| { - let output: [[f64; 3]; 4] = bevy::math::DAffine3::to_cols_array_2d( - &_self, + "from_mat3_translation", + |mat3: Val, translation: Val| { + let output: Val = bevy::math::DAffine3::from_mat3_translation( + mat3.into_inner(), + translation.into_inner(), ) .into(); output }, ) .register( - "from_scale", - |scale: Val| { - let output: Val = bevy::math::DAffine3::from_scale( - scale.into_inner(), + "from_mat4", + |m: Val| { + let output: Val = bevy::math::DAffine3::from_mat4( + m.into_inner(), ) .into(); output @@ -20905,11 +20925,11 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_axis_angle", - |axis: Val, angle: f64| { - let output: Val = bevy::math::DAffine3::from_axis_angle( - axis.into_inner(), - angle, + "from_rotation_translation", + |rotation: Val, translation: Val| { + let output: Val = bevy::math::DAffine3::from_rotation_translation( + rotation.into_inner(), + translation.into_inner(), ) .into(); output @@ -20946,31 +20966,10 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_translation", - |translation: Val| { - let output: Val = bevy::math::DAffine3::from_translation( - translation.into_inner(), - ) - .into(); - output - }, - ) - .register( - "from_mat3", - |mat3: Val| { - let output: Val = bevy::math::DAffine3::from_mat3( - mat3.into_inner(), - ) - .into(); - output - }, - ) - .register( - "from_mat3_translation", - |mat3: Val, translation: Val| { - let output: Val = bevy::math::DAffine3::from_mat3_translation( - mat3.into_inner(), - translation.into_inner(), + "from_scale", + |scale: Val| { + let output: Val = bevy::math::DAffine3::from_scale( + scale.into_inner(), ) .into(); output @@ -20993,10 +20992,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_rotation_translation", - |rotation: Val, translation: Val| { - let output: Val = bevy::math::DAffine3::from_rotation_translation( - rotation.into_inner(), + "from_translation", + |translation: Val| { + let output: Val = bevy::math::DAffine3::from_translation( translation.into_inner(), ) .into(); @@ -21004,25 +21002,39 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_mat4", - |m: Val| { - let output: Val = bevy::math::DAffine3::from_mat4( - m.into_inner(), + "inverse", + |_self: Ref| { + let output: Val = bevy::math::DAffine3::inverse( + &_self, ) .into(); output }, ) .register( - "look_to_lh", + "is_finite", + |_self: Ref| { + let output: bool = bevy::math::DAffine3::is_finite(&_self).into(); + output + }, + ) + .register( + "is_nan", + |_self: Ref| { + let output: bool = bevy::math::DAffine3::is_nan(&_self).into(); + output + }, + ) + .register( + "look_at_lh", | eye: Val, - dir: Val, + center: Val, up: Val| { - let output: Val = bevy::math::DAffine3::look_to_lh( + let output: Val = bevy::math::DAffine3::look_at_lh( eye.into_inner(), - dir.into_inner(), + center.into_inner(), up.into_inner(), ) .into(); @@ -21030,15 +21042,15 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "look_to_rh", + "look_at_rh", | eye: Val, - dir: Val, + center: Val, up: Val| { - let output: Val = bevy::math::DAffine3::look_to_rh( + let output: Val = bevy::math::DAffine3::look_at_rh( eye.into_inner(), - dir.into_inner(), + center.into_inner(), up.into_inner(), ) .into(); @@ -21046,15 +21058,15 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "look_at_lh", + "look_to_lh", | eye: Val, - center: Val, + dir: Val, up: Val| { - let output: Val = bevy::math::DAffine3::look_at_lh( + let output: Val = bevy::math::DAffine3::look_to_lh( eye.into_inner(), - center.into_inner(), + dir.into_inner(), up.into_inner(), ) .into(); @@ -21062,15 +21074,15 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "look_at_rh", + "look_to_rh", | eye: Val, - center: Val, + dir: Val, up: Val| { - let output: Val = bevy::math::DAffine3::look_at_rh( + let output: Val = bevy::math::DAffine3::look_to_rh( eye.into_inner(), - center.into_inner(), + dir.into_inner(), up.into_inner(), ) .into(); @@ -21078,194 +21090,187 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "transform_point3", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::DAffine3::transform_point3( - &_self, - rhs.into_inner(), - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "transform_vector3", - |_self: Ref, rhs: Val| { - let output: Val = bevy::math::DAffine3::transform_vector3( - &_self, - rhs.into_inner(), - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "is_finite", + "to_cols_array", |_self: Ref| { - let output: bool = bevy::math::DAffine3::is_finite(&_self).into(); + let output: [f64; 12] = bevy::math::DAffine3::to_cols_array(&_self) + .into(); output }, ) .register( - "is_nan", + "to_cols_array_2d", |_self: Ref| { - let output: bool = bevy::math::DAffine3::is_nan(&_self).into(); - output - }, - ) - .register( - "abs_diff_eq", - | - _self: Ref, - rhs: Val, - max_abs_diff: f64| - { - let output: bool = bevy::math::DAffine3::abs_diff_eq( + let output: [[f64; 3]; 4] = bevy::math::DAffine3::to_cols_array_2d( &_self, - rhs.into_inner(), - max_abs_diff, ) .into(); output }, ) .register( - "inverse", - |_self: Ref| { - let output: Val = bevy::math::DAffine3::inverse( + "transform_point3", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::DAffine3::transform_point3( &_self, + rhs.into_inner(), ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "transform_vector3", + |_self: Ref, rhs: Val| { + let output: Val = bevy::math::DAffine3::transform_vector3( + &_self, + rhs.into_inner(), + ) .into(); output }, ); NamespaceBuilder::<::bevy::math::DQuat>::new(world) .register( - "mul", - |_self: Val, rhs: Val| { - let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) + "abs_diff_eq", + | + _self: Val, + rhs: Val, + max_abs_diff: f64| + { + let output: bool = bevy::math::DQuat::abs_diff_eq( + _self.into_inner(), + rhs.into_inner(), + max_abs_diff, + ) .into(); output }, ) .register( - "mul", + "add", |_self: Val, rhs: Val| { - let output: Val = = >::mul(_self.into_inner(), rhs.into_inner()) + >>::add(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "div", - |_self: Val, rhs: f64| { - let output: Val = >::div(_self.into_inner(), rhs) + "angle_between", + |_self: Val, rhs: Val| { + let output: f64 = bevy::math::DQuat::angle_between( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "add", - |_self: Val, rhs: Val| { - let output: Val = >::add(_self.into_inner(), rhs.into_inner()) + "as_quat", + |_self: Val| { + let output: Val = bevy::math::DQuat::as_quat( + _self.into_inner(), + ) .into(); output }, ) .register( - "from_xyzw", - |x: f64, y: f64, z: f64, w: f64| { - let output: Val = bevy::math::DQuat::from_xyzw( - x, - y, - z, - w, + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, ) .into(); output }, ) .register( - "from_array", - |a: [f64; 4]| { - let output: Val = bevy::math::DQuat::from_array(a) + "conjugate", + |_self: Val| { + let output: Val = bevy::math::DQuat::conjugate( + _self.into_inner(), + ) .into(); output }, ) .register( - "from_vec4", - |v: Val| { - let output: Val = bevy::math::DQuat::from_vec4( - v.into_inner(), - ) + "div", + |_self: Val, rhs: f64| { + let output: Val = >::div(_self.into_inner(), rhs) .into(); output }, ) .register( - "from_axis_angle", - |axis: Val, angle: f64| { - let output: Val = bevy::math::DQuat::from_axis_angle( - axis.into_inner(), - angle, + "dot", + |_self: Val, rhs: Val| { + let output: f64 = bevy::math::DQuat::dot( + _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "from_scaled_axis", - |v: Val| { - let output: Val = bevy::math::DQuat::from_scaled_axis( - v.into_inner(), - ) + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = >::eq(&_self, &rhs) .into(); output }, ) .register( - "from_rotation_x", - |angle: f64| { - let output: Val = bevy::math::DQuat::from_rotation_x( - angle, + "from_affine3", + |a: Ref| { + let output: Val = bevy::math::DQuat::from_affine3( + &a, ) .into(); output }, ) .register( - "from_rotation_y", - |angle: f64| { - let output: Val = bevy::math::DQuat::from_rotation_y( - angle, - ) + "from_array", + |a: [f64; 4]| { + let output: Val = bevy::math::DQuat::from_array(a) .into(); output }, ) .register( - "from_rotation_z", - |angle: f64| { - let output: Val = bevy::math::DQuat::from_rotation_z( + "from_axis_angle", + |axis: Val, angle: f64| { + let output: Val = bevy::math::DQuat::from_axis_angle( + axis.into_inner(), angle, ) .into(); @@ -21316,6 +21321,17 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { output }, ) + .register( + "from_rotation_arc_2d", + |from: Val, to: Val| { + let output: Val = bevy::math::DQuat::from_rotation_arc_2d( + from.into_inner(), + to.into_inner(), + ) + .into(); + output + }, + ) .register( "from_rotation_arc_colinear", |from: Val, to: Val| { @@ -21328,20 +21344,72 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_rotation_arc_2d", - |from: Val, to: Val| { - let output: Val = bevy::math::DQuat::from_rotation_arc_2d( - from.into_inner(), - to.into_inner(), + "from_rotation_x", + |angle: f64| { + let output: Val = bevy::math::DQuat::from_rotation_x( + angle, + ) + .into(); + output + }, + ) + .register( + "from_rotation_y", + |angle: f64| { + let output: Val = bevy::math::DQuat::from_rotation_y( + angle, + ) + .into(); + output + }, + ) + .register( + "from_rotation_z", + |angle: f64| { + let output: Val = bevy::math::DQuat::from_rotation_z( + angle, + ) + .into(); + output + }, + ) + .register( + "from_scaled_axis", + |v: Val| { + let output: Val = bevy::math::DQuat::from_scaled_axis( + v.into_inner(), + ) + .into(); + output + }, + ) + .register( + "from_vec4", + |v: Val| { + let output: Val = bevy::math::DQuat::from_vec4( + v.into_inner(), + ) + .into(); + output + }, + ) + .register( + "from_xyzw", + |x: f64, y: f64, z: f64, w: f64| { + let output: Val = bevy::math::DQuat::from_xyzw( + x, + y, + z, + w, ) .into(); output }, ) .register( - "to_scaled_axis", + "inverse", |_self: Val| { - let output: Val = bevy::math::DQuat::to_scaled_axis( + let output: Val = bevy::math::DQuat::inverse( _self.into_inner(), ) .into(); @@ -21349,27 +21417,25 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "to_euler", - |_self: Val, order: Val| { - let output: (f64, f64, f64) = bevy::math::DQuat::to_euler( - _self.into_inner(), - order.into_inner(), - ) + "is_finite", + |_self: Val| { + let output: bool = bevy::math::DQuat::is_finite(_self.into_inner()) .into(); output }, ) .register( - "to_array", - |_self: Ref| { - let output: [f64; 4] = bevy::math::DQuat::to_array(&_self).into(); + "is_nan", + |_self: Val| { + let output: bool = bevy::math::DQuat::is_nan(_self.into_inner()) + .into(); output }, ) .register( - "xyz", + "is_near_identity", |_self: Val| { - let output: Val = bevy::math::DQuat::xyz( + let output: bool = bevy::math::DQuat::is_near_identity( _self.into_inner(), ) .into(); @@ -21377,9 +21443,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "conjugate", + "is_normalized", |_self: Val| { - let output: Val = bevy::math::DQuat::conjugate( + let output: bool = bevy::math::DQuat::is_normalized( _self.into_inner(), ) .into(); @@ -21387,92 +21453,99 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "inverse", + "length", |_self: Val| { - let output: Val = bevy::math::DQuat::inverse( - _self.into_inner(), - ) + let output: f64 = bevy::math::DQuat::length(_self.into_inner()) .into(); output }, ) .register( - "dot", - |_self: Val, rhs: Val| { - let output: f64 = bevy::math::DQuat::dot( - _self.into_inner(), - rhs.into_inner(), - ) + "length_recip", + |_self: Val| { + let output: f64 = bevy::math::DQuat::length_recip(_self.into_inner()) .into(); output }, ) .register( - "length", + "length_squared", |_self: Val| { - let output: f64 = bevy::math::DQuat::length(_self.into_inner()) + let output: f64 = bevy::math::DQuat::length_squared( + _self.into_inner(), + ) .into(); output }, ) .register( - "length_squared", - |_self: Val| { - let output: f64 = bevy::math::DQuat::length_squared( + "lerp", + |_self: Val, end: Val, s: f64| { + let output: Val = bevy::math::DQuat::lerp( _self.into_inner(), + end.into_inner(), + s, ) .into(); output }, ) .register( - "length_recip", - |_self: Val| { - let output: f64 = bevy::math::DQuat::length_recip(_self.into_inner()) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "normalize", - |_self: Val| { - let output: Val = bevy::math::DQuat::normalize( - _self.into_inner(), - ) + "mul", + |_self: Val, rhs: Val| { + let output: Val = >::mul(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "is_finite", - |_self: Val| { - let output: bool = bevy::math::DQuat::is_finite(_self.into_inner()) + "mul", + |_self: Val, rhs: f64| { + let output: Val = >::mul(_self.into_inner(), rhs) .into(); output }, ) .register( - "is_nan", - |_self: Val| { - let output: bool = bevy::math::DQuat::is_nan(_self.into_inner()) + "mul_quat", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DQuat::mul_quat( + _self.into_inner(), + rhs.into_inner(), + ) .into(); output }, ) .register( - "is_normalized", - |_self: Val| { - let output: bool = bevy::math::DQuat::is_normalized( + "mul_vec3", + |_self: Val, rhs: Val| { + let output: Val = bevy::math::DQuat::mul_vec3( _self.into_inner(), + rhs.into_inner(), ) .into(); output }, ) .register( - "is_near_identity", + "neg", |_self: Val| { - let output: bool = bevy::math::DQuat::is_near_identity( + let output: Val = ::neg( _self.into_inner(), ) .into(); @@ -21480,11 +21553,10 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "angle_between", - |_self: Val, rhs: Val| { - let output: f64 = bevy::math::DQuat::angle_between( + "normalize", + |_self: Val| { + let output: Val = bevy::math::DQuat::normalize( _self.into_inner(), - rhs.into_inner(), ) .into(); output @@ -21506,34 +21578,6 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { output }, ) - .register( - "abs_diff_eq", - | - _self: Val, - rhs: Val, - max_abs_diff: f64| - { - let output: bool = bevy::math::DQuat::abs_diff_eq( - _self.into_inner(), - rhs.into_inner(), - max_abs_diff, - ) - .into(); - output - }, - ) - .register( - "lerp", - |_self: Val, end: Val, s: f64| { - let output: Val = bevy::math::DQuat::lerp( - _self.into_inner(), - end.into_inner(), - s, - ) - .into(); - output - }, - ) .register( "slerp", |_self: Val, end: Val, s: f64| { @@ -21547,41 +21591,37 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "mul_vec3", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DQuat::mul_vec3( - _self.into_inner(), - rhs.into_inner(), - ) + "sub", + |_self: Val, rhs: Val| { + let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) .into(); output }, ) .register( - "mul_quat", - |_self: Val, rhs: Val| { - let output: Val = bevy::math::DQuat::mul_quat( - _self.into_inner(), - rhs.into_inner(), - ) - .into(); + "to_array", + |_self: Ref| { + let output: [f64; 4] = bevy::math::DQuat::to_array(&_self).into(); output }, ) .register( - "from_affine3", - |a: Ref| { - let output: Val = bevy::math::DQuat::from_affine3( - &a, + "to_euler", + |_self: Val, order: Val| { + let output: (f64, f64, f64) = bevy::math::DQuat::to_euler( + _self.into_inner(), + order.into_inner(), ) .into(); output }, ) .register( - "as_quat", + "to_scaled_axis", |_self: Val| { - let output: Val = bevy::math::DQuat::as_quat( + let output: Val = bevy::math::DQuat::to_scaled_axis( _self.into_inner(), ) .into(); @@ -21589,87 +21629,81 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "neg", + "xyz", |_self: Val| { - let output: Val = ::neg( + let output: Val = bevy::math::DQuat::xyz( _self.into_inner(), ) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::EulerRot>::new(world) .register( - "sub", - |_self: Val, rhs: Val| { - let output: Val = >::sub(_self.into_inner(), rhs.into_inner()) + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( + &_self, + ) .into(); output }, ) .register( - "mul", - |_self: Val, rhs: f64| { - let output: Val = >::mul(_self.into_inner(), rhs) + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) .into(); output }, ) .register( "eq", - |_self: Ref, rhs: Ref| { - let output: bool = >::eq(&_self, &rhs) + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::BVec3A>::new(world) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) + "all", + |_self: Val| { + let output: bool = bevy::math::BVec3A::all(_self.into_inner()) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::EulerRot>::new(world) + ) .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) + "any", + |_self: Val| { + let output: bool = bevy::math::BVec3A::any(_self.into_inner()) .into(); output }, ) .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, - ) + "bitmask", + |_self: Val| { + let output: u32 = bevy::math::BVec3A::bitmask(_self.into_inner()) .into(); output }, ) .register( "clone", - |_self: Ref| { - let output: Val = ::clone( + |_self: Ref| { + let output: Val = ::clone( &_self, ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::BVec3A>::new(world) + ) .register( "eq", |_self: Ref, rhs: Ref| { @@ -21681,10 +21715,10 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, + "from_array", + |a: [bool; 3]| { + let output: Val = bevy::math::BVec3A::from_array( + a, ) .into(); output @@ -21703,63 +21737,63 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "splat", - |v: bool| { - let output: Val = bevy::math::BVec3A::splat(v) + "set", + |mut _self: Mut, index: usize, value: bool| { + let output: () = bevy::math::BVec3A::set(&mut _self, index, value) .into(); output }, ) .register( - "from_array", - |a: [bool; 3]| { - let output: Val = bevy::math::BVec3A::from_array( - a, - ) + "splat", + |v: bool| { + let output: Val = bevy::math::BVec3A::splat(v) .into(); output }, ) .register( - "bitmask", - |_self: Val| { - let output: u32 = bevy::math::BVec3A::bitmask(_self.into_inner()) - .into(); + "test", + |_self: Ref, index: usize| { + let output: bool = bevy::math::BVec3A::test(&_self, index).into(); output }, - ) + ); + NamespaceBuilder::<::bevy::math::BVec4A>::new(world) .register( - "any", - |_self: Val| { - let output: bool = bevy::math::BVec3A::any(_self.into_inner()) + "all", + |_self: Val| { + let output: bool = bevy::math::BVec4A::all(_self.into_inner()) .into(); output }, ) .register( - "all", - |_self: Val| { - let output: bool = bevy::math::BVec3A::all(_self.into_inner()) + "any", + |_self: Val| { + let output: bool = bevy::math::BVec4A::any(_self.into_inner()) .into(); output }, ) .register( - "test", - |_self: Ref, index: usize| { - let output: bool = bevy::math::BVec3A::test(&_self, index).into(); + "bitmask", + |_self: Val| { + let output: u32 = bevy::math::BVec4A::bitmask(_self.into_inner()) + .into(); output }, ) .register( - "set", - |mut _self: Mut, index: usize, value: bool| { - let output: () = bevy::math::BVec3A::set(&mut _self, index, value) + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) .into(); output }, - ); - NamespaceBuilder::<::bevy::math::BVec4A>::new(world) + ) .register( "eq", |_self: Ref, rhs: Ref| { @@ -21771,10 +21805,10 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, + "from_array", + |a: [bool; 4]| { + let output: Val = bevy::math::BVec4A::from_array( + a, ) .into(); output @@ -21794,70 +21828,68 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "splat", - |v: bool| { - let output: Val = bevy::math::BVec4A::splat(v) + "set", + |mut _self: Mut, index: usize, value: bool| { + let output: () = bevy::math::BVec4A::set(&mut _self, index, value) .into(); output }, ) .register( - "from_array", - |a: [bool; 4]| { - let output: Val = bevy::math::BVec4A::from_array( - a, - ) + "splat", + |v: bool| { + let output: Val = bevy::math::BVec4A::splat(v) .into(); output }, ) .register( - "bitmask", - |_self: Val| { - let output: u32 = bevy::math::BVec4A::bitmask(_self.into_inner()) - .into(); + "test", + |_self: Ref, index: usize| { + let output: bool = bevy::math::BVec4A::test(&_self, index).into(); output }, - ) + ); + NamespaceBuilder::<::smol_str::SmolStr>::new(world) .register( - "any", - |_self: Val| { - let output: bool = bevy::math::BVec4A::any(_self.into_inner()) + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) .into(); output }, ) .register( - "all", - |_self: Val| { - let output: bool = bevy::math::BVec4A::all(_self.into_inner()) + "eq", + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "test", - |_self: Ref, index: usize| { - let output: bool = bevy::math::BVec4A::test(&_self, index).into(); + "is_empty", + |_self: Ref| { + let output: bool = smol_str::SmolStr::is_empty(&_self).into(); output }, ) .register( - "set", - |mut _self: Mut, index: usize, value: bool| { - let output: () = bevy::math::BVec4A::set(&mut _self, index, value) + "is_heap_allocated", + |_self: Ref| { + let output: bool = smol_str::SmolStr::is_heap_allocated(&_self) .into(); output }, - ); - NamespaceBuilder::<::smol_str::SmolStr>::new(world) + ) .register( - "clone", + "len", |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); + let output: usize = smol_str::SmolStr::len(&_self).into(); output }, ) @@ -21870,40 +21902,49 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { .into(); output }, - ) + ); + NamespaceBuilder::<::uuid::Uuid>::new(world) .register( - "len", - |_self: Ref| { - let output: usize = smol_str::SmolStr::len(&_self).into(); + "as_u128", + |_self: Ref| { + let output: u128 = uuid::Uuid::as_u128(&_self).into(); output }, ) .register( - "is_empty", - |_self: Ref| { - let output: bool = smol_str::SmolStr::is_empty(&_self).into(); + "as_u64_pair", + |_self: Ref| { + let output: (u64, u64) = uuid::Uuid::as_u64_pair(&_self).into(); output }, ) .register( - "is_heap_allocated", - |_self: Ref| { - let output: bool = smol_str::SmolStr::is_heap_allocated(&_self) + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( + &_self, + ) .into(); output }, ) .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) .into(); output }, - ); - NamespaceBuilder::<::uuid::Uuid>::new(world) + ) + .register( + "encode_buffer", + || { + let output: [u8; 45] = uuid::Uuid::encode_buffer().into(); + output + }, + ) .register( "eq", |_self: Ref, other: Ref| { @@ -21915,16 +21956,16 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "nil", - || { - let output: Val = uuid::Uuid::nil().into(); + "from_bytes", + |bytes: [u8; 16]| { + let output: Val = uuid::Uuid::from_bytes(bytes).into(); output }, ) .register( - "max", - || { - let output: Val = uuid::Uuid::max().into(); + "from_bytes_le", + |b: [u8; 16]| { + let output: Val = uuid::Uuid::from_bytes_le(b).into(); output }, ) @@ -21954,16 +21995,11 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "from_bytes", - |bytes: [u8; 16]| { - let output: Val = uuid::Uuid::from_bytes(bytes).into(); - output - }, - ) - .register( - "from_bytes_le", - |b: [u8; 16]| { - let output: Val = uuid::Uuid::from_bytes_le(b).into(); + "get_node_id", + |_self: Ref| { + let output: bevy::reflect::erased_serde::__private::serde::__private::Option< + [u8; 6], + > = uuid::Uuid::get_node_id(&_self).into(); output }, ) @@ -21974,27 +22010,6 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { output }, ) - .register( - "as_u128", - |_self: Ref| { - let output: u128 = uuid::Uuid::as_u128(&_self).into(); - output - }, - ) - .register( - "to_u128_le", - |_self: Ref| { - let output: u128 = uuid::Uuid::to_u128_le(&_self).into(); - output - }, - ) - .register( - "as_u64_pair", - |_self: Ref| { - let output: (u64, u64) = uuid::Uuid::as_u64_pair(&_self).into(); - output - }, - ) .register( "into_bytes", |_self: Val| { @@ -22004,9 +22019,9 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "to_bytes_le", + "is_max", |_self: Ref| { - let output: [u8; 16] = uuid::Uuid::to_bytes_le(&_self).into(); + let output: bool = uuid::Uuid::is_max(&_self).into(); output }, ) @@ -22018,52 +22033,37 @@ impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { }, ) .register( - "is_max", - |_self: Ref| { - let output: bool = uuid::Uuid::is_max(&_self).into(); - output - }, - ) - .register( - "encode_buffer", + "max", || { - let output: [u8; 45] = uuid::Uuid::encode_buffer().into(); + let output: Val = uuid::Uuid::max().into(); output }, ) .register( - "get_node_id", - |_self: Ref| { - let output: bevy::reflect::erased_serde::__private::serde::__private::Option< - [u8; 6], - > = uuid::Uuid::get_node_id(&_self).into(); + "new_v4", + || { + let output: Val = uuid::Uuid::new_v4().into(); output }, ) .register( - "new_v4", + "nil", || { - let output: Val = uuid::Uuid::new_v4().into(); + let output: Val = uuid::Uuid::nil().into(); output }, ) .register( - "assert_receiver_is_total_eq", + "to_bytes_le", |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, - ) - .into(); + let output: [u8; 16] = uuid::Uuid::to_bytes_le(&_self).into(); output }, ) .register( - "clone", + "to_u128_le", |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); + let output: u128 = uuid::Uuid::to_u128_le(&_self).into(); output }, ); diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_time.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_time.rs index a74d5cac02..3175e34e8d 100644 --- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_time.rs +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_time.rs @@ -52,6 +52,34 @@ impl ::bevy::app::Plugin for BevyTimeScriptingPlugin { output }, ) + .register( + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) + .into(); + output + }, + ) + .register( + "elapsed_secs", + |_self: Ref| { + let output: f32 = bevy::time::prelude::Timer::elapsed_secs(&_self) + .into(); + output + }, + ) + .register( + "elapsed_secs_f64", + |_self: Ref| { + let output: f64 = bevy::time::prelude::Timer::elapsed_secs_f64( + &_self, + ) + .into(); + output + }, + ) .register( "eq", | @@ -65,17 +93,6 @@ impl ::bevy::app::Plugin for BevyTimeScriptingPlugin { output }, ) - .register( - "from_seconds", - |duration: f32, mode: Val| { - let output: Val = bevy::time::prelude::Timer::from_seconds( - duration, - mode.into_inner(), - ) - .into(); - output - }, - ) .register( "finished", |_self: Ref| { @@ -85,50 +102,47 @@ impl ::bevy::app::Plugin for BevyTimeScriptingPlugin { }, ) .register( - "just_finished", + "fraction", |_self: Ref| { - let output: bool = bevy::time::prelude::Timer::just_finished(&_self) + let output: f32 = bevy::time::prelude::Timer::fraction(&_self) .into(); output }, ) .register( - "elapsed_secs", + "fraction_remaining", |_self: Ref| { - let output: f32 = bevy::time::prelude::Timer::elapsed_secs(&_self) + let output: f32 = bevy::time::prelude::Timer::fraction_remaining( + &_self, + ) .into(); output }, ) .register( - "elapsed_secs_f64", - |_self: Ref| { - let output: f64 = bevy::time::prelude::Timer::elapsed_secs_f64( - &_self, + "from_seconds", + |duration: f32, mode: Val| { + let output: Val = bevy::time::prelude::Timer::from_seconds( + duration, + mode.into_inner(), ) .into(); output }, ) .register( - "mode", + "just_finished", |_self: Ref| { - let output: Val = bevy::time::prelude::Timer::mode( - &_self, - ) + let output: bool = bevy::time::prelude::Timer::just_finished(&_self) .into(); output }, ) .register( - "set_mode", - | - mut _self: Mut, - mode: Val| - { - let output: () = bevy::time::prelude::Timer::set_mode( - &mut _self, - mode.into_inner(), + "mode", + |_self: Ref| { + let output: Val = bevy::time::prelude::Timer::mode( + &_self, ) .into(); output @@ -143,17 +157,17 @@ impl ::bevy::app::Plugin for BevyTimeScriptingPlugin { }, ) .register( - "unpause", - |mut _self: Mut| { - let output: () = bevy::time::prelude::Timer::unpause(&mut _self) - .into(); + "paused", + |_self: Ref| { + let output: bool = bevy::time::prelude::Timer::paused(&_self).into(); output }, ) .register( - "paused", + "remaining_secs", |_self: Ref| { - let output: bool = bevy::time::prelude::Timer::paused(&_self).into(); + let output: f32 = bevy::time::prelude::Timer::remaining_secs(&_self) + .into(); output }, ) @@ -166,17 +180,23 @@ impl ::bevy::app::Plugin for BevyTimeScriptingPlugin { }, ) .register( - "fraction", - |_self: Ref| { - let output: f32 = bevy::time::prelude::Timer::fraction(&_self) + "set_mode", + | + mut _self: Mut, + mode: Val| + { + let output: () = bevy::time::prelude::Timer::set_mode( + &mut _self, + mode.into_inner(), + ) .into(); output }, ) .register( - "fraction_remaining", + "times_finished_this_tick", |_self: Ref| { - let output: f32 = bevy::time::prelude::Timer::fraction_remaining( + let output: u32 = bevy::time::prelude::Timer::times_finished_this_tick( &_self, ) .into(); @@ -184,34 +204,24 @@ impl ::bevy::app::Plugin for BevyTimeScriptingPlugin { }, ) .register( - "remaining_secs", - |_self: Ref| { - let output: f32 = bevy::time::prelude::Timer::remaining_secs(&_self) + "unpause", + |mut _self: Mut| { + let output: () = bevy::time::prelude::Timer::unpause(&mut _self) .into(); output }, - ) + ); + NamespaceBuilder::<::bevy::time::prelude::TimerMode>::new(world) .register( - "times_finished_this_tick", - |_self: Ref| { - let output: u32 = bevy::time::prelude::Timer::times_finished_this_tick( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::assert_receiver_is_total_eq( &_self, ) .into(); output }, ) - .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, - ) - .into(); - output - }, - ); - NamespaceBuilder::<::bevy::time::prelude::TimerMode>::new(world) .register( "clone", |_self: Ref| { @@ -234,16 +244,6 @@ impl ::bevy::app::Plugin for BevyTimeScriptingPlugin { .into(); output }, - ) - .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, - ) - .into(); - output - }, ); NamespaceBuilder::<::bevy::time::prelude::Virtual>::new(world) .register( @@ -258,9 +258,9 @@ impl ::bevy::app::Plugin for BevyTimeScriptingPlugin { ); NamespaceBuilder::<::bevy::time::Stopwatch>::new(world) .register( - "clone", + "assert_receiver_is_total_eq", |_self: Ref| { - let output: Val = ::clone( + let output: () = ::assert_receiver_is_total_eq( &_self, ) .into(); @@ -268,9 +268,11 @@ impl ::bevy::app::Plugin for BevyTimeScriptingPlugin { }, ) .register( - "new", - || { - let output: Val = bevy::time::Stopwatch::new() + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) .into(); output }, @@ -291,50 +293,48 @@ impl ::bevy::app::Plugin for BevyTimeScriptingPlugin { }, ) .register( - "pause", - |mut _self: Mut| { - let output: () = bevy::time::Stopwatch::pause(&mut _self).into(); + "eq", + |_self: Ref, other: Ref| { + let output: bool = >::eq(&_self, &other) + .into(); output }, ) .register( - "unpause", - |mut _self: Mut| { - let output: () = bevy::time::Stopwatch::unpause(&mut _self).into(); + "is_paused", + |_self: Ref| { + let output: bool = bevy::time::Stopwatch::is_paused(&_self).into(); output }, ) .register( - "is_paused", - |_self: Ref| { - let output: bool = bevy::time::Stopwatch::is_paused(&_self).into(); + "new", + || { + let output: Val = bevy::time::Stopwatch::new() + .into(); output }, ) .register( - "reset", + "pause", |mut _self: Mut| { - let output: () = bevy::time::Stopwatch::reset(&mut _self).into(); + let output: () = bevy::time::Stopwatch::pause(&mut _self).into(); output }, ) .register( - "assert_receiver_is_total_eq", - |_self: Ref| { - let output: () = ::assert_receiver_is_total_eq( - &_self, - ) - .into(); + "reset", + |mut _self: Mut| { + let output: () = bevy::time::Stopwatch::reset(&mut _self).into(); output }, ) .register( - "eq", - |_self: Ref, other: Ref| { - let output: bool = >::eq(&_self, &other) - .into(); + "unpause", + |mut _self: Mut| { + let output: () = bevy::time::Stopwatch::unpause(&mut _self).into(); output }, ); diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_transform.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_transform.rs index cab4d331d6..a9af8d8918 100644 --- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_transform.rs +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_transform.rs @@ -24,12 +24,10 @@ impl ::bevy::app::Plugin for BevyTransformScriptingPlugin { let mut world = app.world_mut(); NamespaceBuilder::<::bevy::transform::components::GlobalTransform>::new(world) .register( - "from_xyz", - |x: f32, y: f32, z: f32| { - let output: Val = bevy::transform::components::GlobalTransform::from_xyz( - x, - y, - z, + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, ) .into(); output @@ -46,42 +44,39 @@ impl ::bevy::app::Plugin for BevyTransformScriptingPlugin { }, ) .register( - "reparented_to", + "eq", | _self: Ref, - parent: Ref| + other: Ref| { - let output: Val = bevy::transform::components::GlobalTransform::reparented_to( - &_self, - &parent, - ) + let output: bool = >::eq(&_self, &other) .into(); output }, ) .register( - "mul_transform", - | - _self: Ref, - transform: Val| - { - let output: Val = bevy::transform::components::GlobalTransform::mul_transform( - &_self, - transform.into_inner(), + "from_xyz", + |x: f32, y: f32, z: f32| { + let output: Val = bevy::transform::components::GlobalTransform::from_xyz( + x, + y, + z, ) .into(); output }, ) .register( - "eq", + "mul", | - _self: Ref, - other: Ref| + _self: Val, + transform: Val| { - let output: bool = >::eq(&_self, &other) + let output: Val = >::mul(_self.into_inner(), transform.into_inner()) .into(); output }, @@ -90,39 +85,54 @@ impl ::bevy::app::Plugin for BevyTransformScriptingPlugin { "mul", | _self: Val, - transform: Val| + global_transform: Val| { let output: Val = >::mul(_self.into_inner(), transform.into_inner()) + bevy::transform::components::GlobalTransform, + >>::mul(_self.into_inner(), global_transform.into_inner()) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( + "mul_transform", + | + _self: Ref, + transform: Val| + { + let output: Val = bevy::transform::components::GlobalTransform::mul_transform( &_self, + transform.into_inner(), ) .into(); output }, ) .register( - "mul", + "reparented_to", | - _self: Val, - global_transform: Val| + _self: Ref, + parent: Ref| { - let output: Val = >::mul(_self.into_inner(), global_transform.into_inner()) + let output: Val = bevy::transform::components::GlobalTransform::reparented_to( + &_self, + &parent, + ) .into(); output }, ); NamespaceBuilder::<::bevy::transform::components::Transform>::new(world) + .register( + "clone", + |_self: Ref| { + let output: Val = ::clone( + &_self, + ) + .into(); + output + }, + ) .register( "eq", | @@ -149,33 +159,50 @@ impl ::bevy::app::Plugin for BevyTransformScriptingPlugin { }, ) .register( - "rotate_x", - |mut _self: Mut, angle: f32| { - let output: () = bevy::transform::components::Transform::rotate_x( - &mut _self, - angle, + "is_finite", + |_self: Ref| { + let output: bool = bevy::transform::components::Transform::is_finite( + &_self, ) .into(); output }, ) .register( - "rotate_y", - |mut _self: Mut, angle: f32| { - let output: () = bevy::transform::components::Transform::rotate_y( - &mut _self, - angle, - ) + "mul", + | + _self: Val, + global_transform: Val| + { + let output: Val = >::mul(_self.into_inner(), global_transform.into_inner()) .into(); output }, ) .register( - "rotate_z", - |mut _self: Mut, angle: f32| { - let output: () = bevy::transform::components::Transform::rotate_z( - &mut _self, - angle, + "mul", + | + _self: Val, + transform: Val| + { + let output: Val = >::mul(_self.into_inner(), transform.into_inner()) + .into(); + output + }, + ) + .register( + "mul_transform", + | + _self: Ref, + transform: Val| + { + let output: Val = bevy::transform::components::Transform::mul_transform( + &_self, + transform.into_inner(), ) .into(); output @@ -215,64 +242,37 @@ impl ::bevy::app::Plugin for BevyTransformScriptingPlugin { }, ) .register( - "mul_transform", - | - _self: Ref, - transform: Val| - { - let output: Val = bevy::transform::components::Transform::mul_transform( - &_self, - transform.into_inner(), + "rotate_x", + |mut _self: Mut, angle: f32| { + let output: () = bevy::transform::components::Transform::rotate_x( + &mut _self, + angle, ) .into(); output }, ) .register( - "is_finite", - |_self: Ref| { - let output: bool = bevy::transform::components::Transform::is_finite( - &_self, + "rotate_y", + |mut _self: Mut, angle: f32| { + let output: () = bevy::transform::components::Transform::rotate_y( + &mut _self, + angle, ) .into(); output }, ) .register( - "clone", - |_self: Ref| { - let output: Val = ::clone( - &_self, + "rotate_z", + |mut _self: Mut, angle: f32| { + let output: () = bevy::transform::components::Transform::rotate_z( + &mut _self, + angle, ) .into(); output }, - ) - .register( - "mul", - | - _self: Val, - transform: Val| - { - let output: Val = >::mul(_self.into_inner(), transform.into_inner()) - .into(); - output - }, - ) - .register( - "mul", - | - _self: Val, - global_transform: Val| - { - let output: Val = >::mul(_self.into_inner(), global_transform.into_inner()) - .into(); - output - }, ); } }