From e56bb3a8778460a06a12df981eb475ac5e62a487 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Sat, 28 Dec 2024 13:45:32 +0000 Subject: [PATCH] chore(codegen): update bevy bindings --- .../src/bevy_bindings/bevy_core.rs | 42 + .../src/bevy_bindings/bevy_ecs.rs | 385 + .../src/bevy_bindings/bevy_hierarchy.rs | 95 + .../src/bevy_bindings/bevy_input.rs | 1437 + .../src/bevy_bindings/bevy_math.rs | 3548 +++ .../src/bevy_bindings/bevy_reflect.rs | 22507 ++++++++++++++++ .../src/bevy_bindings/bevy_time.rs | 355 + .../src/bevy_bindings/bevy_transform.rs | 278 + .../src/bevy_bindings/mod.rs | 25 + 9 files changed, 28672 insertions(+) create mode 100644 crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_core.rs create mode 100644 crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_ecs.rs create mode 100644 crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_hierarchy.rs create mode 100644 crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_input.rs create mode 100644 crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_math.rs create mode 100644 crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_reflect.rs create mode 100644 crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_time.rs create mode 100644 crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_transform.rs create mode 100644 crates/bevy_mod_scripting_functions/src/bevy_bindings/mod.rs 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 new file mode 100644 index 0000000000..870b902312 --- /dev/null +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_core.rs @@ -0,0 +1,42 @@ +// @generated by cargo bevy-api-gen generate, modify the templates not this file +#![allow(clippy::all)] +#![allow(unused, deprecated, dead_code)] +#![cfg_attr(rustfmt, rustfmt_skip)] +use super::bevy_ecs::*; +use super::bevy_reflect::*; +use bevy_mod_scripting_core::{ + AddContextInitializer, StoreDocumentation, + bindings::{ReflectReference, function::from::{Ref, Mut, Val}}, +}; +use crate::*; +pub struct BevyCoreScriptingPlugin; +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) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::core::prelude::Name::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::core::prelude::Name::clone( + _self.into(), + ) + .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 new file mode 100644 index 0000000000..6bf900abf5 --- /dev/null +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_ecs.rs @@ -0,0 +1,385 @@ +// @generated by cargo bevy-api-gen generate, modify the templates not this file +#![allow(clippy::all)] +#![allow(unused, deprecated, dead_code)] +#![cfg_attr(rustfmt, rustfmt_skip)] +use super::bevy_reflect::*; +use bevy_mod_scripting_core::{ + AddContextInitializer, StoreDocumentation, + bindings::{ReflectReference, function::from::{Ref, Mut, Val}}, +}; +use crate::*; +pub struct BevyEcsScriptingPlugin; +impl ::bevy::app::Plugin for BevyEcsScriptingPlugin { + fn build(&self, app: &mut ::bevy::prelude::App) { + let mut world = app.world_mut(); + NamespaceBuilder::<::bevy::ecs::entity::Entity>::new(world) + .overwrite_script_function( + "from_raw", + |index: u32| { + let output: Val = ::bevy::ecs::entity::Entity::from_raw( + index.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_bits", + |_self: Val| { + let output: u64 = ::bevy::ecs::entity::Entity::to_bits(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "from_bits", + |bits: u64| { + let output: Val = ::bevy::ecs::entity::Entity::from_bits( + bits.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "index", + |_self: Val| { + let output: u32 = ::bevy::ecs::entity::Entity::index(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "generation", + |_self: Val| { + let output: u32 = ::bevy::ecs::entity::Entity::generation( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::ecs::entity::Entity::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::ecs::entity::Entity::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::ecs::world::OnAdd>::new(world); + NamespaceBuilder::<::bevy::ecs::world::OnInsert>::new(world); + NamespaceBuilder::<::bevy::ecs::world::OnRemove>::new(world); + NamespaceBuilder::<::bevy::ecs::world::OnReplace>::new(world); + NamespaceBuilder::<::bevy::ecs::component::ComponentId>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::ecs::component::ComponentId::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::ecs::component::ComponentId::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |index: usize| { + let output: Val = ::bevy::ecs::component::ComponentId::new( + index.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "index", + |_self: Val| { + let output: usize = ::bevy::ecs::component::ComponentId::index( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::ecs::component::ComponentId::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::ecs::component::Tick>::new(world) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::ecs::component::Tick::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::ecs::component::Tick::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::ecs::component::Tick::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |tick: u32| { + let output: Val = ::bevy::ecs::component::Tick::new( + tick.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "get", + |_self: Val| { + let output: u32 = ::bevy::ecs::component::Tick::get(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "set", + |_self: Mut, tick: u32| { + let output: () = ::bevy::ecs::component::Tick::set( + _self.into(), + tick.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_newer_than", + | + _self: Val, + last_run: Val, + this_run: Val| + { + let output: bool = ::bevy::ecs::component::Tick::is_newer_than( + _self.into(), + last_run.into(), + this_run.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::ecs::component::ComponentTicks>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::ecs::component::ComponentTicks::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_added", + | + _self: Ref, + last_run: Val, + this_run: Val| + { + let output: bool = ::bevy::ecs::component::ComponentTicks::is_added( + _self.into(), + last_run.into(), + this_run.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_changed", + | + _self: Ref, + last_run: Val, + this_run: Val| + { + let output: bool = ::bevy::ecs::component::ComponentTicks::is_changed( + _self.into(), + last_run.into(), + this_run.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |change_tick: Val| { + let output: Val = ::bevy::ecs::component::ComponentTicks::new( + change_tick.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "set_changed", + | + _self: Mut, + change_tick: Val| + { + let output: () = ::bevy::ecs::component::ComponentTicks::set_changed( + _self.into(), + change_tick.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::ecs::identifier::Identifier>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::ecs::identifier::Identifier::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "low", + |_self: Val| { + let output: u32 = ::bevy::ecs::identifier::Identifier::low( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "masked_high", + |_self: Val| { + let output: u32 = ::bevy::ecs::identifier::Identifier::masked_high( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_bits", + |_self: Val| { + let output: u64 = ::bevy::ecs::identifier::Identifier::to_bits( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_bits", + |value: u64| { + let output: Val = ::bevy::ecs::identifier::Identifier::from_bits( + value.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::ecs::identifier::Identifier::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::ecs::entity::EntityHash>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::ecs::entity::EntityHash::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::< + ::bevy::ecs::removal_detection::RemovedComponentEntity, + >::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val< + bevy::ecs::removal_detection::RemovedComponentEntity, + > = ::bevy::ecs::removal_detection::RemovedComponentEntity::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::ecs::system::SystemIdMarker>::new(world); + } +} 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 new file mode 100644 index 0000000000..faa3ed7af6 --- /dev/null +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_hierarchy.rs @@ -0,0 +1,95 @@ +// @generated by cargo bevy-api-gen generate, modify the templates not this file +#![allow(clippy::all)] +#![allow(unused, deprecated, dead_code)] +#![cfg_attr(rustfmt, rustfmt_skip)] +use super::bevy_ecs::*; +use super::bevy_reflect::*; +use super::bevy_core::*; +use bevy_mod_scripting_core::{ + AddContextInitializer, StoreDocumentation, + bindings::{ReflectReference, function::from::{Ref, Mut, Val}}, +}; +use crate::*; +pub struct BevyHierarchyScriptingPlugin; +impl ::bevy::app::Plugin for BevyHierarchyScriptingPlugin { + fn build(&self, app: &mut ::bevy::prelude::App) { + let mut world = app.world_mut(); + NamespaceBuilder::<::bevy::hierarchy::prelude::Children>::new(world) + .overwrite_script_function( + "swap", + | + _self: Mut, + a_index: usize, + b_index: usize| + { + let output: () = ::bevy::hierarchy::prelude::Children::swap( + _self.into(), + a_index.into(), + b_index.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::hierarchy::prelude::Parent>::new(world) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::hierarchy::prelude::Parent::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::hierarchy::prelude::Parent::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::hierarchy::HierarchyEvent>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::hierarchy::HierarchyEvent::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::hierarchy::HierarchyEvent::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::hierarchy::HierarchyEvent::assert_receiver_is_total_eq( + _self.into(), + ) + .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 new file mode 100644 index 0000000000..db3d2207c3 --- /dev/null +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_input.rs @@ -0,0 +1,1437 @@ +// @generated by cargo bevy-api-gen generate, modify the templates not this file +#![allow(clippy::all)] +#![allow(unused, deprecated, dead_code)] +#![cfg_attr(rustfmt, rustfmt_skip)] +use super::bevy_ecs::*; +use super::bevy_reflect::*; +use super::bevy_core::*; +use super::bevy_math::*; +use bevy_mod_scripting_core::{ + AddContextInitializer, StoreDocumentation, + bindings::{ReflectReference, function::from::{Ref, Mut, Val}}, +}; +use crate::*; +pub struct BevyInputScriptingPlugin; +impl ::bevy::app::Plugin for BevyInputScriptingPlugin { + fn build(&self, app: &mut ::bevy::prelude::App) { + let mut world = app.world_mut(); + NamespaceBuilder::<::bevy::input::gamepad::Gamepad>::new(world) + .overwrite_script_function( + "vendor_id", + |_self: Ref| { + let output: std::option::Option = ::bevy::input::gamepad::Gamepad::vendor_id( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "product_id", + |_self: Ref| { + let output: std::option::Option = ::bevy::input::gamepad::Gamepad::product_id( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "pressed", + | + _self: Ref, + button_type: Val| + { + let output: bool = ::bevy::input::gamepad::Gamepad::pressed( + _self.into(), + button_type.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "just_pressed", + | + _self: Ref, + button_type: Val| + { + let output: bool = ::bevy::input::gamepad::Gamepad::just_pressed( + _self.into(), + button_type.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "just_released", + | + _self: Ref, + button_type: Val| + { + let output: bool = ::bevy::input::gamepad::Gamepad::just_released( + _self.into(), + button_type.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::gamepad::GamepadAxis>::new(world) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::input::gamepad::GamepadAxis::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::gamepad::GamepadAxis::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::gamepad::GamepadAxis::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::gamepad::GamepadButton>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::gamepad::GamepadButton::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::gamepad::GamepadButton::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::input::gamepad::GamepadButton::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::gamepad::GamepadSettings>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::gamepad::GamepadSettings::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::keyboard::KeyCode>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::keyboard::KeyCode::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::keyboard::KeyCode::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::input::keyboard::KeyCode::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::mouse::MouseButton>::new(world) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::input::mouse::MouseButton::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::mouse::MouseButton::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::mouse::MouseButton::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::touch::TouchInput>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::touch::TouchInput::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::touch::TouchInput::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::keyboard::KeyboardFocusLost>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::keyboard::KeyboardFocusLost::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::input::keyboard::KeyboardFocusLost::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::keyboard::KeyboardFocusLost::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::keyboard::KeyboardInput>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::keyboard::KeyboardInput::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::keyboard::KeyboardInput::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::input::keyboard::KeyboardInput::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::mouse::AccumulatedMouseMotion>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::mouse::AccumulatedMouseMotion::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::mouse::AccumulatedMouseMotion::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::mouse::AccumulatedMouseScroll>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::mouse::AccumulatedMouseScroll::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::mouse::AccumulatedMouseScroll::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::mouse::MouseButtonInput>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::mouse::MouseButtonInput::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::mouse::MouseButtonInput::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::input::mouse::MouseButtonInput::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::mouse::MouseMotion>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::mouse::MouseMotion::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::mouse::MouseMotion::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::mouse::MouseWheel>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::mouse::MouseWheel::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::mouse::MouseWheel::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::gamepad::GamepadAxisChangedEvent>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::gamepad::GamepadAxisChangedEvent::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::gamepad::GamepadAxisChangedEvent::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::gamepad::GamepadButtonChangedEvent>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::gamepad::GamepadButtonChangedEvent::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::gamepad::GamepadButtonChangedEvent::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::< + ::bevy::input::gamepad::GamepadButtonStateChangedEvent, + >::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val< + bevy::input::gamepad::GamepadButtonStateChangedEvent, + > = ::bevy::input::gamepad::GamepadButtonStateChangedEvent::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::gamepad::GamepadButtonStateChangedEvent::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::input::gamepad::GamepadButtonStateChangedEvent::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::gamepad::GamepadConnection>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::gamepad::GamepadConnection::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::gamepad::GamepadConnection::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::gamepad::GamepadConnectionEvent>::new(world) + .overwrite_script_function( + "connected", + |_self: Ref| { + let output: bool = ::bevy::input::gamepad::GamepadConnectionEvent::connected( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "disconnected", + |_self: Ref| { + let output: bool = ::bevy::input::gamepad::GamepadConnectionEvent::disconnected( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::gamepad::GamepadConnectionEvent::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::gamepad::GamepadConnectionEvent::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::gamepad::GamepadEvent>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::gamepad::GamepadEvent::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::gamepad::GamepadEvent::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::gamepad::GamepadInput>::new(world) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::input::gamepad::GamepadInput::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::gamepad::GamepadInput::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::gamepad::GamepadInput::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::gamepad::GamepadRumbleRequest>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::gamepad::GamepadRumbleRequest::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::< + ::bevy::input::gamepad::RawGamepadAxisChangedEvent, + >::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::gamepad::RawGamepadAxisChangedEvent::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::gamepad::RawGamepadAxisChangedEvent::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::< + ::bevy::input::gamepad::RawGamepadButtonChangedEvent, + >::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val< + bevy::input::gamepad::RawGamepadButtonChangedEvent, + > = ::bevy::input::gamepad::RawGamepadButtonChangedEvent::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::gamepad::RawGamepadButtonChangedEvent::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::gamepad::RawGamepadEvent>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::gamepad::RawGamepadEvent::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::gamepad::RawGamepadEvent::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::gestures::PinchGesture>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::gestures::PinchGesture::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::gestures::PinchGesture::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::gestures::RotationGesture>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::gestures::RotationGesture::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::gestures::RotationGesture::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::gestures::DoubleTapGesture>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::gestures::DoubleTapGesture::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::gestures::DoubleTapGesture::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::gestures::PanGesture>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::gestures::PanGesture::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::gestures::PanGesture::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::ButtonState>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::ButtonState::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_pressed", + |_self: Ref| { + let output: bool = ::bevy::input::ButtonState::is_pressed( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::input::ButtonState::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::ButtonState::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::gamepad::ButtonSettings>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::gamepad::ButtonSettings::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::gamepad::ButtonSettings::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_pressed", + |_self: Ref, value: f32| { + let output: bool = ::bevy::input::gamepad::ButtonSettings::is_pressed( + _self.into(), + value.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_released", + |_self: Ref, value: f32| { + let output: bool = ::bevy::input::gamepad::ButtonSettings::is_released( + _self.into(), + value.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "press_threshold", + |_self: Ref| { + let output: f32 = ::bevy::input::gamepad::ButtonSettings::press_threshold( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "set_press_threshold", + |_self: Mut, value: f32| { + let output: f32 = ::bevy::input::gamepad::ButtonSettings::set_press_threshold( + _self.into(), + value.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "release_threshold", + |_self: Ref| { + let output: f32 = ::bevy::input::gamepad::ButtonSettings::release_threshold( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "set_release_threshold", + |_self: Mut, value: f32| { + let output: f32 = ::bevy::input::gamepad::ButtonSettings::set_release_threshold( + _self.into(), + value.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::gamepad::AxisSettings>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::gamepad::AxisSettings::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "livezone_upperbound", + |_self: Ref| { + let output: f32 = ::bevy::input::gamepad::AxisSettings::livezone_upperbound( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "set_livezone_upperbound", + |_self: Mut, value: f32| { + let output: f32 = ::bevy::input::gamepad::AxisSettings::set_livezone_upperbound( + _self.into(), + value.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "deadzone_upperbound", + |_self: Ref| { + let output: f32 = ::bevy::input::gamepad::AxisSettings::deadzone_upperbound( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "set_deadzone_upperbound", + |_self: Mut, value: f32| { + let output: f32 = ::bevy::input::gamepad::AxisSettings::set_deadzone_upperbound( + _self.into(), + value.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "livezone_lowerbound", + |_self: Ref| { + let output: f32 = ::bevy::input::gamepad::AxisSettings::livezone_lowerbound( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "set_livezone_lowerbound", + |_self: Mut, value: f32| { + let output: f32 = ::bevy::input::gamepad::AxisSettings::set_livezone_lowerbound( + _self.into(), + value.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "deadzone_lowerbound", + |_self: Ref| { + let output: f32 = ::bevy::input::gamepad::AxisSettings::deadzone_lowerbound( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "set_deadzone_lowerbound", + |_self: Mut, value: f32| { + let output: f32 = ::bevy::input::gamepad::AxisSettings::set_deadzone_lowerbound( + _self.into(), + value.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "threshold", + |_self: Ref| { + let output: f32 = ::bevy::input::gamepad::AxisSettings::threshold( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "set_threshold", + |_self: Mut, value: f32| { + let output: f32 = ::bevy::input::gamepad::AxisSettings::set_threshold( + _self.into(), + value.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp", + |_self: Ref, new_value: f32| { + let output: f32 = ::bevy::input::gamepad::AxisSettings::clamp( + _self.into(), + new_value.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "filter", + | + _self: Ref, + new_value: f32, + old_value: std::option::Option| + { + let output: std::option::Option = ::bevy::input::gamepad::AxisSettings::filter( + _self.into(), + new_value.into(), + old_value.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::gamepad::AxisSettings::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::gamepad::ButtonAxisSettings>::new(world) + .overwrite_script_function( + "filter", + | + _self: Ref, + new_value: f32, + old_value: std::option::Option| + { + let output: std::option::Option = ::bevy::input::gamepad::ButtonAxisSettings::filter( + _self.into(), + new_value.into(), + old_value.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::gamepad::ButtonAxisSettings::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::gamepad::GamepadRumbleIntensity>::new(world) + .overwrite_script_function( + "weak_motor", + |intensity: f32| { + let output: Val = ::bevy::input::gamepad::GamepadRumbleIntensity::weak_motor( + intensity.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "strong_motor", + |intensity: f32| { + let output: Val = ::bevy::input::gamepad::GamepadRumbleIntensity::strong_motor( + intensity.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::gamepad::GamepadRumbleIntensity::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::gamepad::GamepadRumbleIntensity::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::keyboard::Key>::new(world) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::input::keyboard::Key::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::keyboard::Key::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::keyboard::Key::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::keyboard::NativeKeyCode>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::keyboard::NativeKeyCode::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::keyboard::NativeKeyCode::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::input::keyboard::NativeKeyCode::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::keyboard::NativeKey>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::keyboard::NativeKey::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::input::keyboard::NativeKey::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::keyboard::NativeKey::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::mouse::MouseScrollUnit>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::mouse::MouseScrollUnit::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::input::mouse::MouseScrollUnit::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::mouse::MouseScrollUnit::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::touch::TouchPhase>::new(world) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::input::touch::TouchPhase::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::touch::TouchPhase::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::touch::TouchPhase::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::input::touch::ForceTouch>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::input::touch::ForceTouch::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::input::touch::ForceTouch::eq( + _self.into(), + other.into(), + ) + .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 new file mode 100644 index 0000000000..09e42ace0a --- /dev/null +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_math.rs @@ -0,0 +1,3548 @@ +// @generated by cargo bevy-api-gen generate, modify the templates not this file +#![allow(clippy::all)] +#![allow(unused, deprecated, dead_code)] +#![cfg_attr(rustfmt, rustfmt_skip)] +use super::bevy_reflect::*; +use bevy_mod_scripting_core::{ + AddContextInitializer, StoreDocumentation, + bindings::{ReflectReference, function::from::{Ref, Mut, Val}}, +}; +use crate::*; +pub struct BevyMathScriptingPlugin; +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) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::AspectRatio::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "ratio", + |_self: Ref| { + let output: f32 = ::bevy::math::AspectRatio::ratio(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "inverse", + |_self: Ref| { + let output: Val = ::bevy::math::AspectRatio::inverse( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_landscape", + |_self: Ref| { + let output: bool = ::bevy::math::AspectRatio::is_landscape( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_portrait", + |_self: Ref| { + let output: bool = ::bevy::math::AspectRatio::is_portrait( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_square", + |_self: Ref| { + let output: bool = ::bevy::math::AspectRatio::is_square(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::AspectRatio::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::CompassOctant>::new(world) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::math::CompassOctant::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::CompassOctant::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::CompassOctant::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::CompassQuadrant>::new(world) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::math::CompassQuadrant::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::CompassQuadrant::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::CompassQuadrant::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::Isometry2d>::new(world) + .overwrite_script_function( + "mul", + | + _self: Val, + rhs: Val| + { + let output: Val = ::bevy::math::Isometry2d::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation", + |rotation: Val| { + let output: Val = ::bevy::math::Isometry2d::from_rotation( + rotation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_xy", + |x: f32, y: f32| { + let output: Val = ::bevy::math::Isometry2d::from_xy( + x.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "inverse", + |_self: Ref| { + let output: Val = ::bevy::math::Isometry2d::inverse( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "inverse_mul", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Isometry2d::inverse_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::Isometry2d::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Isometry2d::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::Isometry2d::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::Isometry3d>::new(world) + .overwrite_script_function( + "from_xyz", + |x: f32, y: f32, z: f32| { + let output: Val = ::bevy::math::Isometry3d::from_xyz( + x.into(), + y.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "inverse", + |_self: Ref| { + let output: Val = ::bevy::math::Isometry3d::inverse( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "inverse_mul", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Isometry3d::inverse_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::Isometry3d::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Isometry3d::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + | + _self: Val, + rhs: Val| + { + let output: Val = ::bevy::math::Isometry3d::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::Isometry3d::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::Ray2d>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::Ray2d::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::Ray2d::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::Ray3d>::new(world) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::Ray3d::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::Ray3d::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::Rot2>::new(world) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Rot2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "radians", + |radians: f32| { + let output: Val = ::bevy::math::Rot2::radians( + radians.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "degrees", + |degrees: f32| { + let output: Val = ::bevy::math::Rot2::degrees( + degrees.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "turn_fraction", + |fraction: f32| { + let output: Val = ::bevy::math::Rot2::turn_fraction( + fraction.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_sin_cos", + |sin: f32, cos: f32| { + let output: Val = ::bevy::math::Rot2::from_sin_cos( + sin.into(), + cos.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_radians", + |_self: Val| { + let output: f32 = ::bevy::math::Rot2::as_radians(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "as_degrees", + |_self: Val| { + let output: f32 = ::bevy::math::Rot2::as_degrees(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "as_turn_fraction", + |_self: Val| { + let output: f32 = ::bevy::math::Rot2::as_turn_fraction(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "sin_cos", + |_self: Val| { + let output: (f32, f32) = ::bevy::math::Rot2::sin_cos(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "length", + |_self: Val| { + let output: f32 = ::bevy::math::Rot2::length(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "length_squared", + |_self: Val| { + let output: f32 = ::bevy::math::Rot2::length_squared(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "length_recip", + |_self: Val| { + let output: f32 = ::bevy::math::Rot2::length_recip(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize", + |_self: Val| { + let output: Val = ::bevy::math::Rot2::normalize( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "fast_renormalize", + |_self: Val| { + let output: Val = ::bevy::math::Rot2::fast_renormalize( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite", + |_self: Val| { + let output: bool = ::bevy::math::Rot2::is_finite(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_nan", + |_self: Val| { + let output: bool = ::bevy::math::Rot2::is_nan(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "is_normalized", + |_self: Val| { + let output: bool = ::bevy::math::Rot2::is_normalized(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_near_identity", + |_self: Val| { + let output: bool = ::bevy::math::Rot2::is_near_identity(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "angle_between", + |_self: Val, other: Val| { + let output: f32 = ::bevy::math::Rot2::angle_between( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "angle_to", + |_self: Val, other: Val| { + let output: f32 = ::bevy::math::Rot2::angle_to( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "inverse", + |_self: Val| { + let output: Val = ::bevy::math::Rot2::inverse( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "nlerp", + |_self: Val, end: Val, s: f32| { + let output: Val = ::bevy::math::Rot2::nlerp( + _self.into(), + end.into(), + s.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "slerp", + |_self: Val, end: Val, s: f32| { + let output: Val = ::bevy::math::Rot2::slerp( + _self.into(), + end.into(), + s.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + | + _self: Val, + direction: Val| + { + let output: Val = ::bevy::math::Rot2::mul( + _self.into(), + direction.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::Rot2::eq(_self.into(), other.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::Rot2::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::prelude::Dir2>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::prelude::Dir2::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_xy_unchecked", + |x: f32, y: f32| { + let output: Val = ::bevy::math::prelude::Dir2::from_xy_unchecked( + x.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "slerp", + | + _self: Val, + rhs: Val, + s: f32| + { + let output: Val = ::bevy::math::prelude::Dir2::slerp( + _self.into(), + rhs.into(), + s.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rotation_to", + | + _self: Val, + other: Val| + { + let output: Val = ::bevy::math::prelude::Dir2::rotation_to( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rotation_from", + | + _self: Val, + other: Val| + { + let output: Val = ::bevy::math::prelude::Dir2::rotation_from( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rotation_from_x", + |_self: Val| { + let output: Val = ::bevy::math::prelude::Dir2::rotation_from_x( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rotation_to_x", + |_self: Val| { + let output: Val = ::bevy::math::prelude::Dir2::rotation_to_x( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rotation_from_y", + |_self: Val| { + let output: Val = ::bevy::math::prelude::Dir2::rotation_from_y( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rotation_to_y", + |_self: Val| { + let output: Val = ::bevy::math::prelude::Dir2::rotation_to_y( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "fast_renormalize", + |_self: Val| { + let output: Val = ::bevy::math::prelude::Dir2::fast_renormalize( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::prelude::Dir2::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::prelude::Dir2::neg( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::prelude::Dir3>::new(world) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::prelude::Dir3::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::prelude::Dir3::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::prelude::Dir3::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_xyz_unchecked", + |x: f32, y: f32, z: f32| { + let output: Val = ::bevy::math::prelude::Dir3::from_xyz_unchecked( + x.into(), + y.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "slerp", + | + _self: Val, + rhs: Val, + s: f32| + { + let output: Val = ::bevy::math::prelude::Dir3::slerp( + _self.into(), + rhs.into(), + s.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "fast_renormalize", + |_self: Val| { + let output: Val = ::bevy::math::prelude::Dir3::fast_renormalize( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::prelude::Dir3A>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::prelude::Dir3A::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::prelude::Dir3A::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::prelude::Dir3A::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_xyz_unchecked", + |x: f32, y: f32, z: f32| { + let output: Val = ::bevy::math::prelude::Dir3A::from_xyz_unchecked( + x.into(), + y.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "slerp", + | + _self: Val, + rhs: Val, + s: f32| + { + let output: Val = ::bevy::math::prelude::Dir3A::slerp( + _self.into(), + rhs.into(), + s.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "fast_renormalize", + |_self: Val| { + let output: Val = ::bevy::math::prelude::Dir3A::fast_renormalize( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::prelude::IRect>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::prelude::IRect::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::math::prelude::IRect::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::prelude::IRect::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x0: i32, y0: i32, x1: i32, y1: i32| { + let output: Val = ::bevy::math::prelude::IRect::new( + x0.into(), + y0.into(), + x1.into(), + y1.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_empty", + |_self: Ref| { + let output: bool = ::bevy::math::prelude::IRect::is_empty( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "width", + |_self: Ref| { + let output: i32 = ::bevy::math::prelude::IRect::width(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "height", + |_self: Ref| { + let output: i32 = ::bevy::math::prelude::IRect::height(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "union", + | + _self: Ref, + other: Val| + { + let output: Val = ::bevy::math::prelude::IRect::union( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "intersect", + | + _self: Ref, + other: Val| + { + let output: Val = ::bevy::math::prelude::IRect::intersect( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "inflate", + |_self: Ref, expansion: i32| { + let output: Val = ::bevy::math::prelude::IRect::inflate( + _self.into(), + expansion.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_rect", + |_self: Ref| { + let output: Val = ::bevy::math::prelude::IRect::as_rect( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_urect", + |_self: Ref| { + let output: Val = ::bevy::math::prelude::IRect::as_urect( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::prelude::Rect>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::prelude::Rect::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x0: f32, y0: f32, x1: f32, y1: f32| { + let output: Val = ::bevy::math::prelude::Rect::new( + x0.into(), + y0.into(), + x1.into(), + y1.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_empty", + |_self: Ref| { + let output: bool = ::bevy::math::prelude::Rect::is_empty( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "width", + |_self: Ref| { + let output: f32 = ::bevy::math::prelude::Rect::width(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "height", + |_self: Ref| { + let output: f32 = ::bevy::math::prelude::Rect::height(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "union", + | + _self: Ref, + other: Val| + { + let output: Val = ::bevy::math::prelude::Rect::union( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "intersect", + | + _self: Ref, + other: Val| + { + let output: Val = ::bevy::math::prelude::Rect::intersect( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "inflate", + |_self: Ref, expansion: f32| { + let output: Val = ::bevy::math::prelude::Rect::inflate( + _self.into(), + expansion.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize", + | + _self: Ref, + other: Val| + { + let output: Val = ::bevy::math::prelude::Rect::normalize( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_irect", + |_self: Ref| { + let output: Val = ::bevy::math::prelude::Rect::as_irect( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_urect", + |_self: Ref| { + let output: Val = ::bevy::math::prelude::Rect::as_urect( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::prelude::Rect::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::prelude::URect>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::prelude::URect::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x0: u32, y0: u32, x1: u32, y1: u32| { + let output: Val = ::bevy::math::prelude::URect::new( + x0.into(), + y0.into(), + x1.into(), + y1.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_empty", + |_self: Ref| { + let output: bool = ::bevy::math::prelude::URect::is_empty( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "width", + |_self: Ref| { + let output: u32 = ::bevy::math::prelude::URect::width(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "height", + |_self: Ref| { + let output: u32 = ::bevy::math::prelude::URect::height(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "union", + | + _self: Ref, + other: Val| + { + let output: Val = ::bevy::math::prelude::URect::union( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "intersect", + | + _self: Ref, + other: Val| + { + let output: Val = ::bevy::math::prelude::URect::intersect( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "inflate", + |_self: Ref, expansion: i32| { + let output: Val = ::bevy::math::prelude::URect::inflate( + _self.into(), + expansion.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_rect", + |_self: Ref| { + let output: Val = ::bevy::math::prelude::URect::as_rect( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_irect", + |_self: Ref| { + let output: Val = ::bevy::math::prelude::URect::as_irect( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::prelude::URect::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::math::prelude::URect::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::Affine3>::new(world); + NamespaceBuilder::<::bevy::math::bounding::Aabb2d>::new(world) + .overwrite_script_function( + "bounding_circle", + |_self: Ref| { + let output: Val = ::bevy::math::bounding::Aabb2d::bounding_circle( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::bounding::Aabb2d::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::bounding::BoundingCircle>::new(world) + .overwrite_script_function( + "radius", + |_self: Ref| { + let output: f32 = ::bevy::math::bounding::BoundingCircle::radius( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "aabb_2d", + |_self: Ref| { + let output: Val = ::bevy::math::bounding::BoundingCircle::aabb_2d( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::bounding::BoundingCircle::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::Circle>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::Circle::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |radius: f32| { + let output: Val = ::bevy::math::primitives::Circle::new( + radius.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "diameter", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Circle::diameter( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Circle::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::Annulus>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Annulus::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::Annulus::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |inner_radius: f32, outer_radius: f32| { + let output: Val = ::bevy::math::primitives::Annulus::new( + inner_radius.into(), + outer_radius.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "diameter", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Annulus::diameter( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "thickness", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Annulus::thickness( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::Arc2d>::new(world) + .overwrite_script_function( + "new", + |radius: f32, half_angle: f32| { + let output: Val = ::bevy::math::primitives::Arc2d::new( + radius.into(), + half_angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_radians", + |radius: f32, angle: f32| { + let output: Val = ::bevy::math::primitives::Arc2d::from_radians( + radius.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_degrees", + |radius: f32, angle: f32| { + let output: Val = ::bevy::math::primitives::Arc2d::from_degrees( + radius.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_turns", + |radius: f32, fraction: f32| { + let output: Val = ::bevy::math::primitives::Arc2d::from_turns( + radius.into(), + fraction.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "angle", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Arc2d::angle( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "length", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Arc2d::length( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "half_chord_length", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Arc2d::half_chord_length( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "chord_length", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Arc2d::chord_length( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "apothem", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Arc2d::apothem( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sagitta", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Arc2d::sagitta( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_minor", + |_self: Ref| { + let output: bool = ::bevy::math::primitives::Arc2d::is_minor( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_major", + |_self: Ref| { + let output: bool = ::bevy::math::primitives::Arc2d::is_major( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Arc2d::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::Arc2d::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::Capsule2d>::new(world) + .overwrite_script_function( + "new", + |radius: f32, length: f32| { + let output: Val = ::bevy::math::primitives::Capsule2d::new( + radius.into(), + length.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_inner_rectangle", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Capsule2d::to_inner_rectangle( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::Capsule2d::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Capsule2d::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::CircularSector>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::CircularSector::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |radius: f32, angle: f32| { + let output: Val = ::bevy::math::primitives::CircularSector::new( + radius.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_radians", + |radius: f32, angle: f32| { + let output: Val = ::bevy::math::primitives::CircularSector::from_radians( + radius.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_degrees", + |radius: f32, angle: f32| { + let output: Val = ::bevy::math::primitives::CircularSector::from_degrees( + radius.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_turns", + |radius: f32, fraction: f32| { + let output: Val = ::bevy::math::primitives::CircularSector::from_turns( + radius.into(), + fraction.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "half_angle", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::CircularSector::half_angle( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "angle", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::CircularSector::angle( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "radius", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::CircularSector::radius( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "arc_length", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::CircularSector::arc_length( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "half_chord_length", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::CircularSector::half_chord_length( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "chord_length", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::CircularSector::chord_length( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "apothem", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::CircularSector::apothem( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sagitta", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::CircularSector::sagitta( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::CircularSector::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::CircularSegment>::new(world) + .overwrite_script_function( + "new", + |radius: f32, angle: f32| { + let output: Val = ::bevy::math::primitives::CircularSegment::new( + radius.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_radians", + |radius: f32, angle: f32| { + let output: Val = ::bevy::math::primitives::CircularSegment::from_radians( + radius.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_degrees", + |radius: f32, angle: f32| { + let output: Val = ::bevy::math::primitives::CircularSegment::from_degrees( + radius.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_turns", + |radius: f32, fraction: f32| { + let output: Val = ::bevy::math::primitives::CircularSegment::from_turns( + radius.into(), + fraction.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "half_angle", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::CircularSegment::half_angle( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "angle", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::CircularSegment::angle( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "radius", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::CircularSegment::radius( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "arc_length", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::CircularSegment::arc_length( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "half_chord_length", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::CircularSegment::half_chord_length( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "chord_length", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::CircularSegment::chord_length( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "apothem", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::CircularSegment::apothem( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sagitta", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::CircularSegment::sagitta( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::CircularSegment::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::CircularSegment::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::Ellipse>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::Ellipse::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |half_width: f32, half_height: f32| { + let output: Val = ::bevy::math::primitives::Ellipse::new( + half_width.into(), + half_height.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eccentricity", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Ellipse::eccentricity( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "focal_length", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Ellipse::focal_length( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "semi_major", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Ellipse::semi_major( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "semi_minor", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Ellipse::semi_minor( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Ellipse::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::Line2d>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Line2d::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::Line2d::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::Plane2d>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Plane2d::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::Plane2d::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::Rectangle>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::Rectangle::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |width: f32, height: f32| { + let output: Val = ::bevy::math::primitives::Rectangle::new( + width.into(), + height.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_length", + |length: f32| { + let output: Val = ::bevy::math::primitives::Rectangle::from_length( + length.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Rectangle::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::RegularPolygon>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::RegularPolygon::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |circumradius: f32, sides: u32| { + let output: Val = ::bevy::math::primitives::RegularPolygon::new( + circumradius.into(), + sides.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "circumradius", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::RegularPolygon::circumradius( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "inradius", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::RegularPolygon::inradius( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "side_length", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::RegularPolygon::side_length( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "internal_angle_degrees", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::RegularPolygon::internal_angle_degrees( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "internal_angle_radians", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::RegularPolygon::internal_angle_radians( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "external_angle_degrees", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::RegularPolygon::external_angle_degrees( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "external_angle_radians", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::RegularPolygon::external_angle_radians( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::RegularPolygon::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::Rhombus>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::Rhombus::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |horizontal_diagonal: f32, vertical_diagonal: f32| { + let output: Val = ::bevy::math::primitives::Rhombus::new( + horizontal_diagonal.into(), + vertical_diagonal.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_side", + |side: f32| { + let output: Val = ::bevy::math::primitives::Rhombus::from_side( + side.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_inradius", + |inradius: f32| { + let output: Val = ::bevy::math::primitives::Rhombus::from_inradius( + inradius.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "side", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Rhombus::side( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "circumradius", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Rhombus::circumradius( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "inradius", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Rhombus::inradius( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Rhombus::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::Segment2d>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::Segment2d::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |direction: Val, length: f32| { + let output: Val = ::bevy::math::primitives::Segment2d::new( + direction.into(), + length.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Segment2d::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::Triangle2d>::new(world) + .overwrite_script_function( + "is_degenerate", + |_self: Ref| { + let output: bool = ::bevy::math::primitives::Triangle2d::is_degenerate( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_acute", + |_self: Ref| { + let output: bool = ::bevy::math::primitives::Triangle2d::is_acute( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_obtuse", + |_self: Ref| { + let output: bool = ::bevy::math::primitives::Triangle2d::is_obtuse( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reverse", + |_self: Mut| { + let output: () = ::bevy::math::primitives::Triangle2d::reverse( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reversed", + |_self: Val| { + let output: Val = ::bevy::math::primitives::Triangle2d::reversed( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Triangle2d::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::Triangle2d::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::bounding::Aabb3d>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::bounding::Aabb3d::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "bounding_sphere", + |_self: Ref| { + let output: Val = ::bevy::math::bounding::Aabb3d::bounding_sphere( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::bounding::BoundingSphere>::new(world) + .overwrite_script_function( + "radius", + |_self: Ref| { + let output: f32 = ::bevy::math::bounding::BoundingSphere::radius( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "aabb_3d", + |_self: Ref| { + let output: Val = ::bevy::math::bounding::BoundingSphere::aabb_3d( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::bounding::BoundingSphere::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::Sphere>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::Sphere::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Sphere::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |radius: f32| { + let output: Val = ::bevy::math::primitives::Sphere::new( + radius.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "diameter", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Sphere::diameter( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::Cuboid>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Cuboid::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::Cuboid::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x_length: f32, y_length: f32, z_length: f32| { + let output: Val = ::bevy::math::primitives::Cuboid::new( + x_length.into(), + y_length.into(), + z_length.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_length", + |length: f32| { + let output: Val = ::bevy::math::primitives::Cuboid::from_length( + length.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::Cylinder>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Cylinder::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::Cylinder::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |radius: f32, height: f32| { + let output: Val = ::bevy::math::primitives::Cylinder::new( + radius.into(), + height.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "base", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Cylinder::base( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "lateral_area", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Cylinder::lateral_area( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "base_area", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Cylinder::base_area( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::Capsule3d>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Capsule3d::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::Capsule3d::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |radius: f32, length: f32| { + let output: Val = ::bevy::math::primitives::Capsule3d::new( + radius.into(), + length.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_cylinder", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Capsule3d::to_cylinder( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::Cone>::new(world) + .overwrite_script_function( + "new", + |radius: f32, height: f32| { + let output: Val = ::bevy::math::primitives::Cone::new( + radius.into(), + height.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "base", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Cone::base( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "slant_height", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Cone::slant_height( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "lateral_area", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Cone::lateral_area( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "base_area", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Cone::base_area( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Cone::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::Cone::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::ConicalFrustum>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::ConicalFrustum::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::ConicalFrustum::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::InfinitePlane3d>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::InfinitePlane3d::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::InfinitePlane3d::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::Line3d>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Line3d::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::Line3d::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::Segment3d>::new(world) + .overwrite_script_function( + "new", + |direction: Val, length: f32| { + let output: Val = ::bevy::math::primitives::Segment3d::new( + direction.into(), + length.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::Segment3d::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Segment3d::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::Torus>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Torus::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::Torus::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |inner_radius: f32, outer_radius: f32| { + let output: Val = ::bevy::math::primitives::Torus::new( + inner_radius.into(), + outer_radius.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "inner_radius", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Torus::inner_radius( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "outer_radius", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Torus::outer_radius( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::Triangle3d>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::Triangle3d::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_degenerate", + |_self: Ref| { + let output: bool = ::bevy::math::primitives::Triangle3d::is_degenerate( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_acute", + |_self: Ref| { + let output: bool = ::bevy::math::primitives::Triangle3d::is_acute( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_obtuse", + |_self: Ref| { + let output: bool = ::bevy::math::primitives::Triangle3d::is_obtuse( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reverse", + |_self: Mut| { + let output: () = ::bevy::math::primitives::Triangle3d::reverse( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reversed", + |_self: Val| { + let output: Val = ::bevy::math::primitives::Triangle3d::reversed( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Triangle3d::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::bounding::RayCast2d>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::bounding::RayCast2d::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_ray", + |ray: Val, max: f32| { + let output: Val = ::bevy::math::bounding::RayCast2d::from_ray( + ray.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "aabb_intersection_at", + | + _self: Ref, + aabb: Ref| + { + let output: std::option::Option = ::bevy::math::bounding::RayCast2d::aabb_intersection_at( + _self.into(), + aabb.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "circle_intersection_at", + | + _self: Ref, + circle: Ref| + { + let output: std::option::Option = ::bevy::math::bounding::RayCast2d::circle_intersection_at( + _self.into(), + circle.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::bounding::AabbCast2d>::new(world) + .overwrite_script_function( + "from_ray", + | + aabb: Val, + ray: Val, + max: f32| + { + let output: Val = ::bevy::math::bounding::AabbCast2d::from_ray( + aabb.into(), + ray.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "aabb_collision_at", + | + _self: Ref, + aabb: Val| + { + let output: std::option::Option = ::bevy::math::bounding::AabbCast2d::aabb_collision_at( + _self.into(), + aabb.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::bounding::AabbCast2d::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::bounding::BoundingCircleCast>::new(world) + .overwrite_script_function( + "from_ray", + | + circle: Val, + ray: Val, + max: f32| + { + let output: Val = ::bevy::math::bounding::BoundingCircleCast::from_ray( + circle.into(), + ray.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "circle_collision_at", + | + _self: Ref, + circle: Val| + { + let output: std::option::Option = ::bevy::math::bounding::BoundingCircleCast::circle_collision_at( + _self.into(), + circle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::bounding::BoundingCircleCast::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::bounding::RayCast3d>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::bounding::RayCast3d::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_ray", + |ray: Val, max: f32| { + let output: Val = ::bevy::math::bounding::RayCast3d::from_ray( + ray.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "aabb_intersection_at", + | + _self: Ref, + aabb: Ref| + { + let output: std::option::Option = ::bevy::math::bounding::RayCast3d::aabb_intersection_at( + _self.into(), + aabb.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sphere_intersection_at", + | + _self: Ref, + sphere: Ref| + { + let output: std::option::Option = ::bevy::math::bounding::RayCast3d::sphere_intersection_at( + _self.into(), + sphere.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::bounding::AabbCast3d>::new(world) + .overwrite_script_function( + "from_ray", + | + aabb: Val, + ray: Val, + max: f32| + { + let output: Val = ::bevy::math::bounding::AabbCast3d::from_ray( + aabb.into(), + ray.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "aabb_collision_at", + | + _self: Ref, + aabb: Val| + { + let output: std::option::Option = ::bevy::math::bounding::AabbCast3d::aabb_collision_at( + _self.into(), + aabb.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::bounding::AabbCast3d::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::bounding::BoundingSphereCast>::new(world) + .overwrite_script_function( + "from_ray", + | + sphere: Val, + ray: Val, + max: f32| + { + let output: Val = ::bevy::math::bounding::BoundingSphereCast::from_ray( + sphere.into(), + ray.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sphere_collision_at", + | + _self: Ref, + sphere: Val| + { + let output: std::option::Option = ::bevy::math::bounding::BoundingSphereCast::sphere_collision_at( + _self.into(), + sphere.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::bounding::BoundingSphereCast::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::curve::interval::Interval>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::curve::interval::Interval::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "start", + |_self: Val| { + let output: f32 = ::bevy::math::curve::interval::Interval::start( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "end", + |_self: Val| { + let output: f32 = ::bevy::math::curve::interval::Interval::end( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "length", + |_self: Val| { + let output: f32 = ::bevy::math::curve::interval::Interval::length( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_bounded", + |_self: Val| { + let output: bool = ::bevy::math::curve::interval::Interval::is_bounded( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "has_finite_start", + |_self: Val| { + let output: bool = ::bevy::math::curve::interval::Interval::has_finite_start( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "has_finite_end", + |_self: Val| { + let output: bool = ::bevy::math::curve::interval::Interval::has_finite_end( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "contains", + |_self: Val, item: f32| { + let output: bool = ::bevy::math::curve::interval::Interval::contains( + _self.into(), + item.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "contains_interval", + | + _self: Val, + other: Val| + { + let output: bool = ::bevy::math::curve::interval::Interval::contains_interval( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp", + |_self: Val, value: f32| { + let output: f32 = ::bevy::math::curve::interval::Interval::clamp( + _self.into(), + value.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::curve::interval::Interval::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::FloatOrd>::new(world) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::FloatOrd::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::FloatOrd::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::FloatOrd::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "lt", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::FloatOrd::lt( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "le", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::FloatOrd::le( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "gt", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::FloatOrd::gt( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "ge", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::FloatOrd::ge( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::Plane3d>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Plane3d::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::Plane3d::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::primitives::Tetrahedron>::new(world) + .overwrite_script_function( + "signed_volume", + |_self: Ref| { + let output: f32 = ::bevy::math::primitives::Tetrahedron::signed_volume( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::primitives::Tetrahedron::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::primitives::Tetrahedron::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::curve::easing::EaseFunction>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::curve::easing::EaseFunction::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::math::curve::easing::EaseFunction::eq( + _self.into(), + other.into(), + ) + .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 new file mode 100644 index 0000000000..603a8e68d0 --- /dev/null +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_reflect.rs @@ -0,0 +1,22507 @@ +// @generated by cargo bevy-api-gen generate, modify the templates not this file +#![allow(clippy::all)] +#![allow(unused, deprecated, dead_code)] +#![cfg_attr(rustfmt, rustfmt_skip)] +use bevy_mod_scripting_core::{ + AddContextInitializer, StoreDocumentation, + bindings::{ReflectReference, function::from::{Ref, Mut, Val}}, +}; +use crate::*; +pub struct BevyReflectScriptingPlugin; +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) + .overwrite_script_function( + "new", + |v: bool| { + let output: Val = ::std::sync::atomic::AtomicBool::new( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "into_inner", + |_self: Val| { + let output: bool = ::std::sync::atomic::AtomicBool::into_inner( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::std::sync::atomic::AtomicI16>::new(world) + .overwrite_script_function( + "new", + |v: i16| { + let output: Val = ::std::sync::atomic::AtomicI16::new( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "into_inner", + |_self: Val| { + let output: i16 = ::std::sync::atomic::AtomicI16::into_inner( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::std::sync::atomic::AtomicI32>::new(world) + .overwrite_script_function( + "new", + |v: i32| { + let output: Val = ::std::sync::atomic::AtomicI32::new( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "into_inner", + |_self: Val| { + let output: i32 = ::std::sync::atomic::AtomicI32::into_inner( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::std::sync::atomic::AtomicI64>::new(world) + .overwrite_script_function( + "new", + |v: i64| { + let output: Val = ::std::sync::atomic::AtomicI64::new( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "into_inner", + |_self: Val| { + let output: i64 = ::std::sync::atomic::AtomicI64::into_inner( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::std::sync::atomic::AtomicI8>::new(world) + .overwrite_script_function( + "new", + |v: i8| { + let output: Val = ::std::sync::atomic::AtomicI8::new( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "into_inner", + |_self: Val| { + let output: i8 = ::std::sync::atomic::AtomicI8::into_inner( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::std::sync::atomic::AtomicIsize>::new(world) + .overwrite_script_function( + "new", + |v: isize| { + let output: Val = ::std::sync::atomic::AtomicIsize::new( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "into_inner", + |_self: Val| { + let output: isize = ::std::sync::atomic::AtomicIsize::into_inner( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::std::sync::atomic::AtomicU16>::new(world) + .overwrite_script_function( + "new", + |v: u16| { + let output: Val = ::std::sync::atomic::AtomicU16::new( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "into_inner", + |_self: Val| { + let output: u16 = ::std::sync::atomic::AtomicU16::into_inner( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::std::sync::atomic::AtomicU32>::new(world) + .overwrite_script_function( + "new", + |v: u32| { + let output: Val = ::std::sync::atomic::AtomicU32::new( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "into_inner", + |_self: Val| { + let output: u32 = ::std::sync::atomic::AtomicU32::into_inner( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::std::sync::atomic::AtomicU64>::new(world) + .overwrite_script_function( + "new", + |v: u64| { + let output: Val = ::std::sync::atomic::AtomicU64::new( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "into_inner", + |_self: Val| { + let output: u64 = ::std::sync::atomic::AtomicU64::into_inner( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::std::sync::atomic::AtomicU8>::new(world) + .overwrite_script_function( + "new", + |v: u8| { + let output: Val = ::std::sync::atomic::AtomicU8::new( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "into_inner", + |_self: Val| { + let output: u8 = ::std::sync::atomic::AtomicU8::into_inner( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::std::sync::atomic::AtomicUsize>::new(world) + .overwrite_script_function( + "new", + |v: usize| { + let output: Val = ::std::sync::atomic::AtomicUsize::new( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "into_inner", + |_self: Val| { + let output: usize = ::std::sync::atomic::AtomicUsize::into_inner( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::utils::Duration>::new(world) + .overwrite_script_function( + "mul", + |_self: Val, rhs: u32| { + let output: Val = ::bevy::utils::Duration::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::utils::Duration::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::utils::Duration::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::utils::Duration::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::utils::Duration::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::utils::Duration::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: u32| { + let output: Val = ::bevy::utils::Duration::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |secs: u64, nanos: u32| { + let output: Val = ::bevy::utils::Duration::new( + secs.into(), + nanos.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_secs", + |secs: u64| { + let output: Val = ::bevy::utils::Duration::from_secs( + secs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_millis", + |millis: u64| { + let output: Val = ::bevy::utils::Duration::from_millis( + millis.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_micros", + |micros: u64| { + let output: Val = ::bevy::utils::Duration::from_micros( + micros.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_nanos", + |nanos: u64| { + let output: Val = ::bevy::utils::Duration::from_nanos( + nanos.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_zero", + |_self: Ref| { + let output: bool = ::bevy::utils::Duration::is_zero(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "as_secs", + |_self: Ref| { + let output: u64 = ::bevy::utils::Duration::as_secs(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "subsec_millis", + |_self: Ref| { + let output: u32 = ::bevy::utils::Duration::subsec_millis( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "subsec_micros", + |_self: Ref| { + let output: u32 = ::bevy::utils::Duration::subsec_micros( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "subsec_nanos", + |_self: Ref| { + let output: u32 = ::bevy::utils::Duration::subsec_nanos(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "as_millis", + |_self: Ref| { + let output: u128 = ::bevy::utils::Duration::as_millis(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "as_micros", + |_self: Ref| { + let output: u128 = ::bevy::utils::Duration::as_micros(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "as_nanos", + |_self: Ref| { + let output: u128 = ::bevy::utils::Duration::as_nanos(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "abs_diff", + |_self: Val, other: Val| { + let output: Val = ::bevy::utils::Duration::abs_diff( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::utils::Duration::saturating_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::utils::Duration::saturating_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_mul", + |_self: Val, rhs: u32| { + let output: Val = ::bevy::utils::Duration::saturating_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_secs_f64", + |_self: Ref| { + let output: f64 = ::bevy::utils::Duration::as_secs_f64(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "as_secs_f32", + |_self: Ref| { + let output: f32 = ::bevy::utils::Duration::as_secs_f32(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "from_secs_f64", + |secs: f64| { + let output: Val = ::bevy::utils::Duration::from_secs_f64( + secs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_secs_f32", + |secs: f32| { + let output: Val = ::bevy::utils::Duration::from_secs_f32( + secs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_f64", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::utils::Duration::mul_f64( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_f32", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::utils::Duration::mul_f32( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_f64", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::utils::Duration::div_f64( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_f32", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::utils::Duration::div_f32( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_duration_f64", + |_self: Val, rhs: Val| { + let output: f64 = ::bevy::utils::Duration::div_duration_f64( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_duration_f32", + |_self: Val, rhs: Val| { + let output: f32 = ::bevy::utils::Duration::div_duration_f32( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::utils::Instant>::new(world) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::utils::Instant::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::utils::Instant::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, other: Val| { + let output: Val = ::bevy::utils::Instant::sub( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, other: Val| { + let output: Val = ::bevy::utils::Instant::sub( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "now", + || { + let output: Val = ::bevy::utils::Instant::now() + .into(); + output + }, + ) + .overwrite_script_function( + "duration_since", + |_self: Ref, earlier: Val| { + let output: Val = ::bevy::utils::Instant::duration_since( + _self.into(), + earlier.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_duration_since", + |_self: Ref, earlier: Val| { + let output: Val = ::bevy::utils::Instant::saturating_duration_since( + _self.into(), + earlier.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "elapsed", + |_self: Ref| { + let output: Val = ::bevy::utils::Instant::elapsed( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::utils::Instant::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, other: Val| { + let output: Val = ::bevy::utils::Instant::add( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::std::ops::RangeFull>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::std::ops::RangeFull::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::std::ops::RangeFull::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::std::ops::RangeFull::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::Quat>::new(world) + .overwrite_script_function( + "mul", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Quat::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Quat::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::Quat::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Quat::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::Quat::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_xyzw", + |x: f32, y: f32, z: f32, w: f32| { + let output: Val = ::bevy::math::Quat::from_xyzw( + x.into(), + y.into(), + z.into(), + w.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [f32; 4]| { + let output: Val = ::bevy::math::Quat::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_vec4", + |v: Val| { + let output: Val = ::bevy::math::Quat::from_vec4( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_axis_angle", + |axis: Val, angle: f32| { + let output: Val = ::bevy::math::Quat::from_axis_angle( + axis.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_scaled_axis", + |v: Val| { + let output: Val = ::bevy::math::Quat::from_scaled_axis( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_x", + |angle: f32| { + let output: Val = ::bevy::math::Quat::from_rotation_x( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_y", + |angle: f32| { + let output: Val = ::bevy::math::Quat::from_rotation_y( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_z", + |angle: f32| { + let output: Val = ::bevy::math::Quat::from_rotation_z( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_euler", + |euler: Val, a: f32, b: f32, c: f32| { + let output: Val = ::bevy::math::Quat::from_euler( + euler.into(), + a.into(), + b.into(), + c.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat3", + |mat: Ref| { + let output: Val = ::bevy::math::Quat::from_mat3( + mat.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat3a", + |mat: Ref| { + let output: Val = ::bevy::math::Quat::from_mat3a( + mat.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat4", + |mat: Ref| { + let output: Val = ::bevy::math::Quat::from_mat4( + mat.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_arc", + |from: Val, to: Val| { + let output: Val = ::bevy::math::Quat::from_rotation_arc( + from.into(), + to.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_arc_colinear", + |from: Val, to: Val| { + let output: Val = ::bevy::math::Quat::from_rotation_arc_colinear( + from.into(), + to.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_arc_2d", + |from: Val, to: Val| { + let output: Val = ::bevy::math::Quat::from_rotation_arc_2d( + from.into(), + to.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_scaled_axis", + |_self: Val| { + let output: Val = ::bevy::math::Quat::to_scaled_axis( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_euler", + |_self: Val, order: Val| { + let output: (f32, f32, f32) = ::bevy::math::Quat::to_euler( + _self.into(), + order.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_array", + |_self: Ref| { + let output: [f32; 4] = ::bevy::math::Quat::to_array(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "xyz", + |_self: Val| { + let output: Val = ::bevy::math::Quat::xyz( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "conjugate", + |_self: Val| { + let output: Val = ::bevy::math::Quat::conjugate( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "inverse", + |_self: Val| { + let output: Val = ::bevy::math::Quat::inverse( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot", + |_self: Val, rhs: Val| { + let output: f32 = ::bevy::math::Quat::dot(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "length", + |_self: Val| { + let output: f32 = ::bevy::math::Quat::length(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "length_squared", + |_self: Val| { + let output: f32 = ::bevy::math::Quat::length_squared(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "length_recip", + |_self: Val| { + let output: f32 = ::bevy::math::Quat::length_recip(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize", + |_self: Val| { + let output: Val = ::bevy::math::Quat::normalize( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite", + |_self: Val| { + let output: bool = ::bevy::math::Quat::is_finite(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_nan", + |_self: Val| { + let output: bool = ::bevy::math::Quat::is_nan(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "is_normalized", + |_self: Val| { + let output: bool = ::bevy::math::Quat::is_normalized(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_near_identity", + |_self: Val| { + let output: bool = ::bevy::math::Quat::is_near_identity(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "angle_between", + |_self: Val, rhs: Val| { + let output: f32 = ::bevy::math::Quat::angle_between( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rotate_towards", + | + _self: Ref, + rhs: Val, + max_angle: f32| + { + let output: Val = ::bevy::math::Quat::rotate_towards( + _self.into(), + rhs.into(), + max_angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs_diff_eq", + | + _self: Val, + rhs: Val, + max_abs_diff: f32| + { + let output: bool = ::bevy::math::Quat::abs_diff_eq( + _self.into(), + rhs.into(), + max_abs_diff.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "lerp", + |_self: Val, end: Val, s: f32| { + let output: Val = ::bevy::math::Quat::lerp( + _self.into(), + end.into(), + s.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "slerp", + |_self: Val, end: Val, s: f32| { + let output: Val = ::bevy::math::Quat::slerp( + _self.into(), + end.into(), + s.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_vec3", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Quat::mul_vec3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_quat", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Quat::mul_quat( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_affine3", + |a: Ref| { + let output: Val = ::bevy::math::Quat::from_affine3( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_vec3a", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Quat::mul_vec3a( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_dquat", + |_self: Val| { + let output: Val = ::bevy::math::Quat::as_dquat( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = ::bevy::math::Quat::eq(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Quat::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Quat::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Quat::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Quat::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::Vec3>::new(world) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::Vec3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::Vec3::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::Vec3::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Vec3::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::Vec3::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Vec3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::Vec3::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::Vec3::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::Vec3::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Vec3::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Vec3::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x: f32, y: f32, z: f32| { + let output: Val = ::bevy::math::Vec3::new( + x.into(), + y.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: f32| { + let output: Val = ::bevy::math::Vec3::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = ::bevy::math::Vec3::select( + mask.into(), + if_true.into(), + if_false.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [f32; 3]| { + let output: Val = ::bevy::math::Vec3::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_array", + |_self: Ref| { + let output: [f32; 3] = ::bevy::math::Vec3::to_array(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "extend", + |_self: Val, w: f32| { + let output: Val = ::bevy::math::Vec3::extend( + _self.into(), + w.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "truncate", + |_self: Val| { + let output: Val = ::bevy::math::Vec3::truncate( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_x", + |_self: Val, x: f32| { + let output: Val = ::bevy::math::Vec3::with_x( + _self.into(), + x.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_y", + |_self: Val, y: f32| { + let output: Val = ::bevy::math::Vec3::with_y( + _self.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_z", + |_self: Val, z: f32| { + let output: Val = ::bevy::math::Vec3::with_z( + _self.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot", + |_self: Val, rhs: Val| { + let output: f32 = ::bevy::math::Vec3::dot(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3::dot_into_vec( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cross", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3::cross( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3::min( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "max", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3::max( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = ::bevy::math::Vec3::clamp( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min_element", + |_self: Val| { + let output: f32 = ::bevy::math::Vec3::min_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "max_element", + |_self: Val| { + let output: f32 = ::bevy::math::Vec3::max_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_sum", + |_self: Val| { + let output: f32 = ::bevy::math::Vec3::element_sum(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_product", + |_self: Val| { + let output: f32 = ::bevy::math::Vec3::element_product(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3::cmpeq( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3::cmpne( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3::cmpge( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpgt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3::cmpgt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmple", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3::cmple( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3::cmplt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs", + |_self: Val| { + let output: Val = ::bevy::math::Vec3::abs( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "signum", + |_self: Val| { + let output: Val = ::bevy::math::Vec3::signum( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "copysign", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3::copysign( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_negative_bitmask", + |_self: Val| { + let output: u32 = ::bevy::math::Vec3::is_negative_bitmask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite", + |_self: Val| { + let output: bool = ::bevy::math::Vec3::is_finite(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite_mask", + |_self: Val| { + let output: Val = ::bevy::math::Vec3::is_finite_mask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_nan", + |_self: Val| { + let output: bool = ::bevy::math::Vec3::is_nan(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "is_nan_mask", + |_self: Val| { + let output: Val = ::bevy::math::Vec3::is_nan_mask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "length", + |_self: Val| { + let output: f32 = ::bevy::math::Vec3::length(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "length_squared", + |_self: Val| { + let output: f32 = ::bevy::math::Vec3::length_squared(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "length_recip", + |_self: Val| { + let output: f32 = ::bevy::math::Vec3::length_recip(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "distance", + |_self: Val, rhs: Val| { + let output: f32 = ::bevy::math::Vec3::distance( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "distance_squared", + |_self: Val, rhs: Val| { + let output: f32 = ::bevy::math::Vec3::distance_squared( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3::div_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3::rem_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize", + |_self: Val| { + let output: Val = ::bevy::math::Vec3::normalize( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize_or", + |_self: Val, fallback: Val| { + let output: Val = ::bevy::math::Vec3::normalize_or( + _self.into(), + fallback.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize_or_zero", + |_self: Val| { + let output: Val = ::bevy::math::Vec3::normalize_or_zero( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_normalized", + |_self: Val| { + let output: bool = ::bevy::math::Vec3::is_normalized(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "project_onto", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3::project_onto( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reject_from", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3::reject_from( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "project_onto_normalized", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3::project_onto_normalized( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reject_from_normalized", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3::reject_from_normalized( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "round", + |_self: Val| { + let output: Val = ::bevy::math::Vec3::round( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "floor", + |_self: Val| { + let output: Val = ::bevy::math::Vec3::floor( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "ceil", + |_self: Val| { + let output: Val = ::bevy::math::Vec3::ceil( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "trunc", + |_self: Val| { + let output: Val = ::bevy::math::Vec3::trunc( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "fract", + |_self: Val| { + let output: Val = ::bevy::math::Vec3::fract( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "fract_gl", + |_self: Val| { + let output: Val = ::bevy::math::Vec3::fract_gl( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "exp", + |_self: Val| { + let output: Val = ::bevy::math::Vec3::exp( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "powf", + |_self: Val, n: f32| { + let output: Val = ::bevy::math::Vec3::powf( + _self.into(), + n.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "recip", + |_self: Val| { + let output: Val = ::bevy::math::Vec3::recip( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "lerp", + |_self: Val, rhs: Val, s: f32| { + let output: Val = ::bevy::math::Vec3::lerp( + _self.into(), + rhs.into(), + s.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "move_towards", + |_self: Ref, rhs: Val, d: f32| { + let output: Val = ::bevy::math::Vec3::move_towards( + _self.into(), + rhs.into(), + d.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "midpoint", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3::midpoint( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs_diff_eq", + | + _self: Val, + rhs: Val, + max_abs_diff: f32| + { + let output: bool = ::bevy::math::Vec3::abs_diff_eq( + _self.into(), + rhs.into(), + max_abs_diff.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp_length", + |_self: Val, min: f32, max: f32| { + let output: Val = ::bevy::math::Vec3::clamp_length( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp_length_max", + |_self: Val, max: f32| { + let output: Val = ::bevy::math::Vec3::clamp_length_max( + _self.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp_length_min", + |_self: Val, min: f32| { + let output: Val = ::bevy::math::Vec3::clamp_length_min( + _self.into(), + min.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_add", + | + _self: Val, + a: Val, + b: Val| + { + let output: Val = ::bevy::math::Vec3::mul_add( + _self.into(), + a.into(), + b.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reflect", + |_self: Val, normal: Val| { + let output: Val = ::bevy::math::Vec3::reflect( + _self.into(), + normal.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "refract", + |_self: Val, normal: Val, eta: f32| { + let output: Val = ::bevy::math::Vec3::refract( + _self.into(), + normal.into(), + eta.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "angle_between", + |_self: Val, rhs: Val| { + let output: f32 = ::bevy::math::Vec3::angle_between( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "any_orthogonal_vector", + |_self: Ref| { + let output: Val = ::bevy::math::Vec3::any_orthogonal_vector( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "any_orthonormal_vector", + |_self: Ref| { + let output: Val = ::bevy::math::Vec3::any_orthonormal_vector( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_dvec3", + |_self: Ref| { + let output: Val = ::bevy::math::Vec3::as_dvec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_ivec3", + |_self: Ref| { + let output: Val = ::bevy::math::Vec3::as_ivec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_uvec3", + |_self: Ref| { + let output: Val = ::bevy::math::Vec3::as_uvec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_i64vec3", + |_self: Ref| { + let output: Val = ::bevy::math::Vec3::as_i64vec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_u64vec3", + |_self: Ref| { + let output: Val = ::bevy::math::Vec3::as_u64vec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::Vec3::eq(_self.into(), other.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Vec3::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::IVec2>::new(world) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::IVec2::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::IVec2::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: i32| { + let output: Val = ::bevy::math::IVec2::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::IVec2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: i32| { + let output: Val = ::bevy::math::IVec2::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::IVec2::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::math::IVec2::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: i32| { + let output: Val = ::bevy::math::IVec2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::IVec2::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::IVec2::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: i32| { + let output: Val = ::bevy::math::IVec2::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: i32| { + let output: Val = ::bevy::math::IVec2::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x: i32, y: i32| { + let output: Val = ::bevy::math::IVec2::new( + x.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: i32| { + let output: Val = ::bevy::math::IVec2::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = ::bevy::math::IVec2::select( + mask.into(), + if_true.into(), + if_false.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [i32; 2]| { + let output: Val = ::bevy::math::IVec2::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_array", + |_self: Ref| { + let output: [i32; 2] = ::bevy::math::IVec2::to_array(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "extend", + |_self: Val, z: i32| { + let output: Val = ::bevy::math::IVec2::extend( + _self.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_x", + |_self: Val, x: i32| { + let output: Val = ::bevy::math::IVec2::with_x( + _self.into(), + x.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_y", + |_self: Val, y: i32| { + let output: Val = ::bevy::math::IVec2::with_y( + _self.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot", + |_self: Val, rhs: Val| { + let output: i32 = ::bevy::math::IVec2::dot(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::dot_into_vec( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::min( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "max", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::max( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = ::bevy::math::IVec2::clamp( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min_element", + |_self: Val| { + let output: i32 = ::bevy::math::IVec2::min_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "max_element", + |_self: Val| { + let output: i32 = ::bevy::math::IVec2::max_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_sum", + |_self: Val| { + let output: i32 = ::bevy::math::IVec2::element_sum(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_product", + |_self: Val| { + let output: i32 = ::bevy::math::IVec2::element_product(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::cmpeq( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::cmpne( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::cmpge( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpgt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::cmpgt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmple", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::cmple( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::cmplt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs", + |_self: Val| { + let output: Val = ::bevy::math::IVec2::abs( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "signum", + |_self: Val| { + let output: Val = ::bevy::math::IVec2::signum( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_negative_bitmask", + |_self: Val| { + let output: u32 = ::bevy::math::IVec2::is_negative_bitmask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "length_squared", + |_self: Val| { + let output: i32 = ::bevy::math::IVec2::length_squared(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "distance_squared", + |_self: Val, rhs: Val| { + let output: i32 = ::bevy::math::IVec2::distance_squared( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::div_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::rem_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "perp", + |_self: Val| { + let output: Val = ::bevy::math::IVec2::perp( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "perp_dot", + |_self: Val, rhs: Val| { + let output: i32 = ::bevy::math::IVec2::perp_dot( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rotate", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::rotate( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_vec2", + |_self: Ref| { + let output: Val = ::bevy::math::IVec2::as_vec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_dvec2", + |_self: Ref| { + let output: Val = ::bevy::math::IVec2::as_dvec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_uvec2", + |_self: Ref| { + let output: Val = ::bevy::math::IVec2::as_uvec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_i64vec2", + |_self: Ref| { + let output: Val = ::bevy::math::IVec2::as_i64vec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_u64vec2", + |_self: Ref| { + let output: Val = ::bevy::math::IVec2::as_u64vec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::wrapping_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::wrapping_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::wrapping_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::wrapping_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::saturating_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::saturating_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::saturating_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::saturating_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::wrapping_add_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_sub_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::wrapping_sub_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::saturating_add_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_sub_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec2::saturating_sub_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::IVec2::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::IVec2::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::IVec3>::new(world) + .overwrite_script_function( + "rem", + |_self: Val, rhs: i32| { + let output: Val = ::bevy::math::IVec3::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::math::IVec3::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x: i32, y: i32, z: i32| { + let output: Val = ::bevy::math::IVec3::new( + x.into(), + y.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: i32| { + let output: Val = ::bevy::math::IVec3::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = ::bevy::math::IVec3::select( + mask.into(), + if_true.into(), + if_false.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [i32; 3]| { + let output: Val = ::bevy::math::IVec3::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_array", + |_self: Ref| { + let output: [i32; 3] = ::bevy::math::IVec3::to_array(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "extend", + |_self: Val, w: i32| { + let output: Val = ::bevy::math::IVec3::extend( + _self.into(), + w.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "truncate", + |_self: Val| { + let output: Val = ::bevy::math::IVec3::truncate( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_x", + |_self: Val, x: i32| { + let output: Val = ::bevy::math::IVec3::with_x( + _self.into(), + x.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_y", + |_self: Val, y: i32| { + let output: Val = ::bevy::math::IVec3::with_y( + _self.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_z", + |_self: Val, z: i32| { + let output: Val = ::bevy::math::IVec3::with_z( + _self.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot", + |_self: Val, rhs: Val| { + let output: i32 = ::bevy::math::IVec3::dot(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::dot_into_vec( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cross", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::cross( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::min( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "max", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::max( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = ::bevy::math::IVec3::clamp( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min_element", + |_self: Val| { + let output: i32 = ::bevy::math::IVec3::min_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "max_element", + |_self: Val| { + let output: i32 = ::bevy::math::IVec3::max_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_sum", + |_self: Val| { + let output: i32 = ::bevy::math::IVec3::element_sum(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_product", + |_self: Val| { + let output: i32 = ::bevy::math::IVec3::element_product(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::cmpeq( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::cmpne( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::cmpge( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpgt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::cmpgt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmple", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::cmple( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::cmplt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs", + |_self: Val| { + let output: Val = ::bevy::math::IVec3::abs( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "signum", + |_self: Val| { + let output: Val = ::bevy::math::IVec3::signum( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_negative_bitmask", + |_self: Val| { + let output: u32 = ::bevy::math::IVec3::is_negative_bitmask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "length_squared", + |_self: Val| { + let output: i32 = ::bevy::math::IVec3::length_squared(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "distance_squared", + |_self: Val, rhs: Val| { + let output: i32 = ::bevy::math::IVec3::distance_squared( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::div_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::rem_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_vec3", + |_self: Ref| { + let output: Val = ::bevy::math::IVec3::as_vec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_vec3a", + |_self: Ref| { + let output: Val = ::bevy::math::IVec3::as_vec3a( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_dvec3", + |_self: Ref| { + let output: Val = ::bevy::math::IVec3::as_dvec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_uvec3", + |_self: Ref| { + let output: Val = ::bevy::math::IVec3::as_uvec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_i64vec3", + |_self: Ref| { + let output: Val = ::bevy::math::IVec3::as_i64vec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_u64vec3", + |_self: Ref| { + let output: Val = ::bevy::math::IVec3::as_u64vec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::wrapping_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::wrapping_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::wrapping_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::wrapping_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::saturating_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::saturating_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::saturating_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::saturating_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::wrapping_add_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_sub_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::wrapping_sub_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::saturating_add_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_sub_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::saturating_sub_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::IVec3::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: i32| { + let output: Val = ::bevy::math::IVec3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::IVec3::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: i32| { + let output: Val = ::bevy::math::IVec3::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::IVec3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: i32| { + let output: Val = ::bevy::math::IVec3::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::IVec3::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::IVec3::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::IVec3::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::IVec3::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::IVec3::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: i32| { + let output: Val = ::bevy::math::IVec3::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec3::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::IVec4>::new(world) + .overwrite_script_function( + "add", + |_self: Val, rhs: i32| { + let output: Val = ::bevy::math::IVec4::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::IVec4::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::IVec4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x: i32, y: i32, z: i32, w: i32| { + let output: Val = ::bevy::math::IVec4::new( + x.into(), + y.into(), + z.into(), + w.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: i32| { + let output: Val = ::bevy::math::IVec4::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = ::bevy::math::IVec4::select( + mask.into(), + if_true.into(), + if_false.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [i32; 4]| { + let output: Val = ::bevy::math::IVec4::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_array", + |_self: Ref| { + let output: [i32; 4] = ::bevy::math::IVec4::to_array(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "truncate", + |_self: Val| { + let output: Val = ::bevy::math::IVec4::truncate( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_x", + |_self: Val, x: i32| { + let output: Val = ::bevy::math::IVec4::with_x( + _self.into(), + x.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_y", + |_self: Val, y: i32| { + let output: Val = ::bevy::math::IVec4::with_y( + _self.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_z", + |_self: Val, z: i32| { + let output: Val = ::bevy::math::IVec4::with_z( + _self.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_w", + |_self: Val, w: i32| { + let output: Val = ::bevy::math::IVec4::with_w( + _self.into(), + w.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot", + |_self: Val, rhs: Val| { + let output: i32 = ::bevy::math::IVec4::dot(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::dot_into_vec( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::min( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "max", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::max( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = ::bevy::math::IVec4::clamp( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min_element", + |_self: Val| { + let output: i32 = ::bevy::math::IVec4::min_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "max_element", + |_self: Val| { + let output: i32 = ::bevy::math::IVec4::max_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_sum", + |_self: Val| { + let output: i32 = ::bevy::math::IVec4::element_sum(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_product", + |_self: Val| { + let output: i32 = ::bevy::math::IVec4::element_product(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::cmpeq( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::cmpne( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::cmpge( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpgt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::cmpgt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmple", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::cmple( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::cmplt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs", + |_self: Val| { + let output: Val = ::bevy::math::IVec4::abs( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "signum", + |_self: Val| { + let output: Val = ::bevy::math::IVec4::signum( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_negative_bitmask", + |_self: Val| { + let output: u32 = ::bevy::math::IVec4::is_negative_bitmask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "length_squared", + |_self: Val| { + let output: i32 = ::bevy::math::IVec4::length_squared(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "distance_squared", + |_self: Val, rhs: Val| { + let output: i32 = ::bevy::math::IVec4::distance_squared( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::div_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::rem_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_vec4", + |_self: Ref| { + let output: Val = ::bevy::math::IVec4::as_vec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_dvec4", + |_self: Ref| { + let output: Val = ::bevy::math::IVec4::as_dvec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_uvec4", + |_self: Ref| { + let output: Val = ::bevy::math::IVec4::as_uvec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_i64vec4", + |_self: Ref| { + let output: Val = ::bevy::math::IVec4::as_i64vec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_u64vec4", + |_self: Ref| { + let output: Val = ::bevy::math::IVec4::as_u64vec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::wrapping_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::wrapping_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::wrapping_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::wrapping_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::saturating_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::saturating_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::saturating_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::saturating_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::wrapping_add_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_sub_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::wrapping_sub_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::saturating_add_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_sub_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::saturating_sub_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::IVec4::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: i32| { + let output: Val = ::bevy::math::IVec4::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::IVec4::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::IVec4::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::IVec4::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: i32| { + let output: Val = ::bevy::math::IVec4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::IVec4::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: i32| { + let output: Val = ::bevy::math::IVec4::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::IVec4::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::IVec4::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::math::IVec4::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: i32| { + let output: Val = ::bevy::math::IVec4::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::I64Vec2>::new(world) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::I64Vec2::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: i64| { + let output: Val = ::bevy::math::I64Vec2::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::I64Vec2::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: i64| { + let output: Val = ::bevy::math::I64Vec2::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::I64Vec2::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::I64Vec2::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::math::I64Vec2::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::I64Vec2::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: i64| { + let output: Val = ::bevy::math::I64Vec2::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::I64Vec2::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x: i64, y: i64| { + let output: Val = ::bevy::math::I64Vec2::new( + x.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: i64| { + let output: Val = ::bevy::math::I64Vec2::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = ::bevy::math::I64Vec2::select( + mask.into(), + if_true.into(), + if_false.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [i64; 2]| { + let output: Val = ::bevy::math::I64Vec2::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_array", + |_self: Ref| { + let output: [i64; 2] = ::bevy::math::I64Vec2::to_array(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "extend", + |_self: Val, z: i64| { + let output: Val = ::bevy::math::I64Vec2::extend( + _self.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_x", + |_self: Val, x: i64| { + let output: Val = ::bevy::math::I64Vec2::with_x( + _self.into(), + x.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_y", + |_self: Val, y: i64| { + let output: Val = ::bevy::math::I64Vec2::with_y( + _self.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot", + |_self: Val, rhs: Val| { + let output: i64 = ::bevy::math::I64Vec2::dot( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::dot_into_vec( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::min( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "max", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::max( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = ::bevy::math::I64Vec2::clamp( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min_element", + |_self: Val| { + let output: i64 = ::bevy::math::I64Vec2::min_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "max_element", + |_self: Val| { + let output: i64 = ::bevy::math::I64Vec2::max_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_sum", + |_self: Val| { + let output: i64 = ::bevy::math::I64Vec2::element_sum(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_product", + |_self: Val| { + let output: i64 = ::bevy::math::I64Vec2::element_product( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::cmpeq( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::cmpne( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::cmpge( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpgt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::cmpgt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmple", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::cmple( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::cmplt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs", + |_self: Val| { + let output: Val = ::bevy::math::I64Vec2::abs( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "signum", + |_self: Val| { + let output: Val = ::bevy::math::I64Vec2::signum( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_negative_bitmask", + |_self: Val| { + let output: u32 = ::bevy::math::I64Vec2::is_negative_bitmask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "length_squared", + |_self: Val| { + let output: i64 = ::bevy::math::I64Vec2::length_squared(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "distance_squared", + |_self: Val, rhs: Val| { + let output: i64 = ::bevy::math::I64Vec2::distance_squared( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::div_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::rem_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "perp", + |_self: Val| { + let output: Val = ::bevy::math::I64Vec2::perp( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "perp_dot", + |_self: Val, rhs: Val| { + let output: i64 = ::bevy::math::I64Vec2::perp_dot( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rotate", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::rotate( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_vec2", + |_self: Ref| { + let output: Val = ::bevy::math::I64Vec2::as_vec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_dvec2", + |_self: Ref| { + let output: Val = ::bevy::math::I64Vec2::as_dvec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_ivec2", + |_self: Ref| { + let output: Val = ::bevy::math::I64Vec2::as_ivec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_uvec2", + |_self: Ref| { + let output: Val = ::bevy::math::I64Vec2::as_uvec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_u64vec2", + |_self: Ref| { + let output: Val = ::bevy::math::I64Vec2::as_u64vec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::wrapping_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::wrapping_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::wrapping_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::wrapping_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::saturating_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::saturating_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::saturating_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::saturating_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::wrapping_add_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_sub_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::wrapping_sub_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::saturating_add_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_sub_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::saturating_sub_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: i64| { + let output: Val = ::bevy::math::I64Vec2::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::I64Vec2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: i64| { + let output: Val = ::bevy::math::I64Vec2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec2::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::I64Vec2::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::I64Vec3>::new(world) + .overwrite_script_function( + "add", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::I64Vec3::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::I64Vec3::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::I64Vec3::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::math::I64Vec3::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: i64| { + let output: Val = ::bevy::math::I64Vec3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::I64Vec3::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::I64Vec3::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::I64Vec3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: i64| { + let output: Val = ::bevy::math::I64Vec3::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: i64| { + let output: Val = ::bevy::math::I64Vec3::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: i64| { + let output: Val = ::bevy::math::I64Vec3::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: i64| { + let output: Val = ::bevy::math::I64Vec3::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x: i64, y: i64, z: i64| { + let output: Val = ::bevy::math::I64Vec3::new( + x.into(), + y.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: i64| { + let output: Val = ::bevy::math::I64Vec3::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = ::bevy::math::I64Vec3::select( + mask.into(), + if_true.into(), + if_false.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [i64; 3]| { + let output: Val = ::bevy::math::I64Vec3::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_array", + |_self: Ref| { + let output: [i64; 3] = ::bevy::math::I64Vec3::to_array(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "extend", + |_self: Val, w: i64| { + let output: Val = ::bevy::math::I64Vec3::extend( + _self.into(), + w.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "truncate", + |_self: Val| { + let output: Val = ::bevy::math::I64Vec3::truncate( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_x", + |_self: Val, x: i64| { + let output: Val = ::bevy::math::I64Vec3::with_x( + _self.into(), + x.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_y", + |_self: Val, y: i64| { + let output: Val = ::bevy::math::I64Vec3::with_y( + _self.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_z", + |_self: Val, z: i64| { + let output: Val = ::bevy::math::I64Vec3::with_z( + _self.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot", + |_self: Val, rhs: Val| { + let output: i64 = ::bevy::math::I64Vec3::dot( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::dot_into_vec( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cross", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::cross( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::min( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "max", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::max( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = ::bevy::math::I64Vec3::clamp( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min_element", + |_self: Val| { + let output: i64 = ::bevy::math::I64Vec3::min_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "max_element", + |_self: Val| { + let output: i64 = ::bevy::math::I64Vec3::max_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_sum", + |_self: Val| { + let output: i64 = ::bevy::math::I64Vec3::element_sum(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_product", + |_self: Val| { + let output: i64 = ::bevy::math::I64Vec3::element_product( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::cmpeq( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::cmpne( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::cmpge( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpgt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::cmpgt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmple", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::cmple( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::cmplt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs", + |_self: Val| { + let output: Val = ::bevy::math::I64Vec3::abs( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "signum", + |_self: Val| { + let output: Val = ::bevy::math::I64Vec3::signum( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_negative_bitmask", + |_self: Val| { + let output: u32 = ::bevy::math::I64Vec3::is_negative_bitmask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "length_squared", + |_self: Val| { + let output: i64 = ::bevy::math::I64Vec3::length_squared(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "distance_squared", + |_self: Val, rhs: Val| { + let output: i64 = ::bevy::math::I64Vec3::distance_squared( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::div_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::rem_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_vec3", + |_self: Ref| { + let output: Val = ::bevy::math::I64Vec3::as_vec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_vec3a", + |_self: Ref| { + let output: Val = ::bevy::math::I64Vec3::as_vec3a( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_dvec3", + |_self: Ref| { + let output: Val = ::bevy::math::I64Vec3::as_dvec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_ivec3", + |_self: Ref| { + let output: Val = ::bevy::math::I64Vec3::as_ivec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_uvec3", + |_self: Ref| { + let output: Val = ::bevy::math::I64Vec3::as_uvec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_u64vec3", + |_self: Ref| { + let output: Val = ::bevy::math::I64Vec3::as_u64vec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::wrapping_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::wrapping_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::wrapping_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::wrapping_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::saturating_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::saturating_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::saturating_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::saturating_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::wrapping_add_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_sub_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::wrapping_sub_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::saturating_add_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_sub_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec3::saturating_sub_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::I64Vec3::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::I64Vec3::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::I64Vec4>::new(world) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::I64Vec4::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::math::I64Vec4::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::I64Vec4::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::I64Vec4::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::I64Vec4::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::I64Vec4::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: i64| { + let output: Val = ::bevy::math::I64Vec4::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: i64| { + let output: Val = ::bevy::math::I64Vec4::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::I64Vec4::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::I64Vec4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: i64| { + let output: Val = ::bevy::math::I64Vec4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: i64| { + let output: Val = ::bevy::math::I64Vec4::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x: i64, y: i64, z: i64, w: i64| { + let output: Val = ::bevy::math::I64Vec4::new( + x.into(), + y.into(), + z.into(), + w.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: i64| { + let output: Val = ::bevy::math::I64Vec4::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = ::bevy::math::I64Vec4::select( + mask.into(), + if_true.into(), + if_false.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [i64; 4]| { + let output: Val = ::bevy::math::I64Vec4::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_array", + |_self: Ref| { + let output: [i64; 4] = ::bevy::math::I64Vec4::to_array(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "truncate", + |_self: Val| { + let output: Val = ::bevy::math::I64Vec4::truncate( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_x", + |_self: Val, x: i64| { + let output: Val = ::bevy::math::I64Vec4::with_x( + _self.into(), + x.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_y", + |_self: Val, y: i64| { + let output: Val = ::bevy::math::I64Vec4::with_y( + _self.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_z", + |_self: Val, z: i64| { + let output: Val = ::bevy::math::I64Vec4::with_z( + _self.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_w", + |_self: Val, w: i64| { + let output: Val = ::bevy::math::I64Vec4::with_w( + _self.into(), + w.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot", + |_self: Val, rhs: Val| { + let output: i64 = ::bevy::math::I64Vec4::dot( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::dot_into_vec( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::min( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "max", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::max( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = ::bevy::math::I64Vec4::clamp( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min_element", + |_self: Val| { + let output: i64 = ::bevy::math::I64Vec4::min_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "max_element", + |_self: Val| { + let output: i64 = ::bevy::math::I64Vec4::max_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_sum", + |_self: Val| { + let output: i64 = ::bevy::math::I64Vec4::element_sum(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_product", + |_self: Val| { + let output: i64 = ::bevy::math::I64Vec4::element_product( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::cmpeq( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::cmpne( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::cmpge( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpgt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::cmpgt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmple", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::cmple( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::cmplt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs", + |_self: Val| { + let output: Val = ::bevy::math::I64Vec4::abs( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "signum", + |_self: Val| { + let output: Val = ::bevy::math::I64Vec4::signum( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_negative_bitmask", + |_self: Val| { + let output: u32 = ::bevy::math::I64Vec4::is_negative_bitmask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "length_squared", + |_self: Val| { + let output: i64 = ::bevy::math::I64Vec4::length_squared(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "distance_squared", + |_self: Val, rhs: Val| { + let output: i64 = ::bevy::math::I64Vec4::distance_squared( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::div_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::rem_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_vec4", + |_self: Ref| { + let output: Val = ::bevy::math::I64Vec4::as_vec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_dvec4", + |_self: Ref| { + let output: Val = ::bevy::math::I64Vec4::as_dvec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_ivec4", + |_self: Ref| { + let output: Val = ::bevy::math::I64Vec4::as_ivec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_uvec4", + |_self: Ref| { + let output: Val = ::bevy::math::I64Vec4::as_uvec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_u64vec4", + |_self: Ref| { + let output: Val = ::bevy::math::I64Vec4::as_u64vec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::wrapping_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::wrapping_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::wrapping_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::wrapping_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::saturating_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::saturating_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::saturating_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::saturating_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::wrapping_add_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_sub_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::wrapping_sub_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::saturating_add_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_sub_unsigned", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::saturating_sub_unsigned( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::I64Vec4::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::I64Vec4::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: i64| { + let output: Val = ::bevy::math::I64Vec4::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::UVec2>::new(world) + .overwrite_script_function( + "div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::UVec2::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::UVec2::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: u32| { + let output: Val = ::bevy::math::UVec2::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: u32| { + let output: Val = ::bevy::math::UVec2::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: u32| { + let output: Val = ::bevy::math::UVec2::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::math::UVec2::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::UVec2::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x: u32, y: u32| { + let output: Val = ::bevy::math::UVec2::new( + x.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: u32| { + let output: Val = ::bevy::math::UVec2::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = ::bevy::math::UVec2::select( + mask.into(), + if_true.into(), + if_false.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [u32; 2]| { + let output: Val = ::bevy::math::UVec2::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_array", + |_self: Ref| { + let output: [u32; 2] = ::bevy::math::UVec2::to_array(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "extend", + |_self: Val, z: u32| { + let output: Val = ::bevy::math::UVec2::extend( + _self.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_x", + |_self: Val, x: u32| { + let output: Val = ::bevy::math::UVec2::with_x( + _self.into(), + x.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_y", + |_self: Val, y: u32| { + let output: Val = ::bevy::math::UVec2::with_y( + _self.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot", + |_self: Val, rhs: Val| { + let output: u32 = ::bevy::math::UVec2::dot(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::dot_into_vec( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::min( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "max", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::max( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = ::bevy::math::UVec2::clamp( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min_element", + |_self: Val| { + let output: u32 = ::bevy::math::UVec2::min_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "max_element", + |_self: Val| { + let output: u32 = ::bevy::math::UVec2::max_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_sum", + |_self: Val| { + let output: u32 = ::bevy::math::UVec2::element_sum(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_product", + |_self: Val| { + let output: u32 = ::bevy::math::UVec2::element_product(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::cmpeq( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::cmpne( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::cmpge( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpgt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::cmpgt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmple", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::cmple( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::cmplt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "length_squared", + |_self: Val| { + let output: u32 = ::bevy::math::UVec2::length_squared(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "as_vec2", + |_self: Ref| { + let output: Val = ::bevy::math::UVec2::as_vec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_dvec2", + |_self: Ref| { + let output: Val = ::bevy::math::UVec2::as_dvec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_ivec2", + |_self: Ref| { + let output: Val = ::bevy::math::UVec2::as_ivec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_i64vec2", + |_self: Ref| { + let output: Val = ::bevy::math::UVec2::as_i64vec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_u64vec2", + |_self: Ref| { + let output: Val = ::bevy::math::UVec2::as_u64vec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::wrapping_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::wrapping_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::wrapping_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::wrapping_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::saturating_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::saturating_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::saturating_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::saturating_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add_signed", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::wrapping_add_signed( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add_signed", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::saturating_add_signed( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::UVec2::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::UVec2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: u32| { + let output: Val = ::bevy::math::UVec2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::UVec2::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::UVec2::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: u32| { + let output: Val = ::bevy::math::UVec2::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::UVec3>::new(world) + .overwrite_script_function( + "div", + |_self: Val, rhs: u32| { + let output: Val = ::bevy::math::UVec3::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::UVec3::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::UVec3::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x: u32, y: u32, z: u32| { + let output: Val = ::bevy::math::UVec3::new( + x.into(), + y.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: u32| { + let output: Val = ::bevy::math::UVec3::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = ::bevy::math::UVec3::select( + mask.into(), + if_true.into(), + if_false.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [u32; 3]| { + let output: Val = ::bevy::math::UVec3::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_array", + |_self: Ref| { + let output: [u32; 3] = ::bevy::math::UVec3::to_array(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "extend", + |_self: Val, w: u32| { + let output: Val = ::bevy::math::UVec3::extend( + _self.into(), + w.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "truncate", + |_self: Val| { + let output: Val = ::bevy::math::UVec3::truncate( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_x", + |_self: Val, x: u32| { + let output: Val = ::bevy::math::UVec3::with_x( + _self.into(), + x.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_y", + |_self: Val, y: u32| { + let output: Val = ::bevy::math::UVec3::with_y( + _self.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_z", + |_self: Val, z: u32| { + let output: Val = ::bevy::math::UVec3::with_z( + _self.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot", + |_self: Val, rhs: Val| { + let output: u32 = ::bevy::math::UVec3::dot(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::dot_into_vec( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cross", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::cross( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::min( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "max", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::max( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = ::bevy::math::UVec3::clamp( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min_element", + |_self: Val| { + let output: u32 = ::bevy::math::UVec3::min_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "max_element", + |_self: Val| { + let output: u32 = ::bevy::math::UVec3::max_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_sum", + |_self: Val| { + let output: u32 = ::bevy::math::UVec3::element_sum(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_product", + |_self: Val| { + let output: u32 = ::bevy::math::UVec3::element_product(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::cmpeq( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::cmpne( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::cmpge( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpgt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::cmpgt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmple", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::cmple( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::cmplt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "length_squared", + |_self: Val| { + let output: u32 = ::bevy::math::UVec3::length_squared(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "as_vec3", + |_self: Ref| { + let output: Val = ::bevy::math::UVec3::as_vec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_vec3a", + |_self: Ref| { + let output: Val = ::bevy::math::UVec3::as_vec3a( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_dvec3", + |_self: Ref| { + let output: Val = ::bevy::math::UVec3::as_dvec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_ivec3", + |_self: Ref| { + let output: Val = ::bevy::math::UVec3::as_ivec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_i64vec3", + |_self: Ref| { + let output: Val = ::bevy::math::UVec3::as_i64vec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_u64vec3", + |_self: Ref| { + let output: Val = ::bevy::math::UVec3::as_u64vec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::wrapping_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::wrapping_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::wrapping_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::wrapping_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::saturating_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::saturating_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::saturating_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::saturating_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add_signed", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::wrapping_add_signed( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add_signed", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::saturating_add_signed( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::UVec3::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: u32| { + let output: Val = ::bevy::math::UVec3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: u32| { + let output: Val = ::bevy::math::UVec3::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: u32| { + let output: Val = ::bevy::math::UVec3::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::math::UVec3::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: u32| { + let output: Val = ::bevy::math::UVec3::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::UVec3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::UVec3::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec3::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::UVec3::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::UVec3::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::UVec4>::new(world) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::math::UVec4::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::UVec4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x: u32, y: u32, z: u32, w: u32| { + let output: Val = ::bevy::math::UVec4::new( + x.into(), + y.into(), + z.into(), + w.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: u32| { + let output: Val = ::bevy::math::UVec4::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = ::bevy::math::UVec4::select( + mask.into(), + if_true.into(), + if_false.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [u32; 4]| { + let output: Val = ::bevy::math::UVec4::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_array", + |_self: Ref| { + let output: [u32; 4] = ::bevy::math::UVec4::to_array(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "truncate", + |_self: Val| { + let output: Val = ::bevy::math::UVec4::truncate( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_x", + |_self: Val, x: u32| { + let output: Val = ::bevy::math::UVec4::with_x( + _self.into(), + x.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_y", + |_self: Val, y: u32| { + let output: Val = ::bevy::math::UVec4::with_y( + _self.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_z", + |_self: Val, z: u32| { + let output: Val = ::bevy::math::UVec4::with_z( + _self.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_w", + |_self: Val, w: u32| { + let output: Val = ::bevy::math::UVec4::with_w( + _self.into(), + w.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot", + |_self: Val, rhs: Val| { + let output: u32 = ::bevy::math::UVec4::dot(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::dot_into_vec( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::min( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "max", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::max( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = ::bevy::math::UVec4::clamp( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min_element", + |_self: Val| { + let output: u32 = ::bevy::math::UVec4::min_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "max_element", + |_self: Val| { + let output: u32 = ::bevy::math::UVec4::max_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_sum", + |_self: Val| { + let output: u32 = ::bevy::math::UVec4::element_sum(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_product", + |_self: Val| { + let output: u32 = ::bevy::math::UVec4::element_product(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::cmpeq( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::cmpne( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::cmpge( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpgt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::cmpgt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmple", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::cmple( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::cmplt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "length_squared", + |_self: Val| { + let output: u32 = ::bevy::math::UVec4::length_squared(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "as_vec4", + |_self: Ref| { + let output: Val = ::bevy::math::UVec4::as_vec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_dvec4", + |_self: Ref| { + let output: Val = ::bevy::math::UVec4::as_dvec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_ivec4", + |_self: Ref| { + let output: Val = ::bevy::math::UVec4::as_ivec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_i64vec4", + |_self: Ref| { + let output: Val = ::bevy::math::UVec4::as_i64vec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_u64vec4", + |_self: Ref| { + let output: Val = ::bevy::math::UVec4::as_u64vec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::wrapping_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::wrapping_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::wrapping_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::wrapping_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::saturating_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::saturating_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::saturating_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::saturating_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add_signed", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::wrapping_add_signed( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add_signed", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::saturating_add_signed( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::UVec4::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::UVec4::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: u32| { + let output: Val = ::bevy::math::UVec4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::UVec4::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: u32| { + let output: Val = ::bevy::math::UVec4::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::UVec4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::UVec4::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::UVec4::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: u32| { + let output: Val = ::bevy::math::UVec4::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: u32| { + let output: Val = ::bevy::math::UVec4::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::UVec4::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: u32| { + let output: Val = ::bevy::math::UVec4::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::U64Vec2>::new(world) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::math::U64Vec2::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: u64| { + let output: Val = ::bevy::math::U64Vec2::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: u64| { + let output: Val = ::bevy::math::U64Vec2::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::U64Vec2::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: u64| { + let output: Val = ::bevy::math::U64Vec2::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::U64Vec2::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::U64Vec2::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: u64| { + let output: Val = ::bevy::math::U64Vec2::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::U64Vec2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::U64Vec2::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x: u64, y: u64| { + let output: Val = ::bevy::math::U64Vec2::new( + x.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: u64| { + let output: Val = ::bevy::math::U64Vec2::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = ::bevy::math::U64Vec2::select( + mask.into(), + if_true.into(), + if_false.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [u64; 2]| { + let output: Val = ::bevy::math::U64Vec2::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_array", + |_self: Ref| { + let output: [u64; 2] = ::bevy::math::U64Vec2::to_array(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "extend", + |_self: Val, z: u64| { + let output: Val = ::bevy::math::U64Vec2::extend( + _self.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_x", + |_self: Val, x: u64| { + let output: Val = ::bevy::math::U64Vec2::with_x( + _self.into(), + x.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_y", + |_self: Val, y: u64| { + let output: Val = ::bevy::math::U64Vec2::with_y( + _self.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot", + |_self: Val, rhs: Val| { + let output: u64 = ::bevy::math::U64Vec2::dot( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::dot_into_vec( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::min( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "max", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::max( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = ::bevy::math::U64Vec2::clamp( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min_element", + |_self: Val| { + let output: u64 = ::bevy::math::U64Vec2::min_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "max_element", + |_self: Val| { + let output: u64 = ::bevy::math::U64Vec2::max_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_sum", + |_self: Val| { + let output: u64 = ::bevy::math::U64Vec2::element_sum(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_product", + |_self: Val| { + let output: u64 = ::bevy::math::U64Vec2::element_product( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::cmpeq( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::cmpne( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::cmpge( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpgt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::cmpgt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmple", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::cmple( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::cmplt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "length_squared", + |_self: Val| { + let output: u64 = ::bevy::math::U64Vec2::length_squared(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "as_vec2", + |_self: Ref| { + let output: Val = ::bevy::math::U64Vec2::as_vec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_dvec2", + |_self: Ref| { + let output: Val = ::bevy::math::U64Vec2::as_dvec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_ivec2", + |_self: Ref| { + let output: Val = ::bevy::math::U64Vec2::as_ivec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_uvec2", + |_self: Ref| { + let output: Val = ::bevy::math::U64Vec2::as_uvec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_i64vec2", + |_self: Ref| { + let output: Val = ::bevy::math::U64Vec2::as_i64vec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::wrapping_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::wrapping_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::wrapping_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::wrapping_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::saturating_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::saturating_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::saturating_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::saturating_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add_signed", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::wrapping_add_signed( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add_signed", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::saturating_add_signed( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: u64| { + let output: Val = ::bevy::math::U64Vec2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::U64Vec2::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec2::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::U64Vec2::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::U64Vec3>::new(world) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::U64Vec3::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::U64Vec3::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: u64| { + let output: Val = ::bevy::math::U64Vec3::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: u64| { + let output: Val = ::bevy::math::U64Vec3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::U64Vec3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::U64Vec3::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: u64| { + let output: Val = ::bevy::math::U64Vec3::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: u64| { + let output: Val = ::bevy::math::U64Vec3::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x: u64, y: u64, z: u64| { + let output: Val = ::bevy::math::U64Vec3::new( + x.into(), + y.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: u64| { + let output: Val = ::bevy::math::U64Vec3::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = ::bevy::math::U64Vec3::select( + mask.into(), + if_true.into(), + if_false.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [u64; 3]| { + let output: Val = ::bevy::math::U64Vec3::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_array", + |_self: Ref| { + let output: [u64; 3] = ::bevy::math::U64Vec3::to_array(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "extend", + |_self: Val, w: u64| { + let output: Val = ::bevy::math::U64Vec3::extend( + _self.into(), + w.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "truncate", + |_self: Val| { + let output: Val = ::bevy::math::U64Vec3::truncate( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_x", + |_self: Val, x: u64| { + let output: Val = ::bevy::math::U64Vec3::with_x( + _self.into(), + x.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_y", + |_self: Val, y: u64| { + let output: Val = ::bevy::math::U64Vec3::with_y( + _self.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_z", + |_self: Val, z: u64| { + let output: Val = ::bevy::math::U64Vec3::with_z( + _self.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot", + |_self: Val, rhs: Val| { + let output: u64 = ::bevy::math::U64Vec3::dot( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::dot_into_vec( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cross", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::cross( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::min( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "max", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::max( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = ::bevy::math::U64Vec3::clamp( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min_element", + |_self: Val| { + let output: u64 = ::bevy::math::U64Vec3::min_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "max_element", + |_self: Val| { + let output: u64 = ::bevy::math::U64Vec3::max_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_sum", + |_self: Val| { + let output: u64 = ::bevy::math::U64Vec3::element_sum(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_product", + |_self: Val| { + let output: u64 = ::bevy::math::U64Vec3::element_product( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::cmpeq( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::cmpne( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::cmpge( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpgt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::cmpgt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmple", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::cmple( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::cmplt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "length_squared", + |_self: Val| { + let output: u64 = ::bevy::math::U64Vec3::length_squared(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "as_vec3", + |_self: Ref| { + let output: Val = ::bevy::math::U64Vec3::as_vec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_vec3a", + |_self: Ref| { + let output: Val = ::bevy::math::U64Vec3::as_vec3a( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_dvec3", + |_self: Ref| { + let output: Val = ::bevy::math::U64Vec3::as_dvec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_ivec3", + |_self: Ref| { + let output: Val = ::bevy::math::U64Vec3::as_ivec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_uvec3", + |_self: Ref| { + let output: Val = ::bevy::math::U64Vec3::as_uvec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_i64vec3", + |_self: Ref| { + let output: Val = ::bevy::math::U64Vec3::as_i64vec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::wrapping_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::wrapping_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::wrapping_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::wrapping_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::saturating_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::saturating_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::saturating_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::saturating_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add_signed", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::wrapping_add_signed( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add_signed", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec3::saturating_add_signed( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: u64| { + let output: Val = ::bevy::math::U64Vec3::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::U64Vec3::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::U64Vec3::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::math::U64Vec3::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::U64Vec3::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::U64Vec4>::new(world) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::U64Vec4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::U64Vec4::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::math::U64Vec4::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::U64Vec4::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::U64Vec4::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: u64| { + let output: Val = ::bevy::math::U64Vec4::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: u64| { + let output: Val = ::bevy::math::U64Vec4::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: u64| { + let output: Val = ::bevy::math::U64Vec4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::U64Vec4::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::U64Vec4::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::U64Vec4::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x: u64, y: u64, z: u64, w: u64| { + let output: Val = ::bevy::math::U64Vec4::new( + x.into(), + y.into(), + z.into(), + w.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: u64| { + let output: Val = ::bevy::math::U64Vec4::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = ::bevy::math::U64Vec4::select( + mask.into(), + if_true.into(), + if_false.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [u64; 4]| { + let output: Val = ::bevy::math::U64Vec4::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_array", + |_self: Ref| { + let output: [u64; 4] = ::bevy::math::U64Vec4::to_array(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "truncate", + |_self: Val| { + let output: Val = ::bevy::math::U64Vec4::truncate( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_x", + |_self: Val, x: u64| { + let output: Val = ::bevy::math::U64Vec4::with_x( + _self.into(), + x.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_y", + |_self: Val, y: u64| { + let output: Val = ::bevy::math::U64Vec4::with_y( + _self.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_z", + |_self: Val, z: u64| { + let output: Val = ::bevy::math::U64Vec4::with_z( + _self.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_w", + |_self: Val, w: u64| { + let output: Val = ::bevy::math::U64Vec4::with_w( + _self.into(), + w.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot", + |_self: Val, rhs: Val| { + let output: u64 = ::bevy::math::U64Vec4::dot( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::dot_into_vec( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::min( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "max", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::max( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = ::bevy::math::U64Vec4::clamp( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min_element", + |_self: Val| { + let output: u64 = ::bevy::math::U64Vec4::min_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "max_element", + |_self: Val| { + let output: u64 = ::bevy::math::U64Vec4::max_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_sum", + |_self: Val| { + let output: u64 = ::bevy::math::U64Vec4::element_sum(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_product", + |_self: Val| { + let output: u64 = ::bevy::math::U64Vec4::element_product( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::cmpeq( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::cmpne( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::cmpge( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpgt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::cmpgt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmple", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::cmple( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::cmplt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "length_squared", + |_self: Val| { + let output: u64 = ::bevy::math::U64Vec4::length_squared(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "as_vec4", + |_self: Ref| { + let output: Val = ::bevy::math::U64Vec4::as_vec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_dvec4", + |_self: Ref| { + let output: Val = ::bevy::math::U64Vec4::as_dvec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_ivec4", + |_self: Ref| { + let output: Val = ::bevy::math::U64Vec4::as_ivec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_uvec4", + |_self: Ref| { + let output: Val = ::bevy::math::U64Vec4::as_uvec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_i64vec4", + |_self: Ref| { + let output: Val = ::bevy::math::U64Vec4::as_i64vec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::wrapping_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::wrapping_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::wrapping_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::wrapping_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::saturating_add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::saturating_sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::saturating_mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::saturating_div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "wrapping_add_signed", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::wrapping_add_signed( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "saturating_add_signed", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::U64Vec4::saturating_add_signed( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: u64| { + let output: Val = ::bevy::math::U64Vec4::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: u64| { + let output: Val = ::bevy::math::U64Vec4::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::Vec2>::new(world) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec2::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::Vec2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Vec2::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Vec2::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec2::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec2::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x: f32, y: f32| { + let output: Val = ::bevy::math::Vec2::new( + x.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: f32| { + let output: Val = ::bevy::math::Vec2::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = ::bevy::math::Vec2::select( + mask.into(), + if_true.into(), + if_false.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [f32; 2]| { + let output: Val = ::bevy::math::Vec2::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_array", + |_self: Ref| { + let output: [f32; 2] = ::bevy::math::Vec2::to_array(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "extend", + |_self: Val, z: f32| { + let output: Val = ::bevy::math::Vec2::extend( + _self.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_x", + |_self: Val, x: f32| { + let output: Val = ::bevy::math::Vec2::with_x( + _self.into(), + x.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_y", + |_self: Val, y: f32| { + let output: Val = ::bevy::math::Vec2::with_y( + _self.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot", + |_self: Val, rhs: Val| { + let output: f32 = ::bevy::math::Vec2::dot(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec2::dot_into_vec( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec2::min( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "max", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec2::max( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = ::bevy::math::Vec2::clamp( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min_element", + |_self: Val| { + let output: f32 = ::bevy::math::Vec2::min_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "max_element", + |_self: Val| { + let output: f32 = ::bevy::math::Vec2::max_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_sum", + |_self: Val| { + let output: f32 = ::bevy::math::Vec2::element_sum(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_product", + |_self: Val| { + let output: f32 = ::bevy::math::Vec2::element_product(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec2::cmpeq( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec2::cmpne( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec2::cmpge( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpgt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec2::cmpgt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmple", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec2::cmple( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec2::cmplt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs", + |_self: Val| { + let output: Val = ::bevy::math::Vec2::abs( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "signum", + |_self: Val| { + let output: Val = ::bevy::math::Vec2::signum( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "copysign", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec2::copysign( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_negative_bitmask", + |_self: Val| { + let output: u32 = ::bevy::math::Vec2::is_negative_bitmask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite", + |_self: Val| { + let output: bool = ::bevy::math::Vec2::is_finite(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite_mask", + |_self: Val| { + let output: Val = ::bevy::math::Vec2::is_finite_mask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_nan", + |_self: Val| { + let output: bool = ::bevy::math::Vec2::is_nan(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "is_nan_mask", + |_self: Val| { + let output: Val = ::bevy::math::Vec2::is_nan_mask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "length", + |_self: Val| { + let output: f32 = ::bevy::math::Vec2::length(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "length_squared", + |_self: Val| { + let output: f32 = ::bevy::math::Vec2::length_squared(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "length_recip", + |_self: Val| { + let output: f32 = ::bevy::math::Vec2::length_recip(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "distance", + |_self: Val, rhs: Val| { + let output: f32 = ::bevy::math::Vec2::distance( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "distance_squared", + |_self: Val, rhs: Val| { + let output: f32 = ::bevy::math::Vec2::distance_squared( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec2::div_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec2::rem_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize", + |_self: Val| { + let output: Val = ::bevy::math::Vec2::normalize( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize_or", + |_self: Val, fallback: Val| { + let output: Val = ::bevy::math::Vec2::normalize_or( + _self.into(), + fallback.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize_or_zero", + |_self: Val| { + let output: Val = ::bevy::math::Vec2::normalize_or_zero( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_normalized", + |_self: Val| { + let output: bool = ::bevy::math::Vec2::is_normalized(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "project_onto", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec2::project_onto( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reject_from", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec2::reject_from( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "project_onto_normalized", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec2::project_onto_normalized( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reject_from_normalized", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec2::reject_from_normalized( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "round", + |_self: Val| { + let output: Val = ::bevy::math::Vec2::round( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "floor", + |_self: Val| { + let output: Val = ::bevy::math::Vec2::floor( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "ceil", + |_self: Val| { + let output: Val = ::bevy::math::Vec2::ceil( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "trunc", + |_self: Val| { + let output: Val = ::bevy::math::Vec2::trunc( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "fract", + |_self: Val| { + let output: Val = ::bevy::math::Vec2::fract( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "fract_gl", + |_self: Val| { + let output: Val = ::bevy::math::Vec2::fract_gl( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "exp", + |_self: Val| { + let output: Val = ::bevy::math::Vec2::exp( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "powf", + |_self: Val, n: f32| { + let output: Val = ::bevy::math::Vec2::powf( + _self.into(), + n.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "recip", + |_self: Val| { + let output: Val = ::bevy::math::Vec2::recip( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "lerp", + |_self: Val, rhs: Val, s: f32| { + let output: Val = ::bevy::math::Vec2::lerp( + _self.into(), + rhs.into(), + s.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "move_towards", + |_self: Ref, rhs: Val, d: f32| { + let output: Val = ::bevy::math::Vec2::move_towards( + _self.into(), + rhs.into(), + d.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "midpoint", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec2::midpoint( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs_diff_eq", + | + _self: Val, + rhs: Val, + max_abs_diff: f32| + { + let output: bool = ::bevy::math::Vec2::abs_diff_eq( + _self.into(), + rhs.into(), + max_abs_diff.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp_length", + |_self: Val, min: f32, max: f32| { + let output: Val = ::bevy::math::Vec2::clamp_length( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp_length_max", + |_self: Val, max: f32| { + let output: Val = ::bevy::math::Vec2::clamp_length_max( + _self.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp_length_min", + |_self: Val, min: f32| { + let output: Val = ::bevy::math::Vec2::clamp_length_min( + _self.into(), + min.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_add", + | + _self: Val, + a: Val, + b: Val| + { + let output: Val = ::bevy::math::Vec2::mul_add( + _self.into(), + a.into(), + b.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reflect", + |_self: Val, normal: Val| { + let output: Val = ::bevy::math::Vec2::reflect( + _self.into(), + normal.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "refract", + |_self: Val, normal: Val, eta: f32| { + let output: Val = ::bevy::math::Vec2::refract( + _self.into(), + normal.into(), + eta.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_angle", + |angle: f32| { + let output: Val = ::bevy::math::Vec2::from_angle( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_angle", + |_self: Val| { + let output: f32 = ::bevy::math::Vec2::to_angle(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "angle_between", + |_self: Val, rhs: Val| { + let output: f32 = ::bevy::math::Vec2::angle_between( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "angle_to", + |_self: Val, rhs: Val| { + let output: f32 = ::bevy::math::Vec2::angle_to( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "perp", + |_self: Val| { + let output: Val = ::bevy::math::Vec2::perp( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "perp_dot", + |_self: Val, rhs: Val| { + let output: f32 = ::bevy::math::Vec2::perp_dot( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rotate", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec2::rotate( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rotate_towards", + | + _self: Ref, + rhs: Val, + max_angle: f32| + { + let output: Val = ::bevy::math::Vec2::rotate_towards( + _self.into(), + rhs.into(), + max_angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_dvec2", + |_self: Ref| { + let output: Val = ::bevy::math::Vec2::as_dvec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_ivec2", + |_self: Ref| { + let output: Val = ::bevy::math::Vec2::as_ivec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_uvec2", + |_self: Ref| { + let output: Val = ::bevy::math::Vec2::as_uvec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_i64vec2", + |_self: Ref| { + let output: Val = ::bevy::math::Vec2::as_i64vec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_u64vec2", + |_self: Ref| { + let output: Val = ::bevy::math::Vec2::as_u64vec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::Vec2::eq(_self.into(), other.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::Vec2::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::Vec2::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::Vec2::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Vec2::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec2::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Vec2::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Vec2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::Vec2::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::Vec2::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::Vec2::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::Vec3A>::new(world) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::Vec3A::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3A::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::Vec3A::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Vec3A::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Vec3A::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x: f32, y: f32, z: f32| { + let output: Val = ::bevy::math::Vec3A::new( + x.into(), + y.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: f32| { + let output: Val = ::bevy::math::Vec3A::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = ::bevy::math::Vec3A::select( + mask.into(), + if_true.into(), + if_false.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [f32; 3]| { + let output: Val = ::bevy::math::Vec3A::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_array", + |_self: Ref| { + let output: [f32; 3] = ::bevy::math::Vec3A::to_array(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "from_vec4", + |v: Val| { + let output: Val = ::bevy::math::Vec3A::from_vec4( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "extend", + |_self: Val, w: f32| { + let output: Val = ::bevy::math::Vec3A::extend( + _self.into(), + w.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "truncate", + |_self: Val| { + let output: Val = ::bevy::math::Vec3A::truncate( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_x", + |_self: Val, x: f32| { + let output: Val = ::bevy::math::Vec3A::with_x( + _self.into(), + x.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_y", + |_self: Val, y: f32| { + let output: Val = ::bevy::math::Vec3A::with_y( + _self.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_z", + |_self: Val, z: f32| { + let output: Val = ::bevy::math::Vec3A::with_z( + _self.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot", + |_self: Val, rhs: Val| { + let output: f32 = ::bevy::math::Vec3A::dot(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3A::dot_into_vec( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cross", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3A::cross( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3A::min( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "max", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3A::max( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = ::bevy::math::Vec3A::clamp( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min_element", + |_self: Val| { + let output: f32 = ::bevy::math::Vec3A::min_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "max_element", + |_self: Val| { + let output: f32 = ::bevy::math::Vec3A::max_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_sum", + |_self: Val| { + let output: f32 = ::bevy::math::Vec3A::element_sum(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_product", + |_self: Val| { + let output: f32 = ::bevy::math::Vec3A::element_product(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3A::cmpeq( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3A::cmpne( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3A::cmpge( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpgt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3A::cmpgt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmple", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3A::cmple( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3A::cmplt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs", + |_self: Val| { + let output: Val = ::bevy::math::Vec3A::abs( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "signum", + |_self: Val| { + let output: Val = ::bevy::math::Vec3A::signum( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "copysign", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3A::copysign( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_negative_bitmask", + |_self: Val| { + let output: u32 = ::bevy::math::Vec3A::is_negative_bitmask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite", + |_self: Val| { + let output: bool = ::bevy::math::Vec3A::is_finite(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite_mask", + |_self: Val| { + let output: Val = ::bevy::math::Vec3A::is_finite_mask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_nan", + |_self: Val| { + let output: bool = ::bevy::math::Vec3A::is_nan(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "is_nan_mask", + |_self: Val| { + let output: Val = ::bevy::math::Vec3A::is_nan_mask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "length", + |_self: Val| { + let output: f32 = ::bevy::math::Vec3A::length(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "length_squared", + |_self: Val| { + let output: f32 = ::bevy::math::Vec3A::length_squared(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "length_recip", + |_self: Val| { + let output: f32 = ::bevy::math::Vec3A::length_recip(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "distance", + |_self: Val, rhs: Val| { + let output: f32 = ::bevy::math::Vec3A::distance( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "distance_squared", + |_self: Val, rhs: Val| { + let output: f32 = ::bevy::math::Vec3A::distance_squared( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3A::div_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3A::rem_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize", + |_self: Val| { + let output: Val = ::bevy::math::Vec3A::normalize( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize_or", + |_self: Val, fallback: Val| { + let output: Val = ::bevy::math::Vec3A::normalize_or( + _self.into(), + fallback.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize_or_zero", + |_self: Val| { + let output: Val = ::bevy::math::Vec3A::normalize_or_zero( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_normalized", + |_self: Val| { + let output: bool = ::bevy::math::Vec3A::is_normalized(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "project_onto", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3A::project_onto( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reject_from", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3A::reject_from( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "project_onto_normalized", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3A::project_onto_normalized( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reject_from_normalized", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3A::reject_from_normalized( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "round", + |_self: Val| { + let output: Val = ::bevy::math::Vec3A::round( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "floor", + |_self: Val| { + let output: Val = ::bevy::math::Vec3A::floor( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "ceil", + |_self: Val| { + let output: Val = ::bevy::math::Vec3A::ceil( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "trunc", + |_self: Val| { + let output: Val = ::bevy::math::Vec3A::trunc( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "fract", + |_self: Val| { + let output: Val = ::bevy::math::Vec3A::fract( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "fract_gl", + |_self: Val| { + let output: Val = ::bevy::math::Vec3A::fract_gl( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "exp", + |_self: Val| { + let output: Val = ::bevy::math::Vec3A::exp( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "powf", + |_self: Val, n: f32| { + let output: Val = ::bevy::math::Vec3A::powf( + _self.into(), + n.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "recip", + |_self: Val| { + let output: Val = ::bevy::math::Vec3A::recip( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "lerp", + |_self: Val, rhs: Val, s: f32| { + let output: Val = ::bevy::math::Vec3A::lerp( + _self.into(), + rhs.into(), + s.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "move_towards", + |_self: Ref, rhs: Val, d: f32| { + let output: Val = ::bevy::math::Vec3A::move_towards( + _self.into(), + rhs.into(), + d.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "midpoint", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3A::midpoint( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs_diff_eq", + | + _self: Val, + rhs: Val, + max_abs_diff: f32| + { + let output: bool = ::bevy::math::Vec3A::abs_diff_eq( + _self.into(), + rhs.into(), + max_abs_diff.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp_length", + |_self: Val, min: f32, max: f32| { + let output: Val = ::bevy::math::Vec3A::clamp_length( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp_length_max", + |_self: Val, max: f32| { + let output: Val = ::bevy::math::Vec3A::clamp_length_max( + _self.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp_length_min", + |_self: Val, min: f32| { + let output: Val = ::bevy::math::Vec3A::clamp_length_min( + _self.into(), + min.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_add", + | + _self: Val, + a: Val, + b: Val| + { + let output: Val = ::bevy::math::Vec3A::mul_add( + _self.into(), + a.into(), + b.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reflect", + |_self: Val, normal: Val| { + let output: Val = ::bevy::math::Vec3A::reflect( + _self.into(), + normal.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "refract", + | + _self: Val, + normal: Val, + eta: f32| + { + let output: Val = ::bevy::math::Vec3A::refract( + _self.into(), + normal.into(), + eta.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "angle_between", + |_self: Val, rhs: Val| { + let output: f32 = ::bevy::math::Vec3A::angle_between( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "any_orthogonal_vector", + |_self: Ref| { + let output: Val = ::bevy::math::Vec3A::any_orthogonal_vector( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "any_orthonormal_vector", + |_self: Ref| { + let output: Val = ::bevy::math::Vec3A::any_orthonormal_vector( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_dvec3", + |_self: Ref| { + let output: Val = ::bevy::math::Vec3A::as_dvec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_ivec3", + |_self: Ref| { + let output: Val = ::bevy::math::Vec3A::as_ivec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_uvec3", + |_self: Ref| { + let output: Val = ::bevy::math::Vec3A::as_uvec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_i64vec3", + |_self: Ref| { + let output: Val = ::bevy::math::Vec3A::as_i64vec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_u64vec3", + |_self: Ref| { + let output: Val = ::bevy::math::Vec3A::as_u64vec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::Vec3A::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::Vec3A::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::Vec3A::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::Vec3A::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Vec3A::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3A::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3A::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3A::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = ::bevy::math::Vec3A::eq(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec3A::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Vec3A::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Vec3A::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::Vec3A::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::Vec4>::new(world) + .overwrite_script_function( + "new", + |x: f32, y: f32, z: f32, w: f32| { + let output: Val = ::bevy::math::Vec4::new( + x.into(), + y.into(), + z.into(), + w.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: f32| { + let output: Val = ::bevy::math::Vec4::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = ::bevy::math::Vec4::select( + mask.into(), + if_true.into(), + if_false.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [f32; 4]| { + let output: Val = ::bevy::math::Vec4::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_array", + |_self: Ref| { + let output: [f32; 4] = ::bevy::math::Vec4::to_array(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "truncate", + |_self: Val| { + let output: Val = ::bevy::math::Vec4::truncate( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_x", + |_self: Val, x: f32| { + let output: Val = ::bevy::math::Vec4::with_x( + _self.into(), + x.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_y", + |_self: Val, y: f32| { + let output: Val = ::bevy::math::Vec4::with_y( + _self.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_z", + |_self: Val, z: f32| { + let output: Val = ::bevy::math::Vec4::with_z( + _self.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_w", + |_self: Val, w: f32| { + let output: Val = ::bevy::math::Vec4::with_w( + _self.into(), + w.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot", + |_self: Val, rhs: Val| { + let output: f32 = ::bevy::math::Vec4::dot(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec4::dot_into_vec( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec4::min( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "max", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec4::max( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = ::bevy::math::Vec4::clamp( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min_element", + |_self: Val| { + let output: f32 = ::bevy::math::Vec4::min_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "max_element", + |_self: Val| { + let output: f32 = ::bevy::math::Vec4::max_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_sum", + |_self: Val| { + let output: f32 = ::bevy::math::Vec4::element_sum(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_product", + |_self: Val| { + let output: f32 = ::bevy::math::Vec4::element_product(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec4::cmpeq( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec4::cmpne( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec4::cmpge( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpgt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec4::cmpgt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmple", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec4::cmple( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec4::cmplt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs", + |_self: Val| { + let output: Val = ::bevy::math::Vec4::abs( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "signum", + |_self: Val| { + let output: Val = ::bevy::math::Vec4::signum( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "copysign", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec4::copysign( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_negative_bitmask", + |_self: Val| { + let output: u32 = ::bevy::math::Vec4::is_negative_bitmask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite", + |_self: Val| { + let output: bool = ::bevy::math::Vec4::is_finite(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite_mask", + |_self: Val| { + let output: Val = ::bevy::math::Vec4::is_finite_mask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_nan", + |_self: Val| { + let output: bool = ::bevy::math::Vec4::is_nan(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "is_nan_mask", + |_self: Val| { + let output: Val = ::bevy::math::Vec4::is_nan_mask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "length", + |_self: Val| { + let output: f32 = ::bevy::math::Vec4::length(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "length_squared", + |_self: Val| { + let output: f32 = ::bevy::math::Vec4::length_squared(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "length_recip", + |_self: Val| { + let output: f32 = ::bevy::math::Vec4::length_recip(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "distance", + |_self: Val, rhs: Val| { + let output: f32 = ::bevy::math::Vec4::distance( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "distance_squared", + |_self: Val, rhs: Val| { + let output: f32 = ::bevy::math::Vec4::distance_squared( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec4::div_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec4::rem_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize", + |_self: Val| { + let output: Val = ::bevy::math::Vec4::normalize( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize_or", + |_self: Val, fallback: Val| { + let output: Val = ::bevy::math::Vec4::normalize_or( + _self.into(), + fallback.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize_or_zero", + |_self: Val| { + let output: Val = ::bevy::math::Vec4::normalize_or_zero( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_normalized", + |_self: Val| { + let output: bool = ::bevy::math::Vec4::is_normalized(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "project_onto", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec4::project_onto( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reject_from", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec4::reject_from( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "project_onto_normalized", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec4::project_onto_normalized( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reject_from_normalized", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec4::reject_from_normalized( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "round", + |_self: Val| { + let output: Val = ::bevy::math::Vec4::round( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "floor", + |_self: Val| { + let output: Val = ::bevy::math::Vec4::floor( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "ceil", + |_self: Val| { + let output: Val = ::bevy::math::Vec4::ceil( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "trunc", + |_self: Val| { + let output: Val = ::bevy::math::Vec4::trunc( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "fract", + |_self: Val| { + let output: Val = ::bevy::math::Vec4::fract( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "fract_gl", + |_self: Val| { + let output: Val = ::bevy::math::Vec4::fract_gl( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "exp", + |_self: Val| { + let output: Val = ::bevy::math::Vec4::exp( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "powf", + |_self: Val, n: f32| { + let output: Val = ::bevy::math::Vec4::powf( + _self.into(), + n.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "recip", + |_self: Val| { + let output: Val = ::bevy::math::Vec4::recip( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "lerp", + |_self: Val, rhs: Val, s: f32| { + let output: Val = ::bevy::math::Vec4::lerp( + _self.into(), + rhs.into(), + s.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "move_towards", + |_self: Ref, rhs: Val, d: f32| { + let output: Val = ::bevy::math::Vec4::move_towards( + _self.into(), + rhs.into(), + d.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "midpoint", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec4::midpoint( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs_diff_eq", + | + _self: Val, + rhs: Val, + max_abs_diff: f32| + { + let output: bool = ::bevy::math::Vec4::abs_diff_eq( + _self.into(), + rhs.into(), + max_abs_diff.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp_length", + |_self: Val, min: f32, max: f32| { + let output: Val = ::bevy::math::Vec4::clamp_length( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp_length_max", + |_self: Val, max: f32| { + let output: Val = ::bevy::math::Vec4::clamp_length_max( + _self.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp_length_min", + |_self: Val, min: f32| { + let output: Val = ::bevy::math::Vec4::clamp_length_min( + _self.into(), + min.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_add", + | + _self: Val, + a: Val, + b: Val| + { + let output: Val = ::bevy::math::Vec4::mul_add( + _self.into(), + a.into(), + b.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reflect", + |_self: Val, normal: Val| { + let output: Val = ::bevy::math::Vec4::reflect( + _self.into(), + normal.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "refract", + |_self: Val, normal: Val, eta: f32| { + let output: Val = ::bevy::math::Vec4::refract( + _self.into(), + normal.into(), + eta.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_dvec4", + |_self: Ref| { + let output: Val = ::bevy::math::Vec4::as_dvec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_ivec4", + |_self: Ref| { + let output: Val = ::bevy::math::Vec4::as_ivec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_uvec4", + |_self: Ref| { + let output: Val = ::bevy::math::Vec4::as_uvec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_i64vec4", + |_self: Ref| { + let output: Val = ::bevy::math::Vec4::as_i64vec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_u64vec4", + |_self: Ref| { + let output: Val = ::bevy::math::Vec4::as_u64vec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec4::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec4::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Vec4::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::Vec4::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Vec4::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec4::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::Vec4::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::Vec4::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Vec4::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Vec4::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Vec4::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = ::bevy::math::Vec4::eq(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::Vec4::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::Vec4::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::Vec4::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Vec4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::Vec4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::BVec2>::new(world) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::math::BVec2::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x: bool, y: bool| { + let output: Val = ::bevy::math::BVec2::new( + x.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: bool| { + let output: Val = ::bevy::math::BVec2::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [bool; 2]| { + let output: Val = ::bevy::math::BVec2::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "bitmask", + |_self: Val| { + let output: u32 = ::bevy::math::BVec2::bitmask(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "any", + |_self: Val| { + let output: bool = ::bevy::math::BVec2::any(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "all", + |_self: Val| { + let output: bool = ::bevy::math::BVec2::all(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "test", + |_self: Ref, index: usize| { + let output: bool = ::bevy::math::BVec2::test( + _self.into(), + index.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "set", + |_self: Mut, index: usize, value: bool| { + let output: () = ::bevy::math::BVec2::set( + _self.into(), + index.into(), + value.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::BVec2::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::BVec2::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::BVec3>::new(world) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::math::BVec3::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x: bool, y: bool, z: bool| { + let output: Val = ::bevy::math::BVec3::new( + x.into(), + y.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: bool| { + let output: Val = ::bevy::math::BVec3::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [bool; 3]| { + let output: Val = ::bevy::math::BVec3::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "bitmask", + |_self: Val| { + let output: u32 = ::bevy::math::BVec3::bitmask(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "any", + |_self: Val| { + let output: bool = ::bevy::math::BVec3::any(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "all", + |_self: Val| { + let output: bool = ::bevy::math::BVec3::all(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "test", + |_self: Ref, index: usize| { + let output: bool = ::bevy::math::BVec3::test( + _self.into(), + index.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "set", + |_self: Mut, index: usize, value: bool| { + let output: () = ::bevy::math::BVec3::set( + _self.into(), + index.into(), + value.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::BVec3::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::BVec3::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::BVec4>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::BVec4::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::BVec4::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::math::BVec4::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x: bool, y: bool, z: bool, w: bool| { + let output: Val = ::bevy::math::BVec4::new( + x.into(), + y.into(), + z.into(), + w.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: bool| { + let output: Val = ::bevy::math::BVec4::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [bool; 4]| { + let output: Val = ::bevy::math::BVec4::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "bitmask", + |_self: Val| { + let output: u32 = ::bevy::math::BVec4::bitmask(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "any", + |_self: Val| { + let output: bool = ::bevy::math::BVec4::any(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "all", + |_self: Val| { + let output: bool = ::bevy::math::BVec4::all(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "test", + |_self: Ref, index: usize| { + let output: bool = ::bevy::math::BVec4::test( + _self.into(), + index.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "set", + |_self: Mut, index: usize, value: bool| { + let output: () = ::bevy::math::BVec4::set( + _self.into(), + index.into(), + value.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::DVec2>::new(world) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::math::DVec2::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec2::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x: f64, y: f64| { + let output: Val = ::bevy::math::DVec2::new( + x.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: f64| { + let output: Val = ::bevy::math::DVec2::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = ::bevy::math::DVec2::select( + mask.into(), + if_true.into(), + if_false.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [f64; 2]| { + let output: Val = ::bevy::math::DVec2::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_array", + |_self: Ref| { + let output: [f64; 2] = ::bevy::math::DVec2::to_array(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "extend", + |_self: Val, z: f64| { + let output: Val = ::bevy::math::DVec2::extend( + _self.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_x", + |_self: Val, x: f64| { + let output: Val = ::bevy::math::DVec2::with_x( + _self.into(), + x.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_y", + |_self: Val, y: f64| { + let output: Val = ::bevy::math::DVec2::with_y( + _self.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot", + |_self: Val, rhs: Val| { + let output: f64 = ::bevy::math::DVec2::dot(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec2::dot_into_vec( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec2::min( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "max", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec2::max( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = ::bevy::math::DVec2::clamp( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min_element", + |_self: Val| { + let output: f64 = ::bevy::math::DVec2::min_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "max_element", + |_self: Val| { + let output: f64 = ::bevy::math::DVec2::max_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_sum", + |_self: Val| { + let output: f64 = ::bevy::math::DVec2::element_sum(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_product", + |_self: Val| { + let output: f64 = ::bevy::math::DVec2::element_product(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec2::cmpeq( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec2::cmpne( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec2::cmpge( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpgt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec2::cmpgt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmple", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec2::cmple( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec2::cmplt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs", + |_self: Val| { + let output: Val = ::bevy::math::DVec2::abs( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "signum", + |_self: Val| { + let output: Val = ::bevy::math::DVec2::signum( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "copysign", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec2::copysign( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_negative_bitmask", + |_self: Val| { + let output: u32 = ::bevy::math::DVec2::is_negative_bitmask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite", + |_self: Val| { + let output: bool = ::bevy::math::DVec2::is_finite(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite_mask", + |_self: Val| { + let output: Val = ::bevy::math::DVec2::is_finite_mask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_nan", + |_self: Val| { + let output: bool = ::bevy::math::DVec2::is_nan(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "is_nan_mask", + |_self: Val| { + let output: Val = ::bevy::math::DVec2::is_nan_mask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "length", + |_self: Val| { + let output: f64 = ::bevy::math::DVec2::length(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "length_squared", + |_self: Val| { + let output: f64 = ::bevy::math::DVec2::length_squared(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "length_recip", + |_self: Val| { + let output: f64 = ::bevy::math::DVec2::length_recip(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "distance", + |_self: Val, rhs: Val| { + let output: f64 = ::bevy::math::DVec2::distance( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "distance_squared", + |_self: Val, rhs: Val| { + let output: f64 = ::bevy::math::DVec2::distance_squared( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec2::div_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec2::rem_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize", + |_self: Val| { + let output: Val = ::bevy::math::DVec2::normalize( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize_or", + |_self: Val, fallback: Val| { + let output: Val = ::bevy::math::DVec2::normalize_or( + _self.into(), + fallback.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize_or_zero", + |_self: Val| { + let output: Val = ::bevy::math::DVec2::normalize_or_zero( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_normalized", + |_self: Val| { + let output: bool = ::bevy::math::DVec2::is_normalized(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "project_onto", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec2::project_onto( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reject_from", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec2::reject_from( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "project_onto_normalized", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec2::project_onto_normalized( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reject_from_normalized", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec2::reject_from_normalized( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "round", + |_self: Val| { + let output: Val = ::bevy::math::DVec2::round( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "floor", + |_self: Val| { + let output: Val = ::bevy::math::DVec2::floor( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "ceil", + |_self: Val| { + let output: Val = ::bevy::math::DVec2::ceil( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "trunc", + |_self: Val| { + let output: Val = ::bevy::math::DVec2::trunc( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "fract", + |_self: Val| { + let output: Val = ::bevy::math::DVec2::fract( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "fract_gl", + |_self: Val| { + let output: Val = ::bevy::math::DVec2::fract_gl( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "exp", + |_self: Val| { + let output: Val = ::bevy::math::DVec2::exp( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "powf", + |_self: Val, n: f64| { + let output: Val = ::bevy::math::DVec2::powf( + _self.into(), + n.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "recip", + |_self: Val| { + let output: Val = ::bevy::math::DVec2::recip( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "lerp", + |_self: Val, rhs: Val, s: f64| { + let output: Val = ::bevy::math::DVec2::lerp( + _self.into(), + rhs.into(), + s.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "move_towards", + |_self: Ref, rhs: Val, d: f64| { + let output: Val = ::bevy::math::DVec2::move_towards( + _self.into(), + rhs.into(), + d.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "midpoint", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec2::midpoint( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs_diff_eq", + | + _self: Val, + rhs: Val, + max_abs_diff: f64| + { + let output: bool = ::bevy::math::DVec2::abs_diff_eq( + _self.into(), + rhs.into(), + max_abs_diff.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp_length", + |_self: Val, min: f64, max: f64| { + let output: Val = ::bevy::math::DVec2::clamp_length( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp_length_max", + |_self: Val, max: f64| { + let output: Val = ::bevy::math::DVec2::clamp_length_max( + _self.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp_length_min", + |_self: Val, min: f64| { + let output: Val = ::bevy::math::DVec2::clamp_length_min( + _self.into(), + min.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_add", + | + _self: Val, + a: Val, + b: Val| + { + let output: Val = ::bevy::math::DVec2::mul_add( + _self.into(), + a.into(), + b.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reflect", + |_self: Val, normal: Val| { + let output: Val = ::bevy::math::DVec2::reflect( + _self.into(), + normal.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "refract", + | + _self: Val, + normal: Val, + eta: f64| + { + let output: Val = ::bevy::math::DVec2::refract( + _self.into(), + normal.into(), + eta.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_angle", + |angle: f64| { + let output: Val = ::bevy::math::DVec2::from_angle( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_angle", + |_self: Val| { + let output: f64 = ::bevy::math::DVec2::to_angle(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "angle_between", + |_self: Val, rhs: Val| { + let output: f64 = ::bevy::math::DVec2::angle_between( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "angle_to", + |_self: Val, rhs: Val| { + let output: f64 = ::bevy::math::DVec2::angle_to( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "perp", + |_self: Val| { + let output: Val = ::bevy::math::DVec2::perp( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "perp_dot", + |_self: Val, rhs: Val| { + let output: f64 = ::bevy::math::DVec2::perp_dot( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rotate", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec2::rotate( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rotate_towards", + | + _self: Ref, + rhs: Val, + max_angle: f64| + { + let output: Val = ::bevy::math::DVec2::rotate_towards( + _self.into(), + rhs.into(), + max_angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_vec2", + |_self: Ref| { + let output: Val = ::bevy::math::DVec2::as_vec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_ivec2", + |_self: Ref| { + let output: Val = ::bevy::math::DVec2::as_ivec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_uvec2", + |_self: Ref| { + let output: Val = ::bevy::math::DVec2::as_uvec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_i64vec2", + |_self: Ref| { + let output: Val = ::bevy::math::DVec2::as_i64vec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_u64vec2", + |_self: Ref| { + let output: Val = ::bevy::math::DVec2::as_u64vec2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec2::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::DVec2::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::DVec2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec2::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::math::DVec2::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::DVec2::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::math::DVec2::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::DVec2::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::DVec2::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec2::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::DVec2::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::math::DVec2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::DVec2::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::DVec2::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::math::DVec2::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::DVec3>::new(world) + .overwrite_script_function( + "div", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::math::DVec3::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::math::DVec3::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::math::DVec3::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec3::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::DVec3::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::DVec3::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::math::DVec3::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec3::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::DVec3::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::DVec3::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::DVec3::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::DVec3::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec3::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x: f64, y: f64, z: f64| { + let output: Val = ::bevy::math::DVec3::new( + x.into(), + y.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: f64| { + let output: Val = ::bevy::math::DVec3::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = ::bevy::math::DVec3::select( + mask.into(), + if_true.into(), + if_false.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [f64; 3]| { + let output: Val = ::bevy::math::DVec3::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_array", + |_self: Ref| { + let output: [f64; 3] = ::bevy::math::DVec3::to_array(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "extend", + |_self: Val, w: f64| { + let output: Val = ::bevy::math::DVec3::extend( + _self.into(), + w.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "truncate", + |_self: Val| { + let output: Val = ::bevy::math::DVec3::truncate( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_x", + |_self: Val, x: f64| { + let output: Val = ::bevy::math::DVec3::with_x( + _self.into(), + x.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_y", + |_self: Val, y: f64| { + let output: Val = ::bevy::math::DVec3::with_y( + _self.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_z", + |_self: Val, z: f64| { + let output: Val = ::bevy::math::DVec3::with_z( + _self.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot", + |_self: Val, rhs: Val| { + let output: f64 = ::bevy::math::DVec3::dot(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec3::dot_into_vec( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cross", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec3::cross( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec3::min( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "max", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec3::max( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = ::bevy::math::DVec3::clamp( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min_element", + |_self: Val| { + let output: f64 = ::bevy::math::DVec3::min_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "max_element", + |_self: Val| { + let output: f64 = ::bevy::math::DVec3::max_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_sum", + |_self: Val| { + let output: f64 = ::bevy::math::DVec3::element_sum(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_product", + |_self: Val| { + let output: f64 = ::bevy::math::DVec3::element_product(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec3::cmpeq( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec3::cmpne( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec3::cmpge( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpgt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec3::cmpgt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmple", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec3::cmple( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec3::cmplt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs", + |_self: Val| { + let output: Val = ::bevy::math::DVec3::abs( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "signum", + |_self: Val| { + let output: Val = ::bevy::math::DVec3::signum( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "copysign", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec3::copysign( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_negative_bitmask", + |_self: Val| { + let output: u32 = ::bevy::math::DVec3::is_negative_bitmask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite", + |_self: Val| { + let output: bool = ::bevy::math::DVec3::is_finite(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite_mask", + |_self: Val| { + let output: Val = ::bevy::math::DVec3::is_finite_mask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_nan", + |_self: Val| { + let output: bool = ::bevy::math::DVec3::is_nan(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "is_nan_mask", + |_self: Val| { + let output: Val = ::bevy::math::DVec3::is_nan_mask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "length", + |_self: Val| { + let output: f64 = ::bevy::math::DVec3::length(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "length_squared", + |_self: Val| { + let output: f64 = ::bevy::math::DVec3::length_squared(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "length_recip", + |_self: Val| { + let output: f64 = ::bevy::math::DVec3::length_recip(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "distance", + |_self: Val, rhs: Val| { + let output: f64 = ::bevy::math::DVec3::distance( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "distance_squared", + |_self: Val, rhs: Val| { + let output: f64 = ::bevy::math::DVec3::distance_squared( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec3::div_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec3::rem_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize", + |_self: Val| { + let output: Val = ::bevy::math::DVec3::normalize( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize_or", + |_self: Val, fallback: Val| { + let output: Val = ::bevy::math::DVec3::normalize_or( + _self.into(), + fallback.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize_or_zero", + |_self: Val| { + let output: Val = ::bevy::math::DVec3::normalize_or_zero( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_normalized", + |_self: Val| { + let output: bool = ::bevy::math::DVec3::is_normalized(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "project_onto", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec3::project_onto( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reject_from", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec3::reject_from( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "project_onto_normalized", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec3::project_onto_normalized( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reject_from_normalized", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec3::reject_from_normalized( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "round", + |_self: Val| { + let output: Val = ::bevy::math::DVec3::round( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "floor", + |_self: Val| { + let output: Val = ::bevy::math::DVec3::floor( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "ceil", + |_self: Val| { + let output: Val = ::bevy::math::DVec3::ceil( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "trunc", + |_self: Val| { + let output: Val = ::bevy::math::DVec3::trunc( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "fract", + |_self: Val| { + let output: Val = ::bevy::math::DVec3::fract( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "fract_gl", + |_self: Val| { + let output: Val = ::bevy::math::DVec3::fract_gl( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "exp", + |_self: Val| { + let output: Val = ::bevy::math::DVec3::exp( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "powf", + |_self: Val, n: f64| { + let output: Val = ::bevy::math::DVec3::powf( + _self.into(), + n.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "recip", + |_self: Val| { + let output: Val = ::bevy::math::DVec3::recip( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "lerp", + |_self: Val, rhs: Val, s: f64| { + let output: Val = ::bevy::math::DVec3::lerp( + _self.into(), + rhs.into(), + s.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "move_towards", + |_self: Ref, rhs: Val, d: f64| { + let output: Val = ::bevy::math::DVec3::move_towards( + _self.into(), + rhs.into(), + d.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "midpoint", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec3::midpoint( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs_diff_eq", + | + _self: Val, + rhs: Val, + max_abs_diff: f64| + { + let output: bool = ::bevy::math::DVec3::abs_diff_eq( + _self.into(), + rhs.into(), + max_abs_diff.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp_length", + |_self: Val, min: f64, max: f64| { + let output: Val = ::bevy::math::DVec3::clamp_length( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp_length_max", + |_self: Val, max: f64| { + let output: Val = ::bevy::math::DVec3::clamp_length_max( + _self.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp_length_min", + |_self: Val, min: f64| { + let output: Val = ::bevy::math::DVec3::clamp_length_min( + _self.into(), + min.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_add", + | + _self: Val, + a: Val, + b: Val| + { + let output: Val = ::bevy::math::DVec3::mul_add( + _self.into(), + a.into(), + b.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reflect", + |_self: Val, normal: Val| { + let output: Val = ::bevy::math::DVec3::reflect( + _self.into(), + normal.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "refract", + | + _self: Val, + normal: Val, + eta: f64| + { + let output: Val = ::bevy::math::DVec3::refract( + _self.into(), + normal.into(), + eta.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "angle_between", + |_self: Val, rhs: Val| { + let output: f64 = ::bevy::math::DVec3::angle_between( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "any_orthogonal_vector", + |_self: Ref| { + let output: Val = ::bevy::math::DVec3::any_orthogonal_vector( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "any_orthonormal_vector", + |_self: Ref| { + let output: Val = ::bevy::math::DVec3::any_orthonormal_vector( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_vec3", + |_self: Ref| { + let output: Val = ::bevy::math::DVec3::as_vec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_vec3a", + |_self: Ref| { + let output: Val = ::bevy::math::DVec3::as_vec3a( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_ivec3", + |_self: Ref| { + let output: Val = ::bevy::math::DVec3::as_ivec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_uvec3", + |_self: Ref| { + let output: Val = ::bevy::math::DVec3::as_uvec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_i64vec3", + |_self: Ref| { + let output: Val = ::bevy::math::DVec3::as_i64vec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_u64vec3", + |_self: Ref| { + let output: Val = ::bevy::math::DVec3::as_u64vec3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::math::DVec3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::DVec3::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::DVec3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec3::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::DVec4>::new(world) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::DVec4::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::DVec4::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::DVec4::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "new", + |x: f64, y: f64, z: f64, w: f64| { + let output: Val = ::bevy::math::DVec4::new( + x.into(), + y.into(), + z.into(), + w.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: f64| { + let output: Val = ::bevy::math::DVec4::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "select", + | + mask: Val, + if_true: Val, + if_false: Val| + { + let output: Val = ::bevy::math::DVec4::select( + mask.into(), + if_true.into(), + if_false.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [f64; 4]| { + let output: Val = ::bevy::math::DVec4::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_array", + |_self: Ref| { + let output: [f64; 4] = ::bevy::math::DVec4::to_array(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "truncate", + |_self: Val| { + let output: Val = ::bevy::math::DVec4::truncate( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_x", + |_self: Val, x: f64| { + let output: Val = ::bevy::math::DVec4::with_x( + _self.into(), + x.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_y", + |_self: Val, y: f64| { + let output: Val = ::bevy::math::DVec4::with_y( + _self.into(), + y.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_z", + |_self: Val, z: f64| { + let output: Val = ::bevy::math::DVec4::with_z( + _self.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "with_w", + |_self: Val, w: f64| { + let output: Val = ::bevy::math::DVec4::with_w( + _self.into(), + w.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot", + |_self: Val, rhs: Val| { + let output: f64 = ::bevy::math::DVec4::dot(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "dot_into_vec", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec4::dot_into_vec( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec4::min( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "max", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec4::max( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp", + | + _self: Val, + min: Val, + max: Val| + { + let output: Val = ::bevy::math::DVec4::clamp( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "min_element", + |_self: Val| { + let output: f64 = ::bevy::math::DVec4::min_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "max_element", + |_self: Val| { + let output: f64 = ::bevy::math::DVec4::max_element(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_sum", + |_self: Val| { + let output: f64 = ::bevy::math::DVec4::element_sum(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "element_product", + |_self: Val| { + let output: f64 = ::bevy::math::DVec4::element_product(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpeq", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec4::cmpeq( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpne", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec4::cmpne( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpge", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec4::cmpge( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmpgt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec4::cmpgt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmple", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec4::cmple( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "cmplt", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec4::cmplt( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs", + |_self: Val| { + let output: Val = ::bevy::math::DVec4::abs( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "signum", + |_self: Val| { + let output: Val = ::bevy::math::DVec4::signum( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "copysign", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec4::copysign( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_negative_bitmask", + |_self: Val| { + let output: u32 = ::bevy::math::DVec4::is_negative_bitmask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite", + |_self: Val| { + let output: bool = ::bevy::math::DVec4::is_finite(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite_mask", + |_self: Val| { + let output: Val = ::bevy::math::DVec4::is_finite_mask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_nan", + |_self: Val| { + let output: bool = ::bevy::math::DVec4::is_nan(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "is_nan_mask", + |_self: Val| { + let output: Val = ::bevy::math::DVec4::is_nan_mask( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "length", + |_self: Val| { + let output: f64 = ::bevy::math::DVec4::length(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "length_squared", + |_self: Val| { + let output: f64 = ::bevy::math::DVec4::length_squared(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "length_recip", + |_self: Val| { + let output: f64 = ::bevy::math::DVec4::length_recip(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "distance", + |_self: Val, rhs: Val| { + let output: f64 = ::bevy::math::DVec4::distance( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "distance_squared", + |_self: Val, rhs: Val| { + let output: f64 = ::bevy::math::DVec4::distance_squared( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec4::div_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem_euclid", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec4::rem_euclid( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize", + |_self: Val| { + let output: Val = ::bevy::math::DVec4::normalize( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize_or", + |_self: Val, fallback: Val| { + let output: Val = ::bevy::math::DVec4::normalize_or( + _self.into(), + fallback.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize_or_zero", + |_self: Val| { + let output: Val = ::bevy::math::DVec4::normalize_or_zero( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_normalized", + |_self: Val| { + let output: bool = ::bevy::math::DVec4::is_normalized(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "project_onto", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec4::project_onto( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reject_from", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec4::reject_from( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "project_onto_normalized", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec4::project_onto_normalized( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reject_from_normalized", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec4::reject_from_normalized( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "round", + |_self: Val| { + let output: Val = ::bevy::math::DVec4::round( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "floor", + |_self: Val| { + let output: Val = ::bevy::math::DVec4::floor( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "ceil", + |_self: Val| { + let output: Val = ::bevy::math::DVec4::ceil( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "trunc", + |_self: Val| { + let output: Val = ::bevy::math::DVec4::trunc( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "fract", + |_self: Val| { + let output: Val = ::bevy::math::DVec4::fract( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "fract_gl", + |_self: Val| { + let output: Val = ::bevy::math::DVec4::fract_gl( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "exp", + |_self: Val| { + let output: Val = ::bevy::math::DVec4::exp( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "powf", + |_self: Val, n: f64| { + let output: Val = ::bevy::math::DVec4::powf( + _self.into(), + n.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "recip", + |_self: Val| { + let output: Val = ::bevy::math::DVec4::recip( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "lerp", + |_self: Val, rhs: Val, s: f64| { + let output: Val = ::bevy::math::DVec4::lerp( + _self.into(), + rhs.into(), + s.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "move_towards", + |_self: Ref, rhs: Val, d: f64| { + let output: Val = ::bevy::math::DVec4::move_towards( + _self.into(), + rhs.into(), + d.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "midpoint", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec4::midpoint( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs_diff_eq", + | + _self: Val, + rhs: Val, + max_abs_diff: f64| + { + let output: bool = ::bevy::math::DVec4::abs_diff_eq( + _self.into(), + rhs.into(), + max_abs_diff.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp_length", + |_self: Val, min: f64, max: f64| { + let output: Val = ::bevy::math::DVec4::clamp_length( + _self.into(), + min.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp_length_max", + |_self: Val, max: f64| { + let output: Val = ::bevy::math::DVec4::clamp_length_max( + _self.into(), + max.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clamp_length_min", + |_self: Val, min: f64| { + let output: Val = ::bevy::math::DVec4::clamp_length_min( + _self.into(), + min.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_add", + | + _self: Val, + a: Val, + b: Val| + { + let output: Val = ::bevy::math::DVec4::mul_add( + _self.into(), + a.into(), + b.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reflect", + |_self: Val, normal: Val| { + let output: Val = ::bevy::math::DVec4::reflect( + _self.into(), + normal.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "refract", + | + _self: Val, + normal: Val, + eta: f64| + { + let output: Val = ::bevy::math::DVec4::refract( + _self.into(), + normal.into(), + eta.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_vec4", + |_self: Ref| { + let output: Val = ::bevy::math::DVec4::as_vec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_ivec4", + |_self: Ref| { + let output: Val = ::bevy::math::DVec4::as_ivec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_uvec4", + |_self: Ref| { + let output: Val = ::bevy::math::DVec4::as_uvec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_i64vec4", + |_self: Ref| { + let output: Val = ::bevy::math::DVec4::as_i64vec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_u64vec4", + |_self: Ref| { + let output: Val = ::bevy::math::DVec4::as_u64vec4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::DVec4::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::math::DVec4::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::DVec4::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::DVec4::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::DVec4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::math::DVec4::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec4::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec4::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::math::DVec4::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::math::DVec4::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec4::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rem", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DVec4::rem( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: Ref| { + let output: Val = ::bevy::math::DVec4::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::math::DVec4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::Mat2>::new(world) + .overwrite_script_function( + "div", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Mat2::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = ::bevy::math::Mat2::eq(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::Mat2::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::Mat2::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_cols", + |x_axis: Val, y_axis: Val| { + let output: Val = ::bevy::math::Mat2::from_cols( + x_axis.into(), + y_axis.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_cols_array", + |_self: Ref| { + let output: [f32; 4] = ::bevy::math::Mat2::to_cols_array( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_cols_array_2d", + |_self: Ref| { + let output: [[f32; 2]; 2] = ::bevy::math::Mat2::to_cols_array_2d( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_diagonal", + |diagonal: Val| { + let output: Val = ::bevy::math::Mat2::from_diagonal( + diagonal.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_scale_angle", + |scale: Val, angle: f32| { + let output: Val = ::bevy::math::Mat2::from_scale_angle( + scale.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_angle", + |angle: f32| { + let output: Val = ::bevy::math::Mat2::from_angle( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat3", + |m: Val| { + let output: Val = ::bevy::math::Mat2::from_mat3( + m.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat3_minor", + |m: Val, i: usize, j: usize| { + let output: Val = ::bevy::math::Mat2::from_mat3_minor( + m.into(), + i.into(), + j.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat3a", + |m: Val| { + let output: Val = ::bevy::math::Mat2::from_mat3a( + m.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat3a_minor", + |m: Val, i: usize, j: usize| { + let output: Val = ::bevy::math::Mat2::from_mat3a_minor( + m.into(), + i.into(), + j.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "col", + |_self: Ref, index: usize| { + let output: Val = ::bevy::math::Mat2::col( + _self.into(), + index.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "row", + |_self: Ref, index: usize| { + let output: Val = ::bevy::math::Mat2::row( + _self.into(), + index.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite", + |_self: Ref| { + let output: bool = ::bevy::math::Mat2::is_finite(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_nan", + |_self: Ref| { + let output: bool = ::bevy::math::Mat2::is_nan(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "transpose", + |_self: Ref| { + let output: Val = ::bevy::math::Mat2::transpose( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "determinant", + |_self: Ref| { + let output: f32 = ::bevy::math::Mat2::determinant(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "inverse", + |_self: Ref| { + let output: Val = ::bevy::math::Mat2::inverse( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_vec2", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Mat2::mul_vec2( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_mat2", + |_self: Ref, rhs: Ref| { + let output: Val = ::bevy::math::Mat2::mul_mat2( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add_mat2", + |_self: Ref, rhs: Ref| { + let output: Val = ::bevy::math::Mat2::add_mat2( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub_mat2", + |_self: Ref, rhs: Ref| { + let output: Val = ::bevy::math::Mat2::sub_mat2( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_scalar", + |_self: Ref, rhs: f32| { + let output: Val = ::bevy::math::Mat2::mul_scalar( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_scalar", + |_self: Ref, rhs: f32| { + let output: Val = ::bevy::math::Mat2::div_scalar( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs_diff_eq", + | + _self: Ref, + rhs: Val, + max_abs_diff: f32| + { + let output: bool = ::bevy::math::Mat2::abs_diff_eq( + _self.into(), + rhs.into(), + max_abs_diff.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs", + |_self: Ref| { + let output: Val = ::bevy::math::Mat2::abs( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_dmat2", + |_self: Ref| { + let output: Val = ::bevy::math::Mat2::as_dmat2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Mat2::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Mat2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Mat2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Mat2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Mat2::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::Mat3>::new(world) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Mat3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Mat3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Mat3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Mat3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::Mat3::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Mat3::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::Mat3::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_cols", + | + x_axis: Val, + y_axis: Val, + z_axis: Val| + { + let output: Val = ::bevy::math::Mat3::from_cols( + x_axis.into(), + y_axis.into(), + z_axis.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_cols_array", + |_self: Ref| { + let output: [f32; 9] = ::bevy::math::Mat3::to_cols_array( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_cols_array_2d", + |_self: Ref| { + let output: [[f32; 3]; 3] = ::bevy::math::Mat3::to_cols_array_2d( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_diagonal", + |diagonal: Val| { + let output: Val = ::bevy::math::Mat3::from_diagonal( + diagonal.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat4", + |m: Val| { + let output: Val = ::bevy::math::Mat3::from_mat4( + m.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat4_minor", + |m: Val, i: usize, j: usize| { + let output: Val = ::bevy::math::Mat3::from_mat4_minor( + m.into(), + i.into(), + j.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_quat", + |rotation: Val| { + let output: Val = ::bevy::math::Mat3::from_quat( + rotation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_axis_angle", + |axis: Val, angle: f32| { + let output: Val = ::bevy::math::Mat3::from_axis_angle( + axis.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_euler", + |order: Val, a: f32, b: f32, c: f32| { + let output: Val = ::bevy::math::Mat3::from_euler( + order.into(), + a.into(), + b.into(), + c.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_euler", + |_self: Ref, order: Val| { + let output: (f32, f32, f32) = ::bevy::math::Mat3::to_euler( + _self.into(), + order.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_x", + |angle: f32| { + let output: Val = ::bevy::math::Mat3::from_rotation_x( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_y", + |angle: f32| { + let output: Val = ::bevy::math::Mat3::from_rotation_y( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_z", + |angle: f32| { + let output: Val = ::bevy::math::Mat3::from_rotation_z( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_translation", + |translation: Val| { + let output: Val = ::bevy::math::Mat3::from_translation( + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_angle", + |angle: f32| { + let output: Val = ::bevy::math::Mat3::from_angle( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_scale_angle_translation", + | + scale: Val, + angle: f32, + translation: Val| + { + let output: Val = ::bevy::math::Mat3::from_scale_angle_translation( + scale.into(), + angle.into(), + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_scale", + |scale: Val| { + let output: Val = ::bevy::math::Mat3::from_scale( + scale.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat2", + |m: Val| { + let output: Val = ::bevy::math::Mat3::from_mat2( + m.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "col", + |_self: Ref, index: usize| { + let output: Val = ::bevy::math::Mat3::col( + _self.into(), + index.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "row", + |_self: Ref, index: usize| { + let output: Val = ::bevy::math::Mat3::row( + _self.into(), + index.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite", + |_self: Ref| { + let output: bool = ::bevy::math::Mat3::is_finite(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_nan", + |_self: Ref| { + let output: bool = ::bevy::math::Mat3::is_nan(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "transpose", + |_self: Ref| { + let output: Val = ::bevy::math::Mat3::transpose( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "determinant", + |_self: Ref| { + let output: f32 = ::bevy::math::Mat3::determinant(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "inverse", + |_self: Ref| { + let output: Val = ::bevy::math::Mat3::inverse( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "transform_point2", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Mat3::transform_point2( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "transform_vector2", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Mat3::transform_vector2( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_vec3", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Mat3::mul_vec3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_vec3a", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Mat3::mul_vec3a( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_mat3", + |_self: Ref, rhs: Ref| { + let output: Val = ::bevy::math::Mat3::mul_mat3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add_mat3", + |_self: Ref, rhs: Ref| { + let output: Val = ::bevy::math::Mat3::add_mat3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub_mat3", + |_self: Ref, rhs: Ref| { + let output: Val = ::bevy::math::Mat3::sub_mat3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_scalar", + |_self: Ref, rhs: f32| { + let output: Val = ::bevy::math::Mat3::mul_scalar( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_scalar", + |_self: Ref, rhs: f32| { + let output: Val = ::bevy::math::Mat3::div_scalar( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs_diff_eq", + | + _self: Ref, + rhs: Val, + max_abs_diff: f32| + { + let output: bool = ::bevy::math::Mat3::abs_diff_eq( + _self.into(), + rhs.into(), + max_abs_diff.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs", + |_self: Ref| { + let output: Val = ::bevy::math::Mat3::abs( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_dmat3", + |_self: Ref| { + let output: Val = ::bevy::math::Mat3::as_dmat3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Mat3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = ::bevy::math::Mat3::eq(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Mat3::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Mat3::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::Mat3A>::new(world) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Mat3A::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::Mat3A::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Mat3A::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::Mat3A::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Mat3A::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Mat3A::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = ::bevy::math::Mat3A::eq(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Mat3A::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Mat3A::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Mat3A::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Mat3A::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_cols", + | + x_axis: Val, + y_axis: Val, + z_axis: Val| + { + let output: Val = ::bevy::math::Mat3A::from_cols( + x_axis.into(), + y_axis.into(), + z_axis.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_cols_array", + |_self: Ref| { + let output: [f32; 9] = ::bevy::math::Mat3A::to_cols_array( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_cols_array_2d", + |_self: Ref| { + let output: [[f32; 3]; 3] = ::bevy::math::Mat3A::to_cols_array_2d( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_diagonal", + |diagonal: Val| { + let output: Val = ::bevy::math::Mat3A::from_diagonal( + diagonal.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat4", + |m: Val| { + let output: Val = ::bevy::math::Mat3A::from_mat4( + m.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat4_minor", + |m: Val, i: usize, j: usize| { + let output: Val = ::bevy::math::Mat3A::from_mat4_minor( + m.into(), + i.into(), + j.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_quat", + |rotation: Val| { + let output: Val = ::bevy::math::Mat3A::from_quat( + rotation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_axis_angle", + |axis: Val, angle: f32| { + let output: Val = ::bevy::math::Mat3A::from_axis_angle( + axis.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_euler", + |order: Val, a: f32, b: f32, c: f32| { + let output: Val = ::bevy::math::Mat3A::from_euler( + order.into(), + a.into(), + b.into(), + c.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_euler", + |_self: Ref, order: Val| { + let output: (f32, f32, f32) = ::bevy::math::Mat3A::to_euler( + _self.into(), + order.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_x", + |angle: f32| { + let output: Val = ::bevy::math::Mat3A::from_rotation_x( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_y", + |angle: f32| { + let output: Val = ::bevy::math::Mat3A::from_rotation_y( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_z", + |angle: f32| { + let output: Val = ::bevy::math::Mat3A::from_rotation_z( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_translation", + |translation: Val| { + let output: Val = ::bevy::math::Mat3A::from_translation( + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_angle", + |angle: f32| { + let output: Val = ::bevy::math::Mat3A::from_angle( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_scale_angle_translation", + | + scale: Val, + angle: f32, + translation: Val| + { + let output: Val = ::bevy::math::Mat3A::from_scale_angle_translation( + scale.into(), + angle.into(), + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_scale", + |scale: Val| { + let output: Val = ::bevy::math::Mat3A::from_scale( + scale.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat2", + |m: Val| { + let output: Val = ::bevy::math::Mat3A::from_mat2( + m.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "col", + |_self: Ref, index: usize| { + let output: Val = ::bevy::math::Mat3A::col( + _self.into(), + index.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "row", + |_self: Ref, index: usize| { + let output: Val = ::bevy::math::Mat3A::row( + _self.into(), + index.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite", + |_self: Ref| { + let output: bool = ::bevy::math::Mat3A::is_finite(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_nan", + |_self: Ref| { + let output: bool = ::bevy::math::Mat3A::is_nan(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "transpose", + |_self: Ref| { + let output: Val = ::bevy::math::Mat3A::transpose( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "determinant", + |_self: Ref| { + let output: f32 = ::bevy::math::Mat3A::determinant(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "inverse", + |_self: Ref| { + let output: Val = ::bevy::math::Mat3A::inverse( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "transform_point2", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Mat3A::transform_point2( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "transform_vector2", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Mat3A::transform_vector2( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_vec3", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Mat3A::mul_vec3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_vec3a", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Mat3A::mul_vec3a( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_mat3", + |_self: Ref, rhs: Ref| { + let output: Val = ::bevy::math::Mat3A::mul_mat3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add_mat3", + |_self: Ref, rhs: Ref| { + let output: Val = ::bevy::math::Mat3A::add_mat3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub_mat3", + |_self: Ref, rhs: Ref| { + let output: Val = ::bevy::math::Mat3A::sub_mat3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_scalar", + |_self: Ref, rhs: f32| { + let output: Val = ::bevy::math::Mat3A::mul_scalar( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_scalar", + |_self: Ref, rhs: f32| { + let output: Val = ::bevy::math::Mat3A::div_scalar( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs_diff_eq", + | + _self: Ref, + rhs: Val, + max_abs_diff: f32| + { + let output: bool = ::bevy::math::Mat3A::abs_diff_eq( + _self.into(), + rhs.into(), + max_abs_diff.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs", + |_self: Ref| { + let output: Val = ::bevy::math::Mat3A::abs( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_dmat3", + |_self: Ref| { + let output: Val = ::bevy::math::Mat3A::as_dmat3( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::Mat4>::new(world) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::Mat4::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::Mat4::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Mat4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Mat4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Mat4::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Mat4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = ::bevy::math::Mat4::eq(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Mat4::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: f32| { + let output: Val = ::bevy::math::Mat4::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_cols", + | + x_axis: Val, + y_axis: Val, + z_axis: Val, + w_axis: Val| + { + let output: Val = ::bevy::math::Mat4::from_cols( + x_axis.into(), + y_axis.into(), + z_axis.into(), + w_axis.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_cols_array", + |_self: Ref| { + let output: [f32; 16] = ::bevy::math::Mat4::to_cols_array( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_cols_array_2d", + |_self: Ref| { + let output: [[f32; 4]; 4] = ::bevy::math::Mat4::to_cols_array_2d( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_diagonal", + |diagonal: Val| { + let output: Val = ::bevy::math::Mat4::from_diagonal( + diagonal.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_scale_rotation_translation", + | + scale: Val, + rotation: Val, + translation: Val| + { + let output: Val = ::bevy::math::Mat4::from_scale_rotation_translation( + scale.into(), + rotation.into(), + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_translation", + |rotation: Val, translation: Val| { + let output: Val = ::bevy::math::Mat4::from_rotation_translation( + rotation.into(), + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_quat", + |rotation: Val| { + let output: Val = ::bevy::math::Mat4::from_quat( + rotation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat3", + |m: Val| { + let output: Val = ::bevy::math::Mat4::from_mat3( + m.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat3a", + |m: Val| { + let output: Val = ::bevy::math::Mat4::from_mat3a( + m.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_translation", + |translation: Val| { + let output: Val = ::bevy::math::Mat4::from_translation( + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_axis_angle", + |axis: Val, angle: f32| { + let output: Val = ::bevy::math::Mat4::from_axis_angle( + axis.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_euler", + |order: Val, a: f32, b: f32, c: f32| { + let output: Val = ::bevy::math::Mat4::from_euler( + order.into(), + a.into(), + b.into(), + c.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_euler", + |_self: Ref, order: Val| { + let output: (f32, f32, f32) = ::bevy::math::Mat4::to_euler( + _self.into(), + order.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_x", + |angle: f32| { + let output: Val = ::bevy::math::Mat4::from_rotation_x( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_y", + |angle: f32| { + let output: Val = ::bevy::math::Mat4::from_rotation_y( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_z", + |angle: f32| { + let output: Val = ::bevy::math::Mat4::from_rotation_z( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_scale", + |scale: Val| { + let output: Val = ::bevy::math::Mat4::from_scale( + scale.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "col", + |_self: Ref, index: usize| { + let output: Val = ::bevy::math::Mat4::col( + _self.into(), + index.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "row", + |_self: Ref, index: usize| { + let output: Val = ::bevy::math::Mat4::row( + _self.into(), + index.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite", + |_self: Ref| { + let output: bool = ::bevy::math::Mat4::is_finite(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_nan", + |_self: Ref| { + let output: bool = ::bevy::math::Mat4::is_nan(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "transpose", + |_self: Ref| { + let output: Val = ::bevy::math::Mat4::transpose( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "determinant", + |_self: Ref| { + let output: f32 = ::bevy::math::Mat4::determinant(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "inverse", + |_self: Ref| { + let output: Val = ::bevy::math::Mat4::inverse( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "look_to_lh", + | + eye: Val, + dir: Val, + up: Val| + { + let output: Val = ::bevy::math::Mat4::look_to_lh( + eye.into(), + dir.into(), + up.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "look_to_rh", + | + eye: Val, + dir: Val, + up: Val| + { + let output: Val = ::bevy::math::Mat4::look_to_rh( + eye.into(), + dir.into(), + up.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "look_at_lh", + | + eye: Val, + center: Val, + up: Val| + { + let output: Val = ::bevy::math::Mat4::look_at_lh( + eye.into(), + center.into(), + up.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "look_at_rh", + | + eye: Val, + center: Val, + up: Val| + { + let output: Val = ::bevy::math::Mat4::look_at_rh( + eye.into(), + center.into(), + up.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "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.into(), + aspect_ratio.into(), + z_near.into(), + z_far.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "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.into(), + aspect_ratio.into(), + z_near.into(), + z_far.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "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.into(), + aspect_ratio.into(), + z_near.into(), + z_far.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "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.into(), + aspect_ratio.into(), + z_near.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "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.into(), + aspect_ratio.into(), + z_near.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "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.into(), + aspect_ratio.into(), + z_near.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "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.into(), + aspect_ratio.into(), + z_near.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "orthographic_rh_gl", + |left: f32, right: f32, bottom: f32, top: f32, near: f32, far: f32| { + let output: Val = ::bevy::math::Mat4::orthographic_rh_gl( + left.into(), + right.into(), + bottom.into(), + top.into(), + near.into(), + far.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "orthographic_lh", + |left: f32, right: f32, bottom: f32, top: f32, near: f32, far: f32| { + let output: Val = ::bevy::math::Mat4::orthographic_lh( + left.into(), + right.into(), + bottom.into(), + top.into(), + near.into(), + far.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "orthographic_rh", + |left: f32, right: f32, bottom: f32, top: f32, near: f32, far: f32| { + let output: Val = ::bevy::math::Mat4::orthographic_rh( + left.into(), + right.into(), + bottom.into(), + top.into(), + near.into(), + far.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "project_point3", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Mat4::project_point3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "transform_point3", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Mat4::transform_point3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "transform_vector3", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Mat4::transform_vector3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "project_point3a", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Mat4::project_point3a( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "transform_point3a", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Mat4::transform_point3a( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "transform_vector3a", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Mat4::transform_vector3a( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_vec4", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Mat4::mul_vec4( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_mat4", + |_self: Ref, rhs: Ref| { + let output: Val = ::bevy::math::Mat4::mul_mat4( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add_mat4", + |_self: Ref, rhs: Ref| { + let output: Val = ::bevy::math::Mat4::add_mat4( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub_mat4", + |_self: Ref, rhs: Ref| { + let output: Val = ::bevy::math::Mat4::sub_mat4( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_scalar", + |_self: Ref, rhs: f32| { + let output: Val = ::bevy::math::Mat4::mul_scalar( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_scalar", + |_self: Ref, rhs: f32| { + let output: Val = ::bevy::math::Mat4::div_scalar( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs_diff_eq", + | + _self: Ref, + rhs: Val, + max_abs_diff: f32| + { + let output: bool = ::bevy::math::Mat4::abs_diff_eq( + _self.into(), + rhs.into(), + max_abs_diff.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs", + |_self: Ref| { + let output: Val = ::bevy::math::Mat4::abs( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_dmat4", + |_self: Ref| { + let output: Val = ::bevy::math::Mat4::as_dmat4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Mat4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::DMat2>::new(world) + .overwrite_script_function( + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = ::bevy::math::DMat2::eq(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::DMat2::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DMat2::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DMat2::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DMat2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::DMat2::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DMat2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_cols", + |x_axis: Val, y_axis: Val| { + let output: Val = ::bevy::math::DMat2::from_cols( + x_axis.into(), + y_axis.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_cols_array", + |_self: Ref| { + let output: [f64; 4] = ::bevy::math::DMat2::to_cols_array( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_cols_array_2d", + |_self: Ref| { + let output: [[f64; 2]; 2] = ::bevy::math::DMat2::to_cols_array_2d( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_diagonal", + |diagonal: Val| { + let output: Val = ::bevy::math::DMat2::from_diagonal( + diagonal.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_scale_angle", + |scale: Val, angle: f64| { + let output: Val = ::bevy::math::DMat2::from_scale_angle( + scale.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_angle", + |angle: f64| { + let output: Val = ::bevy::math::DMat2::from_angle( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat3", + |m: Val| { + let output: Val = ::bevy::math::DMat2::from_mat3( + m.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat3_minor", + |m: Val, i: usize, j: usize| { + let output: Val = ::bevy::math::DMat2::from_mat3_minor( + m.into(), + i.into(), + j.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "col", + |_self: Ref, index: usize| { + let output: Val = ::bevy::math::DMat2::col( + _self.into(), + index.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "row", + |_self: Ref, index: usize| { + let output: Val = ::bevy::math::DMat2::row( + _self.into(), + index.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite", + |_self: Ref| { + let output: bool = ::bevy::math::DMat2::is_finite(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_nan", + |_self: Ref| { + let output: bool = ::bevy::math::DMat2::is_nan(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "transpose", + |_self: Ref| { + let output: Val = ::bevy::math::DMat2::transpose( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "determinant", + |_self: Ref| { + let output: f64 = ::bevy::math::DMat2::determinant(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "inverse", + |_self: Ref| { + let output: Val = ::bevy::math::DMat2::inverse( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_vec2", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::DMat2::mul_vec2( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_mat2", + |_self: Ref, rhs: Ref| { + let output: Val = ::bevy::math::DMat2::mul_mat2( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add_mat2", + |_self: Ref, rhs: Ref| { + let output: Val = ::bevy::math::DMat2::add_mat2( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub_mat2", + |_self: Ref, rhs: Ref| { + let output: Val = ::bevy::math::DMat2::sub_mat2( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_scalar", + |_self: Ref, rhs: f64| { + let output: Val = ::bevy::math::DMat2::mul_scalar( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_scalar", + |_self: Ref, rhs: f64| { + let output: Val = ::bevy::math::DMat2::div_scalar( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs_diff_eq", + | + _self: Ref, + rhs: Val, + max_abs_diff: f64| + { + let output: bool = ::bevy::math::DMat2::abs_diff_eq( + _self.into(), + rhs.into(), + max_abs_diff.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs", + |_self: Ref| { + let output: Val = ::bevy::math::DMat2::abs( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_mat2", + |_self: Ref| { + let output: Val = ::bevy::math::DMat2::as_mat2( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::math::DMat2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::math::DMat2::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::DMat3>::new(world) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DMat3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DMat3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DMat3::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_cols", + | + x_axis: Val, + y_axis: Val, + z_axis: Val| + { + let output: Val = ::bevy::math::DMat3::from_cols( + x_axis.into(), + y_axis.into(), + z_axis.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_cols_array", + |_self: Ref| { + let output: [f64; 9] = ::bevy::math::DMat3::to_cols_array( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_cols_array_2d", + |_self: Ref| { + let output: [[f64; 3]; 3] = ::bevy::math::DMat3::to_cols_array_2d( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_diagonal", + |diagonal: Val| { + let output: Val = ::bevy::math::DMat3::from_diagonal( + diagonal.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat4", + |m: Val| { + let output: Val = ::bevy::math::DMat3::from_mat4( + m.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat4_minor", + |m: Val, i: usize, j: usize| { + let output: Val = ::bevy::math::DMat3::from_mat4_minor( + m.into(), + i.into(), + j.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_quat", + |rotation: Val| { + let output: Val = ::bevy::math::DMat3::from_quat( + rotation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_axis_angle", + |axis: Val, angle: f64| { + let output: Val = ::bevy::math::DMat3::from_axis_angle( + axis.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_euler", + |order: Val, a: f64, b: f64, c: f64| { + let output: Val = ::bevy::math::DMat3::from_euler( + order.into(), + a.into(), + b.into(), + c.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_euler", + |_self: Ref, order: Val| { + let output: (f64, f64, f64) = ::bevy::math::DMat3::to_euler( + _self.into(), + order.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_x", + |angle: f64| { + let output: Val = ::bevy::math::DMat3::from_rotation_x( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_y", + |angle: f64| { + let output: Val = ::bevy::math::DMat3::from_rotation_y( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_z", + |angle: f64| { + let output: Val = ::bevy::math::DMat3::from_rotation_z( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_translation", + |translation: Val| { + let output: Val = ::bevy::math::DMat3::from_translation( + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_angle", + |angle: f64| { + let output: Val = ::bevy::math::DMat3::from_angle( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_scale_angle_translation", + | + scale: Val, + angle: f64, + translation: Val| + { + let output: Val = ::bevy::math::DMat3::from_scale_angle_translation( + scale.into(), + angle.into(), + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_scale", + |scale: Val| { + let output: Val = ::bevy::math::DMat3::from_scale( + scale.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat2", + |m: Val| { + let output: Val = ::bevy::math::DMat3::from_mat2( + m.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "col", + |_self: Ref, index: usize| { + let output: Val = ::bevy::math::DMat3::col( + _self.into(), + index.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "row", + |_self: Ref, index: usize| { + let output: Val = ::bevy::math::DMat3::row( + _self.into(), + index.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite", + |_self: Ref| { + let output: bool = ::bevy::math::DMat3::is_finite(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_nan", + |_self: Ref| { + let output: bool = ::bevy::math::DMat3::is_nan(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "transpose", + |_self: Ref| { + let output: Val = ::bevy::math::DMat3::transpose( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "determinant", + |_self: Ref| { + let output: f64 = ::bevy::math::DMat3::determinant(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "inverse", + |_self: Ref| { + let output: Val = ::bevy::math::DMat3::inverse( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "transform_point2", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::DMat3::transform_point2( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "transform_vector2", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::DMat3::transform_vector2( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_vec3", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::DMat3::mul_vec3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_mat3", + |_self: Ref, rhs: Ref| { + let output: Val = ::bevy::math::DMat3::mul_mat3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add_mat3", + |_self: Ref, rhs: Ref| { + let output: Val = ::bevy::math::DMat3::add_mat3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub_mat3", + |_self: Ref, rhs: Ref| { + let output: Val = ::bevy::math::DMat3::sub_mat3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_scalar", + |_self: Ref, rhs: f64| { + let output: Val = ::bevy::math::DMat3::mul_scalar( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_scalar", + |_self: Ref, rhs: f64| { + let output: Val = ::bevy::math::DMat3::div_scalar( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs_diff_eq", + | + _self: Ref, + rhs: Val, + max_abs_diff: f64| + { + let output: bool = ::bevy::math::DMat3::abs_diff_eq( + _self.into(), + rhs.into(), + max_abs_diff.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs", + |_self: Ref| { + let output: Val = ::bevy::math::DMat3::abs( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_mat3", + |_self: Ref| { + let output: Val = ::bevy::math::DMat3::as_mat3( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = ::bevy::math::DMat3::eq(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::DMat3::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::math::DMat3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::DMat3::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DMat3::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DMat3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::math::DMat3::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::DMat4>::new(world) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DMat4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DMat4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_cols", + | + x_axis: Val, + y_axis: Val, + z_axis: Val, + w_axis: Val| + { + let output: Val = ::bevy::math::DMat4::from_cols( + x_axis.into(), + y_axis.into(), + z_axis.into(), + w_axis.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_cols_array", + |_self: Ref| { + let output: [f64; 16] = ::bevy::math::DMat4::to_cols_array( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_cols_array_2d", + |_self: Ref| { + let output: [[f64; 4]; 4] = ::bevy::math::DMat4::to_cols_array_2d( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_diagonal", + |diagonal: Val| { + let output: Val = ::bevy::math::DMat4::from_diagonal( + diagonal.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_scale_rotation_translation", + | + scale: Val, + rotation: Val, + translation: Val| + { + let output: Val = ::bevy::math::DMat4::from_scale_rotation_translation( + scale.into(), + rotation.into(), + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_translation", + |rotation: Val, translation: Val| { + let output: Val = ::bevy::math::DMat4::from_rotation_translation( + rotation.into(), + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_quat", + |rotation: Val| { + let output: Val = ::bevy::math::DMat4::from_quat( + rotation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat3", + |m: Val| { + let output: Val = ::bevy::math::DMat4::from_mat3( + m.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_translation", + |translation: Val| { + let output: Val = ::bevy::math::DMat4::from_translation( + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_axis_angle", + |axis: Val, angle: f64| { + let output: Val = ::bevy::math::DMat4::from_axis_angle( + axis.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_euler", + |order: Val, a: f64, b: f64, c: f64| { + let output: Val = ::bevy::math::DMat4::from_euler( + order.into(), + a.into(), + b.into(), + c.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_euler", + |_self: Ref, order: Val| { + let output: (f64, f64, f64) = ::bevy::math::DMat4::to_euler( + _self.into(), + order.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_x", + |angle: f64| { + let output: Val = ::bevy::math::DMat4::from_rotation_x( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_y", + |angle: f64| { + let output: Val = ::bevy::math::DMat4::from_rotation_y( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_z", + |angle: f64| { + let output: Val = ::bevy::math::DMat4::from_rotation_z( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_scale", + |scale: Val| { + let output: Val = ::bevy::math::DMat4::from_scale( + scale.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "col", + |_self: Ref, index: usize| { + let output: Val = ::bevy::math::DMat4::col( + _self.into(), + index.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "row", + |_self: Ref, index: usize| { + let output: Val = ::bevy::math::DMat4::row( + _self.into(), + index.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite", + |_self: Ref| { + let output: bool = ::bevy::math::DMat4::is_finite(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_nan", + |_self: Ref| { + let output: bool = ::bevy::math::DMat4::is_nan(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "transpose", + |_self: Ref| { + let output: Val = ::bevy::math::DMat4::transpose( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "determinant", + |_self: Ref| { + let output: f64 = ::bevy::math::DMat4::determinant(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "inverse", + |_self: Ref| { + let output: Val = ::bevy::math::DMat4::inverse( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "look_to_lh", + | + eye: Val, + dir: Val, + up: Val| + { + let output: Val = ::bevy::math::DMat4::look_to_lh( + eye.into(), + dir.into(), + up.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "look_to_rh", + | + eye: Val, + dir: Val, + up: Val| + { + let output: Val = ::bevy::math::DMat4::look_to_rh( + eye.into(), + dir.into(), + up.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "look_at_lh", + | + eye: Val, + center: Val, + up: Val| + { + let output: Val = ::bevy::math::DMat4::look_at_lh( + eye.into(), + center.into(), + up.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "look_at_rh", + | + eye: Val, + center: Val, + up: Val| + { + let output: Val = ::bevy::math::DMat4::look_at_rh( + eye.into(), + center.into(), + up.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "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.into(), + aspect_ratio.into(), + z_near.into(), + z_far.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "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.into(), + aspect_ratio.into(), + z_near.into(), + z_far.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "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.into(), + aspect_ratio.into(), + z_near.into(), + z_far.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "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.into(), + aspect_ratio.into(), + z_near.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "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.into(), + aspect_ratio.into(), + z_near.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "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.into(), + aspect_ratio.into(), + z_near.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "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.into(), + aspect_ratio.into(), + z_near.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "orthographic_rh_gl", + |left: f64, right: f64, bottom: f64, top: f64, near: f64, far: f64| { + let output: Val = ::bevy::math::DMat4::orthographic_rh_gl( + left.into(), + right.into(), + bottom.into(), + top.into(), + near.into(), + far.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "orthographic_lh", + |left: f64, right: f64, bottom: f64, top: f64, near: f64, far: f64| { + let output: Val = ::bevy::math::DMat4::orthographic_lh( + left.into(), + right.into(), + bottom.into(), + top.into(), + near.into(), + far.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "orthographic_rh", + |left: f64, right: f64, bottom: f64, top: f64, near: f64, far: f64| { + let output: Val = ::bevy::math::DMat4::orthographic_rh( + left.into(), + right.into(), + bottom.into(), + top.into(), + near.into(), + far.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "project_point3", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::DMat4::project_point3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "transform_point3", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::DMat4::transform_point3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "transform_vector3", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::DMat4::transform_vector3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_vec4", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::DMat4::mul_vec4( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_mat4", + |_self: Ref, rhs: Ref| { + let output: Val = ::bevy::math::DMat4::mul_mat4( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add_mat4", + |_self: Ref, rhs: Ref| { + let output: Val = ::bevy::math::DMat4::add_mat4( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub_mat4", + |_self: Ref, rhs: Ref| { + let output: Val = ::bevy::math::DMat4::sub_mat4( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_scalar", + |_self: Ref, rhs: f64| { + let output: Val = ::bevy::math::DMat4::mul_scalar( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div_scalar", + |_self: Ref, rhs: f64| { + let output: Val = ::bevy::math::DMat4::div_scalar( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs_diff_eq", + | + _self: Ref, + rhs: Val, + max_abs_diff: f64| + { + let output: bool = ::bevy::math::DMat4::abs_diff_eq( + _self.into(), + rhs.into(), + max_abs_diff.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs", + |_self: Ref| { + let output: Val = ::bevy::math::DMat4::abs( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_mat4", + |_self: Ref| { + let output: Val = ::bevy::math::DMat4::as_mat4( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::DMat4::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::DMat4::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DMat4::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::math::DMat4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = ::bevy::math::DMat4::eq(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DMat4::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::math::DMat4::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DMat4::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::Affine2>::new(world) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Affine2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Affine2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::Affine2::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_cols", + | + x_axis: Val, + y_axis: Val, + z_axis: Val| + { + let output: Val = ::bevy::math::Affine2::from_cols( + x_axis.into(), + y_axis.into(), + z_axis.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_cols_array", + |_self: Ref| { + let output: [f32; 6] = ::bevy::math::Affine2::to_cols_array( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_cols_array_2d", + |_self: Ref| { + let output: [[f32; 2]; 3] = ::bevy::math::Affine2::to_cols_array_2d( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_scale", + |scale: Val| { + let output: Val = ::bevy::math::Affine2::from_scale( + scale.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_angle", + |angle: f32| { + let output: Val = ::bevy::math::Affine2::from_angle( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_translation", + |translation: Val| { + let output: Val = ::bevy::math::Affine2::from_translation( + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat2", + |matrix2: Val| { + let output: Val = ::bevy::math::Affine2::from_mat2( + matrix2.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat2_translation", + |matrix2: Val, translation: Val| { + let output: Val = ::bevy::math::Affine2::from_mat2_translation( + matrix2.into(), + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_scale_angle_translation", + | + scale: Val, + angle: f32, + translation: Val| + { + let output: Val = ::bevy::math::Affine2::from_scale_angle_translation( + scale.into(), + angle.into(), + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_angle_translation", + |angle: f32, translation: Val| { + let output: Val = ::bevy::math::Affine2::from_angle_translation( + angle.into(), + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat3", + |m: Val| { + let output: Val = ::bevy::math::Affine2::from_mat3( + m.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat3a", + |m: Val| { + let output: Val = ::bevy::math::Affine2::from_mat3a( + m.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "transform_point2", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Affine2::transform_point2( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "transform_vector2", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Affine2::transform_vector2( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite", + |_self: Ref| { + let output: bool = ::bevy::math::Affine2::is_finite(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_nan", + |_self: Ref| { + let output: bool = ::bevy::math::Affine2::is_nan(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "abs_diff_eq", + | + _self: Ref, + rhs: Val, + max_abs_diff: f32| + { + let output: bool = ::bevy::math::Affine2::abs_diff_eq( + _self.into(), + rhs.into(), + max_abs_diff.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "inverse", + |_self: Ref| { + let output: Val = ::bevy::math::Affine2::inverse( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = ::bevy::math::Affine2::eq( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Affine2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::Affine3A>::new(world) + .overwrite_script_function( + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = ::bevy::math::Affine3A::eq( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::Affine3A::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_cols", + | + x_axis: Val, + y_axis: Val, + z_axis: Val, + w_axis: Val| + { + let output: Val = ::bevy::math::Affine3A::from_cols( + x_axis.into(), + y_axis.into(), + z_axis.into(), + w_axis.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_cols_array", + |_self: Ref| { + let output: [f32; 12] = ::bevy::math::Affine3A::to_cols_array( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_cols_array_2d", + |_self: Ref| { + let output: [[f32; 3]; 4] = ::bevy::math::Affine3A::to_cols_array_2d( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_scale", + |scale: Val| { + let output: Val = ::bevy::math::Affine3A::from_scale( + scale.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_quat", + |rotation: Val| { + let output: Val = ::bevy::math::Affine3A::from_quat( + rotation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_axis_angle", + |axis: Val, angle: f32| { + let output: Val = ::bevy::math::Affine3A::from_axis_angle( + axis.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_x", + |angle: f32| { + let output: Val = ::bevy::math::Affine3A::from_rotation_x( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_y", + |angle: f32| { + let output: Val = ::bevy::math::Affine3A::from_rotation_y( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_z", + |angle: f32| { + let output: Val = ::bevy::math::Affine3A::from_rotation_z( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_translation", + |translation: Val| { + let output: Val = ::bevy::math::Affine3A::from_translation( + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat3", + |mat3: Val| { + let output: Val = ::bevy::math::Affine3A::from_mat3( + mat3.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat3_translation", + |mat3: Val, translation: Val| { + let output: Val = ::bevy::math::Affine3A::from_mat3_translation( + mat3.into(), + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_scale_rotation_translation", + | + scale: Val, + rotation: Val, + translation: Val| + { + let output: Val = ::bevy::math::Affine3A::from_scale_rotation_translation( + scale.into(), + rotation.into(), + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_translation", + |rotation: Val, translation: Val| { + let output: Val = ::bevy::math::Affine3A::from_rotation_translation( + rotation.into(), + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat4", + |m: Val| { + let output: Val = ::bevy::math::Affine3A::from_mat4( + m.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "look_to_lh", + | + eye: Val, + dir: Val, + up: Val| + { + let output: Val = ::bevy::math::Affine3A::look_to_lh( + eye.into(), + dir.into(), + up.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "look_to_rh", + | + eye: Val, + dir: Val, + up: Val| + { + let output: Val = ::bevy::math::Affine3A::look_to_rh( + eye.into(), + dir.into(), + up.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "look_at_lh", + | + eye: Val, + center: Val, + up: Val| + { + let output: Val = ::bevy::math::Affine3A::look_at_lh( + eye.into(), + center.into(), + up.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "look_at_rh", + | + eye: Val, + center: Val, + up: Val| + { + let output: Val = ::bevy::math::Affine3A::look_at_rh( + eye.into(), + center.into(), + up.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "transform_point3", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Affine3A::transform_point3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "transform_vector3", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Affine3A::transform_vector3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "transform_point3a", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Affine3A::transform_point3a( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "transform_vector3a", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::Affine3A::transform_vector3a( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite", + |_self: Ref| { + let output: bool = ::bevy::math::Affine3A::is_finite(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_nan", + |_self: Ref| { + let output: bool = ::bevy::math::Affine3A::is_nan(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "abs_diff_eq", + | + _self: Ref, + rhs: Val, + max_abs_diff: f32| + { + let output: bool = ::bevy::math::Affine3A::abs_diff_eq( + _self.into(), + rhs.into(), + max_abs_diff.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "inverse", + |_self: Ref| { + let output: Val = ::bevy::math::Affine3A::inverse( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Affine3A::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::Affine3A::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::DAffine2>::new(world) + .overwrite_script_function( + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = ::bevy::math::DAffine2::eq( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_cols", + | + x_axis: Val, + y_axis: Val, + z_axis: Val| + { + let output: Val = ::bevy::math::DAffine2::from_cols( + x_axis.into(), + y_axis.into(), + z_axis.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_cols_array", + |_self: Ref| { + let output: [f64; 6] = ::bevy::math::DAffine2::to_cols_array( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_cols_array_2d", + |_self: Ref| { + let output: [[f64; 2]; 3] = ::bevy::math::DAffine2::to_cols_array_2d( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_scale", + |scale: Val| { + let output: Val = ::bevy::math::DAffine2::from_scale( + scale.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_angle", + |angle: f64| { + let output: Val = ::bevy::math::DAffine2::from_angle( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_translation", + |translation: Val| { + let output: Val = ::bevy::math::DAffine2::from_translation( + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat2", + |matrix2: Val| { + let output: Val = ::bevy::math::DAffine2::from_mat2( + matrix2.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat2_translation", + |matrix2: Val, translation: Val| { + let output: Val = ::bevy::math::DAffine2::from_mat2_translation( + matrix2.into(), + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_scale_angle_translation", + | + scale: Val, + angle: f64, + translation: Val| + { + let output: Val = ::bevy::math::DAffine2::from_scale_angle_translation( + scale.into(), + angle.into(), + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_angle_translation", + |angle: f64, translation: Val| { + let output: Val = ::bevy::math::DAffine2::from_angle_translation( + angle.into(), + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat3", + |m: Val| { + let output: Val = ::bevy::math::DAffine2::from_mat3( + m.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "transform_point2", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::DAffine2::transform_point2( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "transform_vector2", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::DAffine2::transform_vector2( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite", + |_self: Ref| { + let output: bool = ::bevy::math::DAffine2::is_finite(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_nan", + |_self: Ref| { + let output: bool = ::bevy::math::DAffine2::is_nan(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "abs_diff_eq", + | + _self: Ref, + rhs: Val, + max_abs_diff: f64| + { + let output: bool = ::bevy::math::DAffine2::abs_diff_eq( + _self.into(), + rhs.into(), + max_abs_diff.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "inverse", + |_self: Ref| { + let output: Val = ::bevy::math::DAffine2::inverse( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DAffine2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DAffine2::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::DAffine2::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::DAffine3>::new(world) + .overwrite_script_function( + "from_cols", + | + x_axis: Val, + y_axis: Val, + z_axis: Val, + w_axis: Val| + { + let output: Val = ::bevy::math::DAffine3::from_cols( + x_axis.into(), + y_axis.into(), + z_axis.into(), + w_axis.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_cols_array", + |_self: Ref| { + let output: [f64; 12] = ::bevy::math::DAffine3::to_cols_array( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_cols_array_2d", + |_self: Ref| { + let output: [[f64; 3]; 4] = ::bevy::math::DAffine3::to_cols_array_2d( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_scale", + |scale: Val| { + let output: Val = ::bevy::math::DAffine3::from_scale( + scale.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_quat", + |rotation: Val| { + let output: Val = ::bevy::math::DAffine3::from_quat( + rotation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_axis_angle", + |axis: Val, angle: f64| { + let output: Val = ::bevy::math::DAffine3::from_axis_angle( + axis.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_x", + |angle: f64| { + let output: Val = ::bevy::math::DAffine3::from_rotation_x( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_y", + |angle: f64| { + let output: Val = ::bevy::math::DAffine3::from_rotation_y( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_z", + |angle: f64| { + let output: Val = ::bevy::math::DAffine3::from_rotation_z( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_translation", + |translation: Val| { + let output: Val = ::bevy::math::DAffine3::from_translation( + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat3", + |mat3: Val| { + let output: Val = ::bevy::math::DAffine3::from_mat3( + mat3.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat3_translation", + |mat3: Val, translation: Val| { + let output: Val = ::bevy::math::DAffine3::from_mat3_translation( + mat3.into(), + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_scale_rotation_translation", + | + scale: Val, + rotation: Val, + translation: Val| + { + let output: Val = ::bevy::math::DAffine3::from_scale_rotation_translation( + scale.into(), + rotation.into(), + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_translation", + |rotation: Val, translation: Val| { + let output: Val = ::bevy::math::DAffine3::from_rotation_translation( + rotation.into(), + translation.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat4", + |m: Val| { + let output: Val = ::bevy::math::DAffine3::from_mat4( + m.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "look_to_lh", + | + eye: Val, + dir: Val, + up: Val| + { + let output: Val = ::bevy::math::DAffine3::look_to_lh( + eye.into(), + dir.into(), + up.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "look_to_rh", + | + eye: Val, + dir: Val, + up: Val| + { + let output: Val = ::bevy::math::DAffine3::look_to_rh( + eye.into(), + dir.into(), + up.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "look_at_lh", + | + eye: Val, + center: Val, + up: Val| + { + let output: Val = ::bevy::math::DAffine3::look_at_lh( + eye.into(), + center.into(), + up.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "look_at_rh", + | + eye: Val, + center: Val, + up: Val| + { + let output: Val = ::bevy::math::DAffine3::look_at_rh( + eye.into(), + center.into(), + up.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "transform_point3", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::DAffine3::transform_point3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "transform_vector3", + |_self: Ref, rhs: Val| { + let output: Val = ::bevy::math::DAffine3::transform_vector3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite", + |_self: Ref| { + let output: bool = ::bevy::math::DAffine3::is_finite(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_nan", + |_self: Ref| { + let output: bool = ::bevy::math::DAffine3::is_nan(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "abs_diff_eq", + | + _self: Ref, + rhs: Val, + max_abs_diff: f64| + { + let output: bool = ::bevy::math::DAffine3::abs_diff_eq( + _self.into(), + rhs.into(), + max_abs_diff.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "inverse", + |_self: Ref| { + let output: Val = ::bevy::math::DAffine3::inverse( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = ::bevy::math::DAffine3::eq( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DAffine3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DAffine3::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::DAffine3::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::DQuat>::new(world) + .overwrite_script_function( + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = ::bevy::math::DQuat::eq(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "div", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::math::DQuat::div( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_xyzw", + |x: f64, y: f64, z: f64, w: f64| { + let output: Val = ::bevy::math::DQuat::from_xyzw( + x.into(), + y.into(), + z.into(), + w.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [f64; 4]| { + let output: Val = ::bevy::math::DQuat::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_vec4", + |v: Val| { + let output: Val = ::bevy::math::DQuat::from_vec4( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_axis_angle", + |axis: Val, angle: f64| { + let output: Val = ::bevy::math::DQuat::from_axis_angle( + axis.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_scaled_axis", + |v: Val| { + let output: Val = ::bevy::math::DQuat::from_scaled_axis( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_x", + |angle: f64| { + let output: Val = ::bevy::math::DQuat::from_rotation_x( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_y", + |angle: f64| { + let output: Val = ::bevy::math::DQuat::from_rotation_y( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_z", + |angle: f64| { + let output: Val = ::bevy::math::DQuat::from_rotation_z( + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_euler", + |euler: Val, a: f64, b: f64, c: f64| { + let output: Val = ::bevy::math::DQuat::from_euler( + euler.into(), + a.into(), + b.into(), + c.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat3", + |mat: Ref| { + let output: Val = ::bevy::math::DQuat::from_mat3( + mat.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_mat4", + |mat: Ref| { + let output: Val = ::bevy::math::DQuat::from_mat4( + mat.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_arc", + |from: Val, to: Val| { + let output: Val = ::bevy::math::DQuat::from_rotation_arc( + from.into(), + to.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_arc_colinear", + |from: Val, to: Val| { + let output: Val = ::bevy::math::DQuat::from_rotation_arc_colinear( + from.into(), + to.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_rotation_arc_2d", + |from: Val, to: Val| { + let output: Val = ::bevy::math::DQuat::from_rotation_arc_2d( + from.into(), + to.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_scaled_axis", + |_self: Val| { + let output: Val = ::bevy::math::DQuat::to_scaled_axis( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_euler", + |_self: Val, order: Val| { + let output: (f64, f64, f64) = ::bevy::math::DQuat::to_euler( + _self.into(), + order.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_array", + |_self: Ref| { + let output: [f64; 4] = ::bevy::math::DQuat::to_array(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "xyz", + |_self: Val| { + let output: Val = ::bevy::math::DQuat::xyz( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "conjugate", + |_self: Val| { + let output: Val = ::bevy::math::DQuat::conjugate( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "inverse", + |_self: Val| { + let output: Val = ::bevy::math::DQuat::inverse( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "dot", + |_self: Val, rhs: Val| { + let output: f64 = ::bevy::math::DQuat::dot(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "length", + |_self: Val| { + let output: f64 = ::bevy::math::DQuat::length(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "length_squared", + |_self: Val| { + let output: f64 = ::bevy::math::DQuat::length_squared(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "length_recip", + |_self: Val| { + let output: f64 = ::bevy::math::DQuat::length_recip(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "normalize", + |_self: Val| { + let output: Val = ::bevy::math::DQuat::normalize( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite", + |_self: Val| { + let output: bool = ::bevy::math::DQuat::is_finite(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_nan", + |_self: Val| { + let output: bool = ::bevy::math::DQuat::is_nan(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "is_normalized", + |_self: Val| { + let output: bool = ::bevy::math::DQuat::is_normalized(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_near_identity", + |_self: Val| { + let output: bool = ::bevy::math::DQuat::is_near_identity( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "angle_between", + |_self: Val, rhs: Val| { + let output: f64 = ::bevy::math::DQuat::angle_between( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rotate_towards", + | + _self: Ref, + rhs: Val, + max_angle: f64| + { + let output: Val = ::bevy::math::DQuat::rotate_towards( + _self.into(), + rhs.into(), + max_angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "abs_diff_eq", + | + _self: Val, + rhs: Val, + max_abs_diff: f64| + { + let output: bool = ::bevy::math::DQuat::abs_diff_eq( + _self.into(), + rhs.into(), + max_abs_diff.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "lerp", + |_self: Val, end: Val, s: f64| { + let output: Val = ::bevy::math::DQuat::lerp( + _self.into(), + end.into(), + s.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "slerp", + |_self: Val, end: Val, s: f64| { + let output: Val = ::bevy::math::DQuat::slerp( + _self.into(), + end.into(), + s.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_vec3", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DQuat::mul_vec3( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_quat", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DQuat::mul_quat( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_affine3", + |a: Ref| { + let output: Val = ::bevy::math::DQuat::from_affine3( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "as_quat", + |_self: Val| { + let output: Val = ::bevy::math::DQuat::as_quat( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DQuat::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DQuat::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::DQuat::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "sub", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DQuat::sub( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + |_self: Val, rhs: f64| { + let output: Val = ::bevy::math::DQuat::mul( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "neg", + |_self: Val| { + let output: Val = ::bevy::math::DQuat::neg( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "add", + |_self: Val, rhs: Val| { + let output: Val = ::bevy::math::DQuat::add( + _self.into(), + rhs.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::EulerRot>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::EulerRot::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::math::EulerRot::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::math::EulerRot::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::BVec3A>::new(world) + .overwrite_script_function( + "new", + |x: bool, y: bool, z: bool| { + let output: Val = ::bevy::math::BVec3A::new( + x.into(), + y.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: bool| { + let output: Val = ::bevy::math::BVec3A::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [bool; 3]| { + let output: Val = ::bevy::math::BVec3A::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "bitmask", + |_self: Val| { + let output: u32 = ::bevy::math::BVec3A::bitmask(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "any", + |_self: Val| { + let output: bool = ::bevy::math::BVec3A::any(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "all", + |_self: Val| { + let output: bool = ::bevy::math::BVec3A::all(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "test", + |_self: Ref, index: usize| { + let output: bool = ::bevy::math::BVec3A::test( + _self.into(), + index.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "set", + |_self: Mut, index: usize, value: bool| { + let output: () = ::bevy::math::BVec3A::set( + _self.into(), + index.into(), + value.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::BVec3A::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = ::bevy::math::BVec3A::eq(_self.into(), rhs.into()) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::math::BVec4A>::new(world) + .overwrite_script_function( + "new", + |x: bool, y: bool, z: bool, w: bool| { + let output: Val = ::bevy::math::BVec4A::new( + x.into(), + y.into(), + z.into(), + w.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "splat", + |v: bool| { + let output: Val = ::bevy::math::BVec4A::splat( + v.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_array", + |a: [bool; 4]| { + let output: Val = ::bevy::math::BVec4A::from_array( + a.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "bitmask", + |_self: Val| { + let output: u32 = ::bevy::math::BVec4A::bitmask(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "any", + |_self: Val| { + let output: bool = ::bevy::math::BVec4A::any(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "all", + |_self: Val| { + let output: bool = ::bevy::math::BVec4A::all(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "test", + |_self: Ref, index: usize| { + let output: bool = ::bevy::math::BVec4A::test( + _self.into(), + index.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "set", + |_self: Mut, index: usize, value: bool| { + let output: () = ::bevy::math::BVec4A::set( + _self.into(), + index.into(), + value.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, rhs: Ref| { + let output: bool = ::bevy::math::BVec4A::eq(_self.into(), rhs.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::math::BVec4A::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::smol_str::SmolStr>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::smol_str::SmolStr::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::smol_str::SmolStr::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "to_string", + |_self: Ref| { + let output: std::string::String = ::smol_str::SmolStr::to_string( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "len", + |_self: Ref| { + let output: usize = ::smol_str::SmolStr::len(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "is_empty", + |_self: Ref| { + let output: bool = ::smol_str::SmolStr::is_empty(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_heap_allocated", + |_self: Ref| { + let output: bool = ::smol_str::SmolStr::is_heap_allocated( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::uuid::Uuid>::new(world) + .overwrite_script_function( + "get_version_num", + |_self: Ref| { + let output: usize = ::uuid::Uuid::get_version_num(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "as_u128", + |_self: Ref| { + let output: u128 = ::uuid::Uuid::as_u128(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "to_u128_le", + |_self: Ref| { + let output: u128 = ::uuid::Uuid::to_u128_le(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "as_u64_pair", + |_self: Ref| { + let output: (u64, u64) = ::uuid::Uuid::as_u64_pair(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "into_bytes", + |_self: Val| { + let output: [u8; 16] = ::uuid::Uuid::into_bytes(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "to_bytes_le", + |_self: Ref| { + let output: [u8; 16] = ::uuid::Uuid::to_bytes_le(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_nil", + |_self: Ref| { + let output: bool = ::uuid::Uuid::is_nil(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "is_max", + |_self: Ref| { + let output: bool = ::uuid::Uuid::is_max(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "encode_buffer", + || { + let output: [u8; 45] = ::uuid::Uuid::encode_buffer().into(); + output + }, + ) + .overwrite_script_function( + "get_node_id", + |_self: Ref| { + let output: bevy::reflect::erased_serde::__private::serde::__private::Option< + [u8; 6], + > = ::uuid::Uuid::get_node_id(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::uuid::Uuid::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "nil", + || { + let output: Val = ::uuid::Uuid::nil().into(); + output + }, + ) + .overwrite_script_function( + "max", + || { + let output: Val = ::uuid::Uuid::max().into(); + output + }, + ) + .overwrite_script_function( + "from_u128", + |v: u128| { + let output: Val = ::uuid::Uuid::from_u128(v.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "from_u128_le", + |v: u128| { + let output: Val = ::uuid::Uuid::from_u128_le(v.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "from_u64_pair", + |high_bits: u64, low_bits: u64| { + let output: Val = ::uuid::Uuid::from_u64_pair( + high_bits.into(), + low_bits.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_bytes", + |bytes: [u8; 16]| { + let output: Val = ::uuid::Uuid::from_bytes(bytes.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "from_bytes_le", + |b: [u8; 16]| { + let output: Val = ::uuid::Uuid::from_bytes_le(b.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::uuid::Uuid::eq(_self.into(), other.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::uuid::Uuid::clone(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "new_v4", + || { + let output: Val = ::uuid::Uuid::new_v4().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 new file mode 100644 index 0000000000..2a0259468a --- /dev/null +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_time.rs @@ -0,0 +1,355 @@ +// @generated by cargo bevy-api-gen generate, modify the templates not this file +#![allow(clippy::all)] +#![allow(unused, deprecated, dead_code)] +#![cfg_attr(rustfmt, rustfmt_skip)] +use super::bevy_ecs::*; +use super::bevy_reflect::*; +use bevy_mod_scripting_core::{ + AddContextInitializer, StoreDocumentation, + bindings::{ReflectReference, function::from::{Ref, Mut, Val}}, +}; +use crate::*; +pub struct BevyTimeScriptingPlugin; +impl ::bevy::app::Plugin for BevyTimeScriptingPlugin { + fn build(&self, app: &mut ::bevy::prelude::App) { + let mut world = app.world_mut(); + NamespaceBuilder::<::bevy::time::prelude::Fixed>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::time::prelude::Fixed::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::time::prelude::Real>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::time::prelude::Real::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::time::prelude::Timer>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::time::prelude::Timer::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::time::prelude::Timer::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_seconds", + |duration: f32, mode: Val| { + let output: Val = ::bevy::time::prelude::Timer::from_seconds( + duration.into(), + mode.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "finished", + |_self: Ref| { + let output: bool = ::bevy::time::prelude::Timer::finished( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "just_finished", + |_self: Ref| { + let output: bool = ::bevy::time::prelude::Timer::just_finished( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "elapsed_secs", + |_self: Ref| { + let output: f32 = ::bevy::time::prelude::Timer::elapsed_secs( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "elapsed_secs_f64", + |_self: Ref| { + let output: f64 = ::bevy::time::prelude::Timer::elapsed_secs_f64( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mode", + |_self: Ref| { + let output: Val = ::bevy::time::prelude::Timer::mode( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "set_mode", + | + _self: Mut, + mode: Val| + { + let output: () = ::bevy::time::prelude::Timer::set_mode( + _self.into(), + mode.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "pause", + |_self: Mut| { + let output: () = ::bevy::time::prelude::Timer::pause(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "unpause", + |_self: Mut| { + let output: () = ::bevy::time::prelude::Timer::unpause(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "paused", + |_self: Ref| { + let output: bool = ::bevy::time::prelude::Timer::paused(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "reset", + |_self: Mut| { + let output: () = ::bevy::time::prelude::Timer::reset(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "fraction", + |_self: Ref| { + let output: f32 = ::bevy::time::prelude::Timer::fraction( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "fraction_remaining", + |_self: Ref| { + let output: f32 = ::bevy::time::prelude::Timer::fraction_remaining( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "remaining_secs", + |_self: Ref| { + let output: f32 = ::bevy::time::prelude::Timer::remaining_secs( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "times_finished_this_tick", + |_self: Ref| { + let output: u32 = ::bevy::time::prelude::Timer::times_finished_this_tick( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::time::prelude::Timer::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::time::prelude::TimerMode>::new(world) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::time::prelude::TimerMode::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::time::prelude::TimerMode::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::time::prelude::TimerMode::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::time::prelude::Virtual>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::time::prelude::Virtual::clone( + _self.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::time::Stopwatch>::new(world) + .overwrite_script_function( + "new", + || { + let output: Val = ::bevy::time::Stopwatch::new() + .into(); + output + }, + ) + .overwrite_script_function( + "elapsed_secs", + |_self: Ref| { + let output: f32 = ::bevy::time::Stopwatch::elapsed_secs(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "elapsed_secs_f64", + |_self: Ref| { + let output: f64 = ::bevy::time::Stopwatch::elapsed_secs_f64( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "pause", + |_self: Mut| { + let output: () = ::bevy::time::Stopwatch::pause(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "unpause", + |_self: Mut| { + let output: () = ::bevy::time::Stopwatch::unpause(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "is_paused", + |_self: Ref| { + let output: bool = ::bevy::time::Stopwatch::is_paused(_self.into()) + .into(); + output + }, + ) + .overwrite_script_function( + "reset", + |_self: Mut| { + let output: () = ::bevy::time::Stopwatch::reset(_self.into()).into(); + output + }, + ) + .overwrite_script_function( + "assert_receiver_is_total_eq", + |_self: Ref| { + let output: () = ::bevy::time::Stopwatch::assert_receiver_is_total_eq( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::time::Stopwatch::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + |_self: Ref, other: Ref| { + let output: bool = ::bevy::time::Stopwatch::eq( + _self.into(), + other.into(), + ) + .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 new file mode 100644 index 0000000000..c32d3ee20e --- /dev/null +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_transform.rs @@ -0,0 +1,278 @@ +// @generated by cargo bevy-api-gen generate, modify the templates not this file +#![allow(clippy::all)] +#![allow(unused, deprecated, dead_code)] +#![cfg_attr(rustfmt, rustfmt_skip)] +use super::bevy_ecs::*; +use super::bevy_reflect::*; +use super::bevy_core::*; +use super::bevy_math::*; +use super::bevy_hierarchy::*; +use bevy_mod_scripting_core::{ + AddContextInitializer, StoreDocumentation, + bindings::{ReflectReference, function::from::{Ref, Mut, Val}}, +}; +use crate::*; +pub struct BevyTransformScriptingPlugin; +impl ::bevy::app::Plugin for BevyTransformScriptingPlugin { + fn build(&self, app: &mut ::bevy::prelude::App) { + let mut world = app.world_mut(); + NamespaceBuilder::<::bevy::transform::components::GlobalTransform>::new(world) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::transform::components::GlobalTransform::clone( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + | + _self: Val, + global_transform: Val| + { + let output: Val = ::bevy::transform::components::GlobalTransform::mul( + _self.into(), + global_transform.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + | + _self: Val, + transform: Val| + { + let output: Val = ::bevy::transform::components::GlobalTransform::mul( + _self.into(), + transform.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::transform::components::GlobalTransform::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "from_xyz", + |x: f32, y: f32, z: f32| { + let output: Val = ::bevy::transform::components::GlobalTransform::from_xyz( + x.into(), + y.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "compute_transform", + |_self: Ref| { + let output: Val = ::bevy::transform::components::GlobalTransform::compute_transform( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "reparented_to", + | + _self: Ref, + parent: Ref| + { + let output: Val = ::bevy::transform::components::GlobalTransform::reparented_to( + _self.into(), + parent.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_transform", + | + _self: Ref, + transform: Val| + { + let output: Val = ::bevy::transform::components::GlobalTransform::mul_transform( + _self.into(), + transform.into(), + ) + .into(); + output + }, + ); + NamespaceBuilder::<::bevy::transform::components::Transform>::new(world) + .overwrite_script_function( + "from_xyz", + |x: f32, y: f32, z: f32| { + let output: Val = ::bevy::transform::components::Transform::from_xyz( + x.into(), + y.into(), + z.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rotate_x", + |_self: Mut, angle: f32| { + let output: () = ::bevy::transform::components::Transform::rotate_x( + _self.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rotate_y", + |_self: Mut, angle: f32| { + let output: () = ::bevy::transform::components::Transform::rotate_y( + _self.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rotate_z", + |_self: Mut, angle: f32| { + let output: () = ::bevy::transform::components::Transform::rotate_z( + _self.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rotate_local_x", + |_self: Mut, angle: f32| { + let output: () = ::bevy::transform::components::Transform::rotate_local_x( + _self.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rotate_local_y", + |_self: Mut, angle: f32| { + let output: () = ::bevy::transform::components::Transform::rotate_local_y( + _self.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "rotate_local_z", + |_self: Mut, angle: f32| { + let output: () = ::bevy::transform::components::Transform::rotate_local_z( + _self.into(), + angle.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul_transform", + | + _self: Ref, + transform: Val| + { + let output: Val = ::bevy::transform::components::Transform::mul_transform( + _self.into(), + transform.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "is_finite", + |_self: Ref| { + let output: bool = ::bevy::transform::components::Transform::is_finite( + _self.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "eq", + | + _self: Ref, + other: Ref| + { + let output: bool = ::bevy::transform::components::Transform::eq( + _self.into(), + other.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + | + _self: Val, + transform: Val| + { + let output: Val = ::bevy::transform::components::Transform::mul( + _self.into(), + transform.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "mul", + | + _self: Val, + global_transform: Val| + { + let output: Val = ::bevy::transform::components::Transform::mul( + _self.into(), + global_transform.into(), + ) + .into(); + output + }, + ) + .overwrite_script_function( + "clone", + |_self: Ref| { + let output: Val = ::bevy::transform::components::Transform::clone( + _self.into(), + ) + .into(); + output + }, + ); + } +} diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/mod.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/mod.rs new file mode 100644 index 0000000000..7aa0977203 --- /dev/null +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/mod.rs @@ -0,0 +1,25 @@ +// @generated by cargo bevy-api-gen collect, modify the templates not this file +#![allow(clippy::all)] +#![allow(unused, deprecated, dead_code)] +#![cfg_attr(rustfmt, rustfmt_skip)] +pub mod bevy_reflect; +pub mod bevy_math; +pub mod bevy_input; +pub mod bevy_transform; +pub mod bevy_core; +pub mod bevy_hierarchy; +pub mod bevy_ecs; +pub mod bevy_time; +pub struct LuaBevyScriptingPlugin; +impl ::bevy::app::Plugin for LuaBevyScriptingPlugin { + fn build(&self, app: &mut ::bevy::prelude::App) { + bevy_reflect::BevyReflectScriptingPlugin.build(app); + bevy_math::BevyMathScriptingPlugin.build(app); + bevy_input::BevyInputScriptingPlugin.build(app); + bevy_transform::BevyTransformScriptingPlugin.build(app); + bevy_core::BevyCoreScriptingPlugin.build(app); + bevy_hierarchy::BevyHierarchyScriptingPlugin.build(app); + bevy_ecs::BevyEcsScriptingPlugin.build(app); + bevy_time::BevyTimeScriptingPlugin.build(app); + } +}