From 762773f224220567f6f1d7318ee4faf3dc259286 Mon Sep 17 00:00:00 2001 From: makspll Date: Sat, 23 Aug 2025 18:31:46 +0100 Subject: [PATCH 01/10] refactor: refactor dependencies, point at bevy subcrates directly --- Cargo.toml | 100 +- codegen/templates/import.tera | 8 +- crates/bevy_mod_scripting_core/Cargo.toml | 39 +- crates/bevy_mod_scripting_core/src/asset.rs | 220 +- .../src/bindings/access_map.rs | 35 +- .../src/bindings/allocator.rs | 15 +- .../src/bindings/function/arg_meta.rs | 6 +- .../src/bindings/function/from.rs | 19 +- .../src/bindings/function/from_ref.rs | 2 +- .../src/bindings/function/into.rs | 17 +- .../src/bindings/function/into_ref.rs | 2 +- .../src/bindings/function/magic_functions.rs | 2 +- .../src/bindings/function/mod.rs | 10 +- .../src/bindings/function/namespace.rs | 6 +- .../src/bindings/function/script_function.rs | 17 +- .../bindings/function/type_dependencies.rs | 116 +- .../src/bindings/globals/core.rs | 28 +- .../src/bindings/globals/mod.rs | 16 +- .../src/bindings/pretty_print.rs | 123 +- .../src/bindings/query.rs | 12 +- .../src/bindings/reference.rs | 94 +- .../src/bindings/schedule.rs | 63 +- .../src/bindings/script_component.rs | 22 +- .../src/bindings/script_system.rs | 74 +- .../src/bindings/script_value.rs | 16 +- .../src/bindings/type_data.rs | 2 +- .../src/bindings/world.rs | 55 +- .../bevy_mod_scripting_core/src/commands.rs | 42 +- crates/bevy_mod_scripting_core/src/context.rs | 2 +- .../src/docgen/info.rs | 14 +- .../src/docgen/typed_through.rs | 46 +- crates/bevy_mod_scripting_core/src/error.rs | 14 +- crates/bevy_mod_scripting_core/src/event.rs | 10 +- .../bevy_mod_scripting_core/src/extractors.rs | 71 +- crates/bevy_mod_scripting_core/src/handler.rs | 14 +- crates/bevy_mod_scripting_core/src/lib.rs | 46 +- .../src/reflection_extensions.rs | 62 +- crates/bevy_mod_scripting_core/src/runtime.rs | 5 +- .../src/script/context_key.rs | 2 +- .../bevy_mod_scripting_core/src/script/mod.rs | 26 +- .../src/script/script_context.rs | 3 +- crates/bevy_mod_scripting_derive/Cargo.toml | 6 +- .../src/derive/get_type_dependencies.rs | 10 +- .../src/derive/script_bindings.rs | 8 +- .../src/derive/script_globals.rs | 2 +- .../bevy_mod_scripting_functions/Cargo.toml | 29 +- .../src/bevy_bindings/bevy_ecs.rs | 321 +- .../src/bevy_bindings/bevy_input.rs | 861 +- .../src/bevy_bindings/bevy_math.rs | 2792 +-- .../src/bevy_bindings/bevy_reflect.rs | 18576 +++++++--------- .../src/bevy_bindings/bevy_time.rs | 211 +- .../src/bevy_bindings/bevy_transform.rs | 464 +- crates/bevy_system_reflection/Cargo.toml | 13 +- crates/bevy_system_reflection/src/lib.rs | 16 +- .../mdbook_lad_preprocessor/Cargo.toml | 18 +- crates/ladfile/Cargo.toml | 6 +- crates/ladfile_builder/Cargo.toml | 14 +- crates/ladfile_builder/src/lib.rs | 10 +- crates/ladfile_builder/src/plugin.rs | 13 +- .../bevy_mod_scripting_lua/Cargo.toml | 8 +- .../src/bindings/script_value.rs | 5 +- .../bevy_mod_scripting_lua/src/lib.rs | 21 +- .../bevy_mod_scripting_rhai/Cargo.toml | 11 +- .../bevy_mod_scripting_rhai/src/lib.rs | 25 +- .../Cargo.toml | 22 +- crates/testing_crates/test_utils/Cargo.toml | 9 +- .../test_utils/src/test_data.rs | 23 +- .../test_utils/src/test_plugin.rs | 12 +- 68 files changed, 11456 insertions(+), 13526 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index a3a12a1947..2b3a94f960 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -67,45 +67,99 @@ rhai = ["bevy_mod_scripting_rhai", "bevy_mod_scripting_functions/rhai_bindings"] # rune = ["bevy_mod_scripting_rune"] ### Profiling -profile_with_tracy = ["bevy/trace_tracy"] +profile_with_tracy = ["bevy?/trace_tracy", "dep:bevy"] [dependencies] -bevy = { workspace = true } +bevy = { workspace = true, optional = true } bevy_math = { workspace = true } bevy_reflect = { workspace = true } bevy_mod_scripting_core = { workspace = true } -bevy_mod_scripting_lua = { path = "crates/languages/bevy_mod_scripting_lua", version = "0.15.1", optional = true } -bevy_mod_scripting_rhai = { path = "crates/languages/bevy_mod_scripting_rhai", version = "0.15.1", optional = true } -# bevy_mod_scripting_rune = { path = "crates/languages/bevy_mod_scripting_rune", version = "0.9.0-alpha.2", optional = true } +bevy_mod_scripting_lua = { workspace = true, optional = true } +bevy_mod_scripting_rhai = { workspace = true, optional = true } bevy_mod_scripting_functions = { workspace = true } bevy_mod_scripting_derive = { workspace = true } [workspace.dependencies] -profiling = { version = "1.0" } - -bevy = { version = "0.16.0", default-features = false } -bevy_math = { version = "0.16.0" } -bevy_reflect = { version = "0.16.0" } -bevy_mod_scripting_core = { path = "crates/bevy_mod_scripting_core", version = "0.15.1" } +# local crates +script_integration_test_harness = { path = "crates/testing_crates/script_integration_test_harness" } +test_utils = { path = "crates/testing_crates/test_utils" } bevy_mod_scripting_functions = { path = "crates/bevy_mod_scripting_functions", version = "0.15.1", default-features = false } bevy_mod_scripting_derive = { path = "crates/bevy_mod_scripting_derive", version = "0.15.1" } +bevy_system_reflection = { path = "crates/bevy_system_reflection", version = "0.2.0", default-features = false } +ladfile = { path = "crates/ladfile", version = "0.5.0" } +ladfile_builder = { path = "crates/ladfile_builder", version = "0.5.1" } +bevy_mod_scripting_lua = { path = "crates/languages/bevy_mod_scripting_lua", version = "0.15.1", default-features = false } +bevy_mod_scripting_rhai = { path = "crates/languages/bevy_mod_scripting_rhai", version = "0.15.1", default-features = false } +# bevy -# test utilities -script_integration_test_harness = { path = "crates/testing_crates/script_integration_test_harness" } -test_utils = { path = "crates/testing_crates/test_utils" } +bevy_mod_scripting_core = { path = "crates/bevy_mod_scripting_core", version = "0.15.1" } +bevy = { version = "0.16.0", default-features = false } +bevy_math = { version = "0.16.0", default-features = false } +bevy_transform = { version = "0.16.0", default-features = false } +bevy_reflect = { version = "0.16.0", default-features = false } +bevy_ecs = { version = "0.16.0", default-features = false } +bevy_asset = { version = "0.16.0", default-features = false } +bevy_app = { version = "0.16.0", default-features = false } +bevy_log = { version = "0.16.0", default-features = false } +bevy_internal = { version = "0.16.0", default-features = false } +bevy_diagnostic = { version = "0.16.0", default-features = false } +bevy_platform = { version = "0.16.0", default-features = false } +bevy_time = { version = "0.16.0", default-features = false } +bevy_input = { version = "0.16.0", default-features = false } +glam = { version = "0.30.0", default-features = false } +uuid = { version = "1.11", default-features = false } +smol_str = { version = "0.2.0", default-features = false } + +# other +serde_json = { version = "1.0", default-features = false } +indexmap = { version = "2.7", default-features = false } +profiling = { version = "1.0", default-features = false } +regex = { version = "1.11", default-features = false } +serde = { version = "1.0", default-features = false } +dot-writer = { version = "0.1.4", default-features = false } +parking_lot = { version = "0.12.1", default-features = false } +strum = { version = "0.26", default-features = false } +rhai = { version = "1.21", default-features = false } +mlua = { version = "0.10", default-features = false } +log = { version = "0.4", default-features = false } +env_logger = { version = "0.11", default-features = false } +clap = { version = "4", default-features = false } +mdbook = { version = "0.4", default-features = false } +quote = { version = "1.0", default-features = false } +syn = { version = "2.0", default-features = false } +proc-macro2 = { version = "1.0", default-features = false } +smallvec = { version = "1.11", default-features = false } +itertools = { version = "0.14", default-features = false } +fixedbitset = { version = "0.5", default-features = false } +variadics_please = { version = "1.1.0", default-features = false } +anyhow = { version = "1.0", default-features = false } + + +# development and testing + +pretty_assertions = { version = "1.4", default-features = false } +manifest-dir-macros = { version = "0.1.18", default-features = false } +assert_cmd = { version = "2.0", default-features = false } +tokio = { version = "1", default-features = false } +bevy_console = { version = "0.14", default-features = false } +tracing-tracy = { version = "0.11", default-features = false } +libtest-mimic = { version = "0.8", default-features = false } +criterion = { version = "0.5", default-features = false } +rand = { version = "0.9", default-features = false } +rand_chacha = { version = "0.9", default-features = false } [dev-dependencies] -bevy = { workspace = true, default-features = true, features = ["std"] } -clap = { version = "4.1", features = ["derive"] } -rand = "0.9.1" -criterion = { version = "0.5" } -ladfile_builder = { path = "crates/ladfile_builder", version = "0.5.1" } +clap = { workspace = true, features = ["derive"] } +rand = { workspace = true } +criterion = { workspace = true } +ladfile_builder = { workspace = true } script_integration_test_harness = { workspace = true } test_utils = { workspace = true } -libtest-mimic = "0.8" -tracing-tracy = "0.11" -regex = "1.11" -bevy_console = "0.14" +libtest-mimic = { workspace = true } +tracing-tracy = { workspace = true } +regex = { workspace = true } +bevy_console = { workspace = true } + [workspace] members = [ diff --git a/codegen/templates/import.tera b/codegen/templates/import.tera index 638bc89bf0..4d690d6293 100644 --- a/codegen/templates/import.tera +++ b/codegen/templates/import.tera @@ -1,7 +1 @@ -{%- if import is starting_with("bevy_") -%} -bevy::{{- import | substring(start=5) -}} -{%- elif import is starting_with("glam::") -%} -bevy::math::{{- import | substring(start=6) -}} -{%- else -%} -::{{import}} -{%- endif -%} \ No newline at end of file +::{{import}} \ No newline at end of file diff --git a/crates/bevy_mod_scripting_core/Cargo.toml b/crates/bevy_mod_scripting_core/Cargo.toml index 3aaf153f6b..57d8ed1aab 100644 --- a/crates/bevy_mod_scripting_core/Cargo.toml +++ b/crates/bevy_mod_scripting_core/Cargo.toml @@ -25,29 +25,32 @@ mlua_impls = ["mlua"] rhai_impls = ["rhai"] [dependencies] -mlua = { version = "0.10", default-features = false, optional = true } -rhai = { version = "1.21", default-features = false, features = [ - "sync", -], optional = true } -bevy = { workspace = true, default-features = false, features = [ - "bevy_asset", - "std", -] } -parking_lot = "0.12.1" -smallvec = "1.11" -itertools = "0.14" +mlua = { workspace = true, optional = true } +rhai = { workspace = true, features = ["sync"], optional = true } + +bevy_reflect = { workspace = true, default-features = false, features = [] } +bevy_ecs = { workspace = true, default-features = false, features = [] } +bevy_app = { workspace = true, default-features = false, features = [] } +bevy_log = { workspace = true, default-features = false, features = [] } +bevy_asset = { workspace = true, default-features = false, features = [] } +bevy_diagnostic = { workspace = true, default-features = false, features = [] } +bevy_platform = { workspace = true, default-features = false, features = [] } + +parking_lot = { workspace = true } +smallvec = { workspace = true } +itertools = { workspace = true } profiling = { workspace = true } bevy_mod_scripting_derive = { workspace = true } -fixedbitset = "0.5" -bevy_system_reflection = { path = "../bevy_system_reflection", version = "0.2.0" } -serde = { version = "1.0", features = ["derive"] } -uuid = "1.11" -variadics_please = "1.1.0" +fixedbitset = { workspace = true } +bevy_system_reflection = { workspace = true } +serde = { workspace = true, features = ["derive"] } +uuid = { workspace = true } +variadics_please = { workspace = true } [dev-dependencies] test_utils = { workspace = true } -tokio = { version = "1", features = ["rt", "macros"] } -pretty_assertions = "1.4" +tokio = { workspace = true, features = ["rt", "macros"] } +pretty_assertions = { workspace = true } [lints] workspace = true diff --git a/crates/bevy_mod_scripting_core/src/asset.rs b/crates/bevy_mod_scripting_core/src/asset.rs index 9e0c5e955e..ef2e07937e 100644 --- a/crates/bevy_mod_scripting_core/src/asset.rs +++ b/crates/bevy_mod_scripting_core/src/asset.rs @@ -2,15 +2,22 @@ use std::{borrow::Cow, collections::VecDeque}; -use bevy::{ - app::{App, Last}, - asset::{Asset, AssetEvent, AssetLoader, Assets, LoadState}, - log::{error, trace, warn, warn_once}, - prelude::{ - AssetServer, Commands, Entity, EventReader, EventWriter, IntoScheduleConfigs, Local, Query, - Res, - }, - reflect::Reflect, +use ::{ + bevy_app::{App, Last}, + bevy_asset::{Asset, AssetEvent, AssetLoader, Assets, LoadState}, + bevy_log::{error, trace, warn, warn_once}, + // prelude::{ + // AssetServer, Commands, Entity, EventReader, EventWriter, IntoScheduleConfigs, Local, Query, + // Res, + // }, + bevy_reflect::Reflect, +}; +use bevy_asset::AssetServer; +use bevy_ecs::{ + entity::Entity, + event::{EventReader, EventWriter}, + schedule::IntoScheduleConfigs, + system::{Commands, Local, Query, Res}, }; use serde::{Deserialize, Serialize}; @@ -128,9 +135,9 @@ impl AssetLoader for ScriptAssetLoader { async fn load( &self, - reader: &mut dyn bevy::asset::io::Reader, + reader: &mut dyn bevy_asset::io::Reader, settings: &Self::Settings, - load_context: &mut bevy::asset::LoadContext<'_>, + load_context: &mut bevy_asset::LoadContext<'_>, ) -> Result { let mut content = Vec::new(); reader @@ -147,6 +154,7 @@ impl AssetLoader for ScriptAssetLoader { .and_then(|e| e.to_str()) .unwrap_or_default(); self.language_extensions + .0 .get(ext) .cloned() .unwrap_or_else(|| { @@ -333,7 +341,7 @@ pub(crate) fn configure_asset_systems(app: &mut App) { .configure_sets( Last, ( - ScriptingSystemSet::ScriptAssetDispatch.after(bevy::asset::AssetEvents), + ScriptingSystemSet::ScriptAssetDispatch.after(bevy_asset::AssetEvents), ScriptingSystemSet::ScriptCommandDispatch .after(ScriptingSystemSet::ScriptAssetDispatch), ), @@ -351,104 +359,102 @@ pub(crate) fn configure_asset_systems_for_plugin(app: #[cfg(test)] mod tests { - use std::path::PathBuf; - use bevy::{ - MinimalPlugins, - app::App, - asset::{AssetApp, AssetPath, AssetPlugin, AssetServer, Assets, Handle, LoadState}, + use ::{ + bevy_app::App, + bevy_asset::{AssetServer, Handle, LoadState}, }; use super::*; - fn init_loader_test(loader: ScriptAssetLoader) -> App { - let mut app = App::new(); - app.add_plugins((MinimalPlugins, AssetPlugin::default())); - app.init_asset::(); - app.register_asset_loader(loader); - app - } - - fn for_extension(extension: &'static str) -> ScriptAssetLoader { - let mut language_extensions = LanguageExtensions::default(); - language_extensions.insert(extension, Language::Unknown); - ScriptAssetLoader::new(language_extensions) - } - - fn load_asset(app: &mut App, path: &str) -> Handle { - let handle = app.world_mut().resource::().load(path); - - loop { - let state = app - .world() - .resource::() - .get_load_state(&handle) - .unwrap(); - if !matches!(state, LoadState::Loading) { - break; - } - app.update(); - } - - match app - .world() - .resource::() - .get_load_state(&handle) - .unwrap() - { - LoadState::NotLoaded => panic!("Asset not loaded"), - LoadState::Loaded => {} - LoadState::Failed(asset_load_error) => { - panic!("Asset load failed: {asset_load_error:?}") - } - _ => panic!("Unexpected load state"), - } - - handle - } - - #[test] - fn test_asset_loader_loads() { - let loader = for_extension("script"); - let mut app = init_loader_test(loader); - - let handle = load_asset(&mut app, "test_assets/test_script.script"); - let asset = app - .world() - .get_resource::>() - .unwrap() - .get(&handle) - .unwrap(); - - assert_eq!( - String::from_utf8(asset.content.clone().to_vec()).unwrap(), - "test script".to_string() - ); - } - - #[test] - fn test_asset_loader_applies_preprocessor() { - let loader = for_extension("script").with_preprocessor(Box::new(|content| { - content[0] = b'p'; - Ok(()) - })); - let mut app = init_loader_test(loader); - - let handle = load_asset(&mut app, "test_assets/test_script.script"); - let asset = app - .world() - .get_resource::>() - .unwrap() - .get(&handle) - .unwrap(); - - assert_eq!( - handle.path().unwrap(), - &AssetPath::from(PathBuf::from("test_assets/test_script.script")) - ); - assert_eq!( - String::from_utf8(asset.content.clone().to_vec()).unwrap(), - "pest script".to_string() - ); - } + // fn init_loader_test(loader: ScriptAssetLoader) -> App { + // let mut app = App::new(); + // app.add_plugins((MinimalPlugins, AssetPlugin::default())); + // app.init_asset::(); + // app.register_asset_loader(loader); + // app + // } + + // fn for_extension(extension: &'static str) -> ScriptAssetLoader { + // let mut language_extensions = LanguageExtensions::default(); + // language_extensions.insert(extension, Language::Unknown); + // ScriptAssetLoader::new(language_extensions) + // } + + // fn load_asset(app: &mut App, path: &str) -> Handle { + // let handle = app.world_mut().resource::().load(path); + + // loop { + // let state = app + // .world() + // .resource::() + // .get_load_state(&handle) + // .unwrap(); + // if !matches!(state, LoadState::Loading) { + // break; + // } + // app.update(); + // } + + // match app + // .world() + // .resource::() + // .get_load_state(&handle) + // .unwrap() + // { + // LoadState::NotLoaded => panic!("Asset not loaded"), + // LoadState::Loaded => {} + // LoadState::Failed(asset_load_error) => { + // panic!("Asset load failed: {asset_load_error:?}") + // } + // _ => panic!("Unexpected load state"), + // } + + // handle + // } + + // #[test] + // fn test_asset_loader_loads() { + // let loader = for_extension("script"); + // let mut app = init_loader_test(loader); + + // let handle = load_asset(&mut app, "test_assets/test_script.script"); + // let asset = app + // .world() + // .get_resource::>() + // .unwrap() + // .get(&handle) + // .unwrap(); + + // assert_eq!( + // String::from_utf8(asset.content.clone().to_vec()).unwrap(), + // "test script".to_string() + // ); + // } + + // #[test] + // fn test_asset_loader_applies_preprocessor() { + // let loader = for_extension("script").with_preprocessor(Box::new(|content| { + // content[0] = b'p'; + // Ok(()) + // })); + // let mut app = init_loader_test(loader); + + // let handle = load_asset(&mut app, "test_assets/test_script.script"); + // let asset = app + // .world() + // .get_resource::>() + // .unwrap() + // .get(&handle) + // .unwrap(); + + // assert_eq!( + // handle.path().unwrap(), + // &AssetPath::from(PathBuf::from("test_assets/test_script.script")) + // ); + // assert_eq!( + // String::from_utf8(asset.content.clone().to_vec()).unwrap(), + // "pest script".to_string() + // ); + // } } diff --git a/crates/bevy_mod_scripting_core/src/bindings/access_map.rs b/crates/bevy_mod_scripting_core/src/bindings/access_map.rs index d4a290fab0..41afa96c21 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/access_map.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/access_map.rs @@ -1,14 +1,13 @@ //! A map of access claims used to safely and dynamically access the world. -use std::hash::{BuildHasherDefault, Hasher}; +use bevy_platform::collections::{HashMap, HashSet}; -use bevy::{ - ecs::{component::ComponentId, world::unsafe_world_cell::UnsafeWorldCell}, - platform::collections::{HashMap, HashSet}, - prelude::Resource, -}; +use ::bevy_ecs::{component::ComponentId, world::unsafe_world_cell::UnsafeWorldCell}; +use bevy_ecs::{component::Component, resource::Resource}; +use bevy_log::error; use parking_lot::Mutex; use smallvec::SmallVec; +use std::hash::{BuildHasherDefault, Hasher}; use crate::error::InteropError; @@ -160,9 +159,7 @@ impl ReflectAccessId { } /// Creates a new access id for a component - pub fn for_component( - cell: &UnsafeWorldCell, - ) -> Result { + pub fn for_component(cell: &UnsafeWorldCell) -> Result { let component_id = cell.components().component_id::().ok_or_else(|| { InteropError::unregistered_component_or_resource_type(std::any::type_name::()) })?; @@ -414,7 +411,7 @@ impl DynamicSystemMeta for AccessMap { let key = key.as_index(); if key == GLOBAL_KEY { - bevy::log::error!("Trying to claim read access to global key, this is not allowed"); + error!("Trying to claim read access to global key, this is not allowed"); return false; } @@ -440,7 +437,7 @@ impl DynamicSystemMeta for AccessMap { let key = key.as_index(); if key == GLOBAL_KEY { - bevy::log::error!("Trying to claim write access to global key, this is not allowed"); + error!("Trying to claim write access to global key, this is not allowed"); return false; } @@ -1157,9 +1154,11 @@ mod test { let access_map = AccessMap::default(); assert!(access_map.claim_global_access()); - assert!(access_map - .access_location(ReflectAccessId::for_global()) - .is_some()); + assert!( + access_map + .access_location(ReflectAccessId::for_global()) + .is_some() + ); access_map.release_global_access(); // Claim a read access @@ -1182,9 +1181,11 @@ mod test { }; assert!(subset_access_map.claim_global_access()); - assert!(subset_access_map - .access_location(ReflectAccessId::for_global()) - .is_some()); + assert!( + subset_access_map + .access_location(ReflectAccessId::for_global()) + .is_some() + ); subset_access_map.release_global_access(); // Claim a read access diff --git a/crates/bevy_mod_scripting_core/src/bindings/allocator.rs b/crates/bevy_mod_scripting_core/src/bindings/allocator.rs index 62faf05405..efe9f8ca2a 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/allocator.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/allocator.rs @@ -1,14 +1,13 @@ //! An allocator used to control the lifetime of allocations -use bevy::prelude::Resource; -use bevy::{ - app::{App, Plugin, PostUpdate}, - diagnostic::{Diagnostic, DiagnosticPath, Diagnostics, RegisterDiagnostic}, - ecs::system::Res, - platform::collections::HashMap, - prelude::ResMut, - reflect::PartialReflect, +use ::{ + bevy_app::{App, Plugin, PostUpdate}, + bevy_diagnostic::{Diagnostic, DiagnosticPath, Diagnostics, RegisterDiagnostic}, + bevy_ecs::system::Res, + bevy_reflect::PartialReflect, }; +use bevy_ecs::{resource::Resource, system::ResMut}; +use bevy_platform::collections::HashMap; use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard}; use std::{ cell::UnsafeCell, diff --git a/crates/bevy_mod_scripting_core/src/bindings/function/arg_meta.rs b/crates/bevy_mod_scripting_core/src/bindings/function/arg_meta.rs index 165ee33f4f..b79fac1015 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/function/arg_meta.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/function/arg_meta.rs @@ -2,9 +2,12 @@ use std::{ffi::OsString, path::PathBuf}; +use bevy_platform::collections::HashMap; + use crate::{ bindings::{ReflectReference, ScriptValue}, - docgen::TypedThrough, error::InteropError, + docgen::TypedThrough, + error::InteropError, }; use super::{ @@ -88,6 +91,7 @@ impl ArgMeta for Option { impl ArgMeta for Vec {} impl ArgMeta for [T; N] {} +impl ArgMeta for HashMap {} impl ArgMeta for std::collections::HashMap {} impl_arg_info!(DynamicScriptFunction, DynamicScriptFunctionMut); diff --git a/crates/bevy_mod_scripting_core/src/bindings/function/from.rs b/crates/bevy_mod_scripting_core/src/bindings/function/from.rs index c07b25921c..ed9b14c66e 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/function/from.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/function/from.rs @@ -1,11 +1,12 @@ //! This module contains the [`FromScript`] trait and its implemenations. use crate::{ - bindings::{access_map::ReflectAccessId, ReflectReference, WorldGuard}, - error::InteropError, ScriptValue, + bindings::{ReflectReference, WorldGuard, access_map::ReflectAccessId}, + error::InteropError, }; -use bevy::reflect::{FromReflect, Reflect}; +use bevy_platform::collections::HashMap; +use bevy_reflect::{FromReflect, Reflect}; use std::{ any::TypeId, ffi::OsString, @@ -91,7 +92,9 @@ macro_rules! impl_from_with_downcast { }; } -impl_from_with_downcast!(i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, f32, f64, usize, isize); +impl_from_with_downcast!( + i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, f32, f64, usize, isize +); macro_rules! impl_from_stringlike { ($($ty:ty),*) => { @@ -450,7 +453,7 @@ impl FromScript for DynamicScriptFunction { } #[profiling::all_functions] -impl FromScript for std::collections::HashMap +impl FromScript for HashMap where V: FromScript + 'static, for<'w> V::This<'w>: Into, @@ -460,14 +463,14 @@ where fn from_script(value: ScriptValue, world: WorldGuard) -> Result { match value { ScriptValue::Map(map) => { - let mut hashmap = std::collections::HashMap::new(); + let mut hashmap = HashMap::new(); for (key, value) in map { hashmap.insert(key, V::from_script(value, world.clone())?.into()); } Ok(hashmap) } ScriptValue::List(list) => { - let mut hashmap = std::collections::HashMap::new(); + let mut hashmap = HashMap::new(); for elem in list { let (key, val) = <(String, V)>::from_script(elem, world.clone())?; hashmap.insert(key, val); @@ -475,7 +478,7 @@ where Ok(hashmap) } _ => Err(InteropError::value_mismatch( - std::any::TypeId::of::>(), + std::any::TypeId::of::>(), value, )), } diff --git a/crates/bevy_mod_scripting_core/src/bindings/function/from_ref.rs b/crates/bevy_mod_scripting_core/src/bindings/function/from_ref.rs index e5fcbea798..dd07092f94 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/function/from_ref.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/function/from_ref.rs @@ -6,7 +6,7 @@ use crate::{ error::InteropError, reflection_extensions::TypeInfoExtensions, }; -use bevy::reflect::{ +use bevy_reflect::{ DynamicEnum, DynamicList, DynamicMap, DynamicTuple, DynamicVariant, Map, PartialReflect, }; use std::{any::TypeId, ffi::OsString, path::PathBuf}; diff --git a/crates/bevy_mod_scripting_core/src/bindings/function/into.rs b/crates/bevy_mod_scripting_core/src/bindings/function/into.rs index fd48053c1e..c56c9c5821 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/function/into.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/function/into.rs @@ -1,13 +1,13 @@ //! Implementations of the [`IntoScript`] trait for various types. -use bevy::reflect::Reflect; -use std::{borrow::Cow, collections::HashMap, ffi::OsString, path::PathBuf}; - use super::{DynamicScriptFunction, DynamicScriptFunctionMut, Union, Val}; use crate::{ bindings::{ReflectReference, ScriptValue, WorldGuard}, error::InteropError, }; +use bevy_platform::collections::HashMap; +use bevy_reflect::Reflect; +use std::{borrow::Cow, ffi::OsString, path::PathBuf}; /// Converts a value into a [`ScriptValue`]. pub trait IntoScript { @@ -179,6 +179,17 @@ impl IntoScript for HashMap { } } +#[profiling::all_functions] +impl IntoScript for std::collections::HashMap { + fn into_script(self, world: WorldGuard) -> Result { + let mut map = HashMap::new(); + for (key, value) in self { + map.insert(key, value.into_script(world.clone())?); + } + Ok(ScriptValue::Map(map)) + } +} + #[profiling::all_functions] impl IntoScript for InteropError { fn into_script(self, _world: WorldGuard) -> Result { diff --git a/crates/bevy_mod_scripting_core/src/bindings/function/into_ref.rs b/crates/bevy_mod_scripting_core/src/bindings/function/into_ref.rs index ca29e7c8f5..8d29f45722 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/function/into_ref.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/function/into_ref.rs @@ -2,7 +2,7 @@ use std::{borrow::Cow, ffi::OsString, path::PathBuf}; -use bevy::reflect::{Access, PartialReflect}; +use bevy_reflect::{Access, PartialReflect}; use crate::{ bindings::{function::into::IntoScript, ReflectReference, WorldGuard}, diff --git a/crates/bevy_mod_scripting_core/src/bindings/function/magic_functions.rs b/crates/bevy_mod_scripting_core/src/bindings/function/magic_functions.rs index fd54390373..430f0047f8 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/function/magic_functions.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/function/magic_functions.rs @@ -5,7 +5,7 @@ use crate::{ error::InteropError, reflection_extensions::TypeIdExtensions, }; -use bevy::reflect::{ParsedPath, PartialReflect}; +use bevy_reflect::{ParsedPath, PartialReflect}; /// A list of magic methods, these only have one replacable implementation, and apply to all `ReflectReferences`. /// It's up to the language implementer to call these in the right order (after any type specific overrides). diff --git a/crates/bevy_mod_scripting_core/src/bindings/function/mod.rs b/crates/bevy_mod_scripting_core/src/bindings/function/mod.rs index c8a33cee8e..8d239ae12e 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/function/mod.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/function/mod.rs @@ -15,8 +15,10 @@ crate::private::export_all_in_modules! { #[cfg(test)] #[allow(dead_code)] mod test { - use bevy::reflect::{FromReflect, GetTypeRegistration, Reflect, Typed}; + use bevy_ecs::world::World; use bevy_mod_scripting_derive::script_bindings; + use bevy_platform::collections::HashMap; + use bevy_reflect::{FromReflect, GetTypeRegistration, Reflect, Typed}; use crate::bindings::{ function::{ @@ -28,7 +30,7 @@ mod test { }; use super::arg_meta::{ScriptArgument, ScriptReturn, TypedScriptArgument, TypedScriptReturn}; - + use bevy_ecs::prelude::AppTypeRegistry; #[test] fn test_macro_generates_correct_registrator_function() { #[derive(Reflect)] @@ -40,7 +42,7 @@ mod test { fn test_fn(_self: Ref, mut _arg1: usize) {} } - let mut test_world = bevy::ecs::world::World::default(); + let mut test_world = World::default(); register_test_fn(&mut test_world); @@ -190,7 +192,7 @@ mod test { V::Underlying: FromReflect + Typed + GetTypeRegistration + Eq, for<'a> V::This<'a>: Into, { - test_is_valid_arg_and_return::>(); + test_is_valid_arg_and_return::>(); } } diff --git a/crates/bevy_mod_scripting_core/src/bindings/function/namespace.rs b/crates/bevy_mod_scripting_core/src/bindings/function/namespace.rs index 203cf94bf6..65d08c02e9 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/function/namespace.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/function/namespace.rs @@ -4,10 +4,8 @@ use crate::{ bindings::function::script_function::{AppScriptFunctionRegistry, ScriptFunction}, docgen::info::GetFunctionInfo, }; -use bevy::{ - prelude::{AppTypeRegistry, World}, - reflect::{GetTypeRegistration, Reflect}, -}; +use ::bevy_reflect::{GetTypeRegistration, Reflect}; +use bevy_ecs::{reflect::AppTypeRegistry, world::World}; use std::{any::TypeId, borrow::Cow, marker::PhantomData}; use super::type_dependencies::GetFunctionTypeDependencies; diff --git a/crates/bevy_mod_scripting_core/src/bindings/function/script_function.rs b/crates/bevy_mod_scripting_core/src/bindings/function/script_function.rs index 6105ad3d4b..b243294b79 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/function/script_function.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/function/script_function.rs @@ -6,18 +6,20 @@ use crate::asset::Language; use crate::bindings::function::arg_meta::ArgMeta; use crate::docgen::info::{FunctionInfo, GetFunctionInfo}; use crate::{ + ScriptValue, bindings::{ThreadWorldContainer, WorldContainer, WorldGuard}, error::InteropError, - ScriptValue, }; -use bevy::platform::collections::HashMap; -use bevy::prelude::{Reflect, Resource}; +use bevy_ecs::prelude::Resource; +use bevy_platform::collections::HashMap; +use bevy_reflect::Reflect; use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard}; use std::borrow::Cow; use std::collections::VecDeque; use std::hash::Hash; use std::ops::{Deref, DerefMut}; use std::sync::Arc; + #[diagnostic::on_unimplemented( message = "This function does not fulfil the requirements to be a script callable function. All arguments must implement the ScriptArgument trait and all return values must implement the ScriptReturn trait", note = "If you're trying to return a non-primitive type, you might need to use Val Ref or Mut wrappers" @@ -626,10 +628,11 @@ variadics_please::all_tuples!(impl_script_function, 0, 13, T); #[cfg(test)] mod test { - use super::*; + use super::*; + use bevy_ecs::{prelude::Component, world::World}; - fn with_local_world(f: F) { - let mut world = bevy::prelude::World::default(); + fn with_local_world(f: F) { + let mut world = World::default(); WorldGuard::with_static_guard(&mut world, |world| { ThreadWorldContainer.set_world(world).unwrap(); f() @@ -693,7 +696,7 @@ mod test { #[test] fn test_interrupted_call_releases_access_scope() { - #[derive(bevy::prelude::Component, Reflect)] + #[derive(Component, Reflect)] struct Comp; let fn_ = |_a: crate::bindings::function::from::Mut| 0usize; diff --git a/crates/bevy_mod_scripting_core/src/bindings/function/type_dependencies.rs b/crates/bevy_mod_scripting_core/src/bindings/function/type_dependencies.rs index e02dc601af..dd5b85f8ff 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/function/type_dependencies.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/function/type_dependencies.rs @@ -1,17 +1,19 @@ //! This module contains the [`GetTypeDependencies`] trait and its implementations for various types. use super::{ - from::{Mut, Ref, Union, Val}, - script_function::FunctionCallContext, DynamicScriptFunction, DynamicScriptFunctionMut, + DynamicScriptFunction, DynamicScriptFunctionMut, + from::{Mut, Ref, Union, Val}, + script_function::FunctionCallContext, }; use crate::{ - bindings::{ReflectReference, ScriptValue}, error::InteropError} -; -use bevy::reflect::{FromReflect, GetTypeRegistration, TypeRegistry, Typed}; + bindings::{ReflectReference, ScriptValue}, + error::InteropError, +}; use bevy_mod_scripting_derive::impl_get_type_dependencies; -use std::{collections::HashMap, ffi::OsString, hash::Hash, path::PathBuf}; - - +use bevy_platform::collections::HashMap; +use bevy_reflect::{FromReflect, GetTypeRegistration, TypeRegistry, Typed}; +use std::collections::HashMap as StdHashMap; +use std::{ffi::OsString, hash::Hash, path::PathBuf}; macro_rules! impl_get_type_dependencies_primitives { ($($ty:ty),*) => { @@ -26,12 +28,31 @@ macro_rules! impl_get_type_dependencies_primitives { } impl_get_type_dependencies_primitives!( - i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, usize, isize, f32, f64, bool, - ScriptValue, DynamicScriptFunction, DynamicScriptFunctionMut, InteropError, - String, PathBuf, OsString, char + i8, + i16, + i32, + i64, + i128, + u8, + u16, + u32, + u64, + u128, + usize, + isize, + f32, + f64, + bool, + ScriptValue, + DynamicScriptFunction, + DynamicScriptFunctionMut, + InteropError, + String, + PathBuf, + OsString, + char ); - impl GetTypeDependencies for () { type Underlying = (); fn register_type_dependencies(registry: &mut TypeRegistry) { @@ -58,75 +79,91 @@ pub trait GetTypeDependencies { impl_get_type_dependencies!( #[derive(GetTypeDependencies)] - #[get_type_dependencies(bms_core_path="crate")] - struct HashMap where + #[get_type_dependencies(bms_core_path = "crate")] + struct HashMap + where K::Underlying: FromReflect + Eq + Hash + Typed, - V::Underlying: FromReflect + Typed {} + V::Underlying: FromReflect + Typed, {} ); impl_get_type_dependencies!( #[derive(GetTypeDependencies)] - #[get_type_dependencies(bms_core_path="crate")] - struct Result where - T::Underlying: FromReflect + Typed, - E::Underlying: FromReflect + Typed {} + #[get_type_dependencies(bms_core_path = "crate")] + struct StdHashMap + where + K::Underlying: FromReflect + Eq + Hash + Typed, + V::Underlying: FromReflect + Typed, {} ); impl_get_type_dependencies!( #[derive(GetTypeDependencies)] - #[get_type_dependencies(bms_core_path="crate")] - struct Option where - T::Underlying: FromReflect + Typed {} + #[get_type_dependencies(bms_core_path = "crate")] + struct Result + where + T::Underlying: FromReflect + Typed, + E::Underlying: FromReflect + Typed, {} ); impl_get_type_dependencies!( #[derive(GetTypeDependencies)] - #[get_type_dependencies(bms_core_path="crate")] - struct Vec where - T::Underlying: FromReflect + Typed {} + #[get_type_dependencies(bms_core_path = "crate")] + struct Option + where + T::Underlying: FromReflect + Typed, {} ); +impl_get_type_dependencies!( + #[derive(GetTypeDependencies)] + #[get_type_dependencies(bms_core_path = "crate")] + struct Vec + where + T::Underlying: FromReflect + Typed, {} +); impl_get_type_dependencies!( #[derive(GetTypeDependencies)] - #[get_type_dependencies(bms_core_path="crate", underlying="Result")] - struct Union where + #[get_type_dependencies( + bms_core_path = "crate", + underlying = "Result" + )] + struct Union + where T1::Underlying: FromReflect + Typed, - T2::Underlying: FromReflect + Typed {} + T2::Underlying: FromReflect + Typed, {} ); impl_get_type_dependencies!( #[derive(GetTypeDependencies)] - #[get_type_dependencies(bms_core_path="crate", underlying="T", dont_recurse)] + #[get_type_dependencies(bms_core_path = "crate", underlying = "T", dont_recurse)] struct Val {} ); impl_get_type_dependencies!( #[derive(GetTypeDependencies)] - #[get_type_dependencies(bms_core_path="crate", underlying="T", dont_recurse)] + #[get_type_dependencies(bms_core_path = "crate", underlying = "T", dont_recurse)] struct Ref<'a, T> {} ); impl_get_type_dependencies!( #[derive(GetTypeDependencies)] - #[get_type_dependencies(bms_core_path="crate", underlying="T", dont_recurse)] + #[get_type_dependencies(bms_core_path = "crate", underlying = "T", dont_recurse)] struct Mut<'a, T> {} ); impl_get_type_dependencies!( #[derive(GetTypeDependencies)] - #[get_type_dependencies(bms_core_path="crate")] - struct ReflectReference where {} + #[get_type_dependencies(bms_core_path = "crate")] + struct ReflectReference {} ); impl_get_type_dependencies!( #[derive(GetTypeDependencies)] - #[get_type_dependencies(bms_core_path="crate")] - struct FunctionCallContext where {} + #[get_type_dependencies(bms_core_path = "crate")] + struct FunctionCallContext {} ); - -impl GetTypeDependencies for [T; N] where +impl GetTypeDependencies for [T; N] +where T: GetTypeDependencies, T::Underlying: FromReflect + Typed, { @@ -138,7 +175,7 @@ impl GetTypeDependencies for [T; N] where macro_rules! register_tuple_dependencies { ($($param:ident),*) => { - impl <$($param),*> $crate::bindings::GetTypeDependencies for ($($param,)*) where + impl <$($param),*> $crate::bindings::GetTypeDependencies for ($($param,)*) where $( $param: GetTypeDependencies, <$param>::Underlying: FromReflect + Typed + GetTypeRegistration, @@ -155,7 +192,6 @@ macro_rules! register_tuple_dependencies { }; } - variadics_please::all_tuples!(register_tuple_dependencies, 1, 14, T); /// A trait collecting type dependency information for a whole function. Used to register everything used by a function with the type registry @@ -166,7 +202,7 @@ pub trait GetFunctionTypeDependencies { macro_rules! impl_script_function_type_dependencies{ ($( $param:ident ),* ) => { - impl GetFunctionTypeDependencies O> for F where + impl GetFunctionTypeDependencies O> for F where O: GetTypeDependencies, F: Fn( $( $param ),* ) -> O, $( diff --git a/crates/bevy_mod_scripting_core/src/bindings/globals/core.rs b/crates/bevy_mod_scripting_core/src/bindings/globals/core.rs index 23de84eb48..72cd9cdd49 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/globals/core.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/globals/core.rs @@ -1,21 +1,22 @@ //! Core globals exposed by the BMS framework -use std::{cell::RefCell, collections::HashMap, sync::Arc}; - -use bevy::{ - app::Plugin, - asset::Handle, - ecs::{entity::Entity, reflect::AppTypeRegistry, world::World}, - reflect::TypeRegistration, +use ::{ + bevy_app::Plugin, + bevy_asset::Handle, + bevy_ecs::{entity::Entity, reflect::AppTypeRegistry, world::World}, + bevy_reflect::TypeRegistration, }; +use bevy_app::App; use bevy_mod_scripting_derive::script_globals; +use bevy_platform::collections::HashMap; +use std::{cell::RefCell, sync::Arc}; use crate::{ asset::ScriptAsset, bindings::{ - function::from::{Union, Val}, ScriptComponentRegistration, ScriptResourceRegistration, ScriptTypeRegistration, WorldGuard, + function::from::{Union, Val}, }, docgen::into_through_type_info, error::InteropError, @@ -51,10 +52,10 @@ thread_local! { } impl Plugin for CoreScriptGlobalsPlugin { - fn build(&self, app: &mut bevy::app::App) { + fn build(&self, app: &mut App) { app.init_resource::(); } - fn finish(&self, app: &mut bevy::app::App) { + fn finish(&self, app: &mut App) { // profiling::function_scope!("app finish"); if self.register_static_references { @@ -68,10 +69,7 @@ impl Plugin for CoreScriptGlobalsPlugin { } #[profiling::function] -fn register_static_core_globals( - world: &mut bevy::ecs::world::World, - filter: fn(&TypeRegistration) -> bool, -) { +fn register_static_core_globals(world: &mut World, filter: fn(&TypeRegistration) -> bool) { let global_registry = world .get_resource_or_init::() .clone(); @@ -144,7 +142,7 @@ impl CoreGlobals { #[cfg(test)] mod test { use super::*; - use bevy::{app::App, reflect::Reflect}; + use ::{bevy_app::App, bevy_reflect::Reflect}; #[test] fn test_register_globals() { diff --git a/crates/bevy_mod_scripting_core/src/bindings/globals/mod.rs b/crates/bevy_mod_scripting_core/src/bindings/globals/mod.rs index 8fd06673b3..c1c983d235 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/globals/mod.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/globals/mod.rs @@ -1,15 +1,15 @@ //! Contains abstractions for exposing "globals" to scripts, in a language-agnostic way. use super::{ + WorldGuard, function::arg_meta::{ScriptReturn, TypedScriptReturn}, script_value::ScriptValue, - WorldGuard, }; use crate::{ - docgen::{into_through_type_info, typed_through::ThroughTypeInfo, TypedThrough}, + docgen::{TypedThrough, into_through_type_info, typed_through::ThroughTypeInfo}, error::InteropError, }; -use bevy::{platform::collections::HashMap, prelude::Resource, reflect::Typed}; +use ::{bevy_ecs::resource::Resource, bevy_platform::collections::HashMap, bevy_reflect::Typed}; use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard}; use std::{any::TypeId, borrow::Cow, sync::Arc}; @@ -251,7 +251,7 @@ impl ScriptGlobalsRegistry { #[cfg(test)] mod test { - use bevy::ecs::world::World; + use bevy_ecs::world::World; use super::*; @@ -294,9 +294,11 @@ mod test { let maker = |_: WorldGuard| Ok(ScriptValue::from(42)); - assert!(registry - .register_documented(Cow::Borrowed("foo"), maker, Cow::Borrowed("This is a test")) - .is_none()); + assert!( + registry + .register_documented(Cow::Borrowed("foo"), maker, Cow::Borrowed("This is a test")) + .is_none() + ); let global = registry.get("foo").unwrap(); assert_eq!(global.documentation.as_deref(), Some("This is a test")); diff --git a/crates/bevy_mod_scripting_core/src/bindings/pretty_print.rs b/crates/bevy_mod_scripting_core/src/bindings/pretty_print.rs index 80b666039c..1f6eddb3a8 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/pretty_print.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/pretty_print.rs @@ -3,14 +3,16 @@ use crate::reflection_extensions::{FakeType, TypeIdExtensions}; use crate::bindings::{ - access_map::ReflectAccessId, script_value::ScriptValue, ReflectAllocationId, ReflectBase, - ReflectBaseType, ReflectReference, WorldGuard, + ReflectAllocationId, ReflectBase, ReflectBaseType, ReflectReference, WorldGuard, + access_map::ReflectAccessId, script_value::ScriptValue, }; -use bevy::{ - ecs::component::ComponentId, - prelude::World, - reflect::{PartialReflect, ReflectRef}, +use ::{ + bevy_ecs::component::ComponentId, + bevy_reflect::{PartialReflect, ReflectRef}, }; +use bevy_ecs::world::World; +use bevy_platform::collections::HashMap; +use bevy_reflect::VariantType; use itertools::Itertools; use std::{ any::{Any, TypeId}, @@ -237,7 +239,7 @@ impl ReflectReferencePrinter { fn pretty_print_value_inner(&self, v: &dyn PartialReflect, output: &mut String) { match v.reflect_ref() { - bevy::reflect::ReflectRef::Struct(s) => { + ReflectRef::Struct(s) => { let field_names = s .get_represented_struct_info() .map(|info| info.field_names()) @@ -301,7 +303,7 @@ impl ReflectReferencePrinter { ReflectRef::Enum(e) => { output.push_str(&e.variant_path()); let bracket_type = match e.variant_type() { - bevy::reflect::VariantType::Tuple => BracketType::Round, + VariantType::Tuple => BracketType::Round, _ => BracketType::Curly, }; let key_vals = e.iter_fields().map(|v| { @@ -603,63 +605,74 @@ impl DisplayWithWorld for String { self.to_string() } } -#[profiling::all_functions] -impl DisplayWithWorld - for std::collections::HashMap -{ - fn display_with_world(&self, world: WorldGuard) -> String { - let mut string = String::new(); - BracketType::Curly.surrounded(&mut string, |string| { - for (i, (k, v)) in self.iter().enumerate() { - string.push_str(&k.display_with_world(world.clone())); - string.push_str(": "); - string.push_str(&v.display_with_world(world.clone())); - if i != self.len() - 1 { - string.push_str(", "); - } + +/// Implements DisplayWithWorld for a HashMap-like type that has key-value pairs +/// and supports iter() and len() methods. +macro_rules! impl_display_with_world_for_map { + ($map_type:path) => { + #[profiling::all_functions] + impl DisplayWithWorld + for $map_type + { + fn display_with_world(&self, world: WorldGuard) -> String { + let mut string = String::new(); + BracketType::Curly.surrounded(&mut string, |string| { + for (i, (k, v)) in self.iter().enumerate() { + string.push_str(&k.display_with_world(world.clone())); + string.push_str(": "); + string.push_str(&v.display_with_world(world.clone())); + if i != self.len() - 1 { + string.push_str(", "); + } + } + }); + string } - }); - string - } - fn display_value_with_world(&self, world: WorldGuard) -> String { - let mut string = String::new(); - BracketType::Curly.surrounded(&mut string, |string| { - for (i, (k, v)) in self.iter().enumerate() { - string.push_str(&k.display_value_with_world(world.clone())); - string.push_str(": "); - string.push_str(&v.display_value_with_world(world.clone())); - if i != self.len() - 1 { - string.push_str(", "); - } + fn display_value_with_world(&self, world: WorldGuard) -> String { + let mut string = String::new(); + BracketType::Curly.surrounded(&mut string, |string| { + for (i, (k, v)) in self.iter().enumerate() { + string.push_str(&k.display_value_with_world(world.clone())); + string.push_str(": "); + string.push_str(&v.display_value_with_world(world.clone())); + if i != self.len() - 1 { + string.push_str(", "); + } + } + }); + string } - }); - string - } - fn display_without_world(&self) -> String { - let mut string = String::new(); - BracketType::Curly.surrounded(&mut string, |string| { - for (i, (k, v)) in self.iter().enumerate() { - string.push_str(&k.display_without_world()); - string.push_str(": "); - string.push_str(&v.display_without_world()); - if i != self.len() - 1 { - string.push_str(", "); - } + fn display_without_world(&self) -> String { + let mut string = String::new(); + BracketType::Curly.surrounded(&mut string, |string| { + for (i, (k, v)) in self.iter().enumerate() { + string.push_str(&k.display_without_world()); + string.push_str(": "); + string.push_str(&v.display_without_world()); + if i != self.len() - 1 { + string.push_str(", "); + } + } + }); + string } - }); - string - } + } + }; } +impl_display_with_world_for_map!(HashMap); +impl_display_with_world_for_map!(std::collections::HashMap); + #[cfg(test)] mod test { - use bevy::{prelude::AppTypeRegistry, reflect::Reflect}; + use bevy_ecs::reflect::AppTypeRegistry; + use bevy_reflect::Reflect; use crate::bindings::{ - function::script_function::AppScriptFunctionRegistry, AppReflectAllocator, - ReflectAllocationId, + AppReflectAllocator, ReflectAllocationId, + function::script_function::AppScriptFunctionRegistry, }; use super::*; @@ -772,7 +785,7 @@ mod test { let mut world = setup_world(); let world = WorldGuard::new_exclusive(&mut world); - let mut map = std::collections::HashMap::new(); + let mut map = HashMap::new(); map.insert("hello".to_owned(), ScriptValue::Bool(true)); assert_eq!(map.display_with_world(world.clone()), "{hello: true}"); diff --git a/crates/bevy_mod_scripting_core/src/bindings/query.rs b/crates/bevy_mod_scripting_core/src/bindings/query.rs index b13fe9f63a..749d6c7e07 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/query.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/query.rs @@ -1,18 +1,18 @@ //! Utilities for querying the world. -use super::{with_global_access, DynamicComponent, ReflectReference, WorldAccessGuard, WorldGuard}; +use bevy_ecs::{ptr::OwningPtr, query::QueryBuilder, world::EntityRef}; + +use super::{DynamicComponent, ReflectReference, WorldAccessGuard, WorldGuard, with_global_access}; use crate::error::InteropError; -use bevy::{ - ecs::{ +use ::{ + bevy_ecs::{ component::ComponentId, entity::Entity, query::{QueryData, QueryState}, reflect::ReflectComponent, world::World, }, - prelude::{EntityRef, QueryBuilder}, - ptr::OwningPtr, - reflect::{ParsedPath, Reflect, TypeRegistration}, + bevy_reflect::{ParsedPath, Reflect, TypeRegistration}, }; use std::{any::TypeId, collections::VecDeque, ptr::NonNull, sync::Arc}; diff --git a/crates/bevy_mod_scripting_core/src/bindings/reference.rs b/crates/bevy_mod_scripting_core/src/bindings/reference.rs index 2e9a02f833..1a4eb318fa 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/reference.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/reference.rs @@ -11,15 +11,17 @@ use crate::{ error::InteropError, reflection_extensions::{PartialReflectExt, TypeIdExtensions}, }; -use bevy::{ - ecs::{ +use ::{ + bevy_ecs::{ change_detection::MutUntyped, component::ComponentId, entity::Entity, world::unsafe_world_cell::UnsafeWorldCell, }, - prelude::{Component, ReflectDefault, Resource}, - ptr::Ptr, - reflect::{ParsedPath, PartialReflect, Reflect, ReflectFromPtr, ReflectPath}, + bevy_reflect::{ + ParsedPath, PartialReflect, Reflect, ReflectFromPtr, ReflectPath, prelude::ReflectDefault, + }, }; +use bevy_ecs::{component::Component, ptr::Ptr, resource::Resource}; +use bevy_reflect::{Access, OffsetAccess, ReflectRef}; use std::{any::TypeId, fmt::Debug}; /// A reference to an arbitrary reflected instance. @@ -85,14 +87,14 @@ impl ReflectReference { /// If this is a reference to something with a length accessible via reflection, returns that length. pub fn len(&self, world: WorldGuard) -> Result, InteropError> { self.with_reflect(world, |r| match r.reflect_ref() { - bevy::reflect::ReflectRef::Struct(s) => Some(s.field_len()), - bevy::reflect::ReflectRef::TupleStruct(ts) => Some(ts.field_len()), - bevy::reflect::ReflectRef::Tuple(t) => Some(t.field_len()), - bevy::reflect::ReflectRef::List(l) => Some(l.len()), - bevy::reflect::ReflectRef::Array(a) => Some(a.len()), - bevy::reflect::ReflectRef::Map(m) => Some(m.len()), - bevy::reflect::ReflectRef::Set(s) => Some(s.len()), - bevy::reflect::ReflectRef::Enum(e) => Some(e.field_len()), + ReflectRef::Struct(s) => Some(s.field_len()), + ReflectRef::TupleStruct(ts) => Some(ts.field_len()), + ReflectRef::Tuple(t) => Some(t.field_len()), + ReflectRef::List(l) => Some(l.len()), + ReflectRef::Array(a) => Some(a.len()), + ReflectRef::Map(m) => Some(m.len()), + ReflectRef::Set(s) => Some(s.len()), + ReflectRef::Enum(e) => Some(e.field_len()), _ => None, }) } @@ -543,16 +545,16 @@ pub trait ReflectionPathExt { /// Returns true if the path is empty fn is_empty(&self) -> bool; /// Returns an iterator over the accesses - fn iter(&self) -> impl Iterator; + fn iter(&self) -> impl Iterator; } #[profiling::all_functions] impl ReflectionPathExt for ParsedPath { /// Assumes the accesses are 1 indexed and converts them to 0 indexed fn convert_to_0_indexed(&mut self) { self.0.iter_mut().for_each(|a| match a.access { - bevy::reflect::Access::FieldIndex(ref mut i) => *i -= 1, - bevy::reflect::Access::TupleIndex(ref mut i) => *i -= 1, - bevy::reflect::Access::ListIndex(ref mut i) => *i -= 1, + Access::FieldIndex(ref mut i) => *i -= 1, + Access::TupleIndex(ref mut i) => *i -= 1, + Access::ListIndex(ref mut i) => *i -= 1, _ => {} }); } @@ -561,7 +563,7 @@ impl ReflectionPathExt for ParsedPath { self.0.is_empty() } - fn iter(&self) -> impl Iterator { + fn iter(&self) -> impl Iterator { self.0.iter() } } @@ -615,8 +617,8 @@ impl ReflectRefIter { } } -const fn list_index_access(index: usize) -> bevy::reflect::Access<'static> { - bevy::reflect::Access::ListIndex(index) +const fn list_index_access(index: usize) -> Access<'static> { + Access::ListIndex(index) } #[profiling::all_functions] impl Iterator for ReflectRefIter { @@ -641,7 +643,9 @@ impl Iterator for ReflectRefIter { #[cfg(test)] mod test { - use bevy::prelude::{AppTypeRegistry, World}; + use bevy_ecs::{ + component::Component, reflect::AppTypeRegistry, resource::Resource, world::World, + }; use crate::bindings::{ AppReflectAllocator, function::script_function::AppScriptFunctionRegistry, @@ -650,10 +654,10 @@ mod test { use super::*; #[derive(Reflect, Component, Debug, Clone, PartialEq)] - struct Component(Vec); + struct TestComponent(Vec); #[derive(Reflect, Resource, Debug, Clone, PartialEq)] - struct Resource(Vec); + struct TestResource(Vec); fn setup_world() -> World { let mut world = World::default(); @@ -661,8 +665,8 @@ mod test { let type_registry = AppTypeRegistry::default(); { let mut guard_type_registry = type_registry.write(); - guard_type_registry.register::(); - guard_type_registry.register::(); + guard_type_registry.register::(); + guard_type_registry.register::(); } world.insert_resource(type_registry); @@ -681,13 +685,13 @@ mod test { let mut world = setup_world(); let entity = world - .spawn(Component(vec!["hello".to_owned(), "world".to_owned()])) + .spawn(TestComponent(vec!["hello".to_owned(), "world".to_owned()])) .id(); let world_guard = WorldGuard::new_exclusive(&mut world); let mut component_ref = - ReflectReference::new_component_ref::(entity, world_guard.clone()) + ReflectReference::new_component_ref::(entity, world_guard.clone()) .expect("could not create component reference"); // index into component @@ -696,13 +700,16 @@ mod test { .tail_type_id(world_guard.clone()) .unwrap() .unwrap(), - TypeId::of::() + TypeId::of::() ); component_ref .with_reflect(world_guard.clone(), |s| { - let s = s.try_downcast_ref::().unwrap(); - assert_eq!(s, &Component(vec!["hello".to_owned(), "world".to_owned()])); + let s = s.try_downcast_ref::().unwrap(); + assert_eq!( + s, + &TestComponent(vec!["hello".to_owned(), "world".to_owned()]) + ); }) .unwrap(); @@ -762,12 +769,13 @@ mod test { fn test_resource_ref() { let mut world = setup_world(); - world.insert_resource(Resource(vec!["hello".to_owned(), "world".to_owned()])); + world.insert_resource(TestResource(vec!["hello".to_owned(), "world".to_owned()])); let world_guard = WorldGuard::new_exclusive(&mut world); - let mut resource_ref = ReflectReference::new_resource_ref::(world_guard.clone()) - .expect("could not create resource reference"); + let mut resource_ref = + ReflectReference::new_resource_ref::(world_guard.clone()) + .expect("could not create resource reference"); // index into resource assert_eq!( @@ -775,13 +783,16 @@ mod test { .tail_type_id(world_guard.clone()) .unwrap() .unwrap(), - TypeId::of::() + TypeId::of::() ); resource_ref .with_reflect(world_guard.clone(), |s| { - let s = s.try_downcast_ref::().unwrap(); - assert_eq!(s, &Resource(vec!["hello".to_owned(), "world".to_owned()])); + let s = s.try_downcast_ref::().unwrap(); + assert_eq!( + s, + &TestResource(vec!["hello".to_owned(), "world".to_owned()]) + ); }) .unwrap(); @@ -841,7 +852,7 @@ mod test { fn test_allocation_ref() { let mut world = setup_world(); - let value = Component(vec!["hello".to_owned(), "world".to_owned()]); + let value: TestComponent = TestComponent(vec!["hello".to_owned(), "world".to_owned()]); let world_guard = WorldGuard::new_exclusive(&mut world); let allocator = world_guard.allocator(); @@ -855,13 +866,16 @@ mod test { .tail_type_id(world_guard.clone()) .unwrap() .unwrap(), - TypeId::of::() + TypeId::of::() ); allocation_ref .with_reflect(world_guard.clone(), |s| { - let s = s.try_downcast_ref::().unwrap(); - assert_eq!(s, &Component(vec!["hello".to_owned(), "world".to_owned()])); + let s = s.try_downcast_ref::().unwrap(); + assert_eq!( + s, + &TestComponent(vec!["hello".to_owned(), "world".to_owned()]) + ); }) .unwrap(); diff --git a/crates/bevy_mod_scripting_core/src/bindings/schedule.rs b/crates/bevy_mod_scripting_core/src/bindings/schedule.rs index 41a15353fd..7609ecd07c 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/schedule.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/schedule.rs @@ -1,22 +1,23 @@ //! Dynamic scheduling from scripts -use super::{script_system::ScriptSystemBuilder, WorldAccessGuard}; -use crate::{error::InteropError, IntoScriptPluginParams}; -use bevy::{ - app::{ - First, FixedFirst, FixedLast, FixedMain, FixedPostUpdate, FixedPreUpdate, FixedUpdate, - Last, PostStartup, PostUpdate, PreStartup, PreUpdate, RunFixedMainLoop, Startup, Update, - }, - ecs::{ - schedule::{Schedule, ScheduleLabel, Schedules}, - world::World, - }, - prelude::Resource, +use super::{WorldAccessGuard, script_system::ScriptSystemBuilder}; +use crate::{IntoScriptPluginParams, error::InteropError}; +use ::{ + bevy_app::{ + First, FixedFirst, FixedLast, FixedMain, FixedPostUpdate, FixedPreUpdate, FixedUpdate, + Last, PostStartup, PostUpdate, PreStartup, PreUpdate, RunFixedMainLoop, Startup, Update, + }, + bevy_ecs::{ + schedule::{Schedule, ScheduleLabel, Schedules}, + world::World, + }, }; +use bevy_ecs::resource::Resource; +use bevy_log::debug; +use bevy_platform::collections::HashMap; use bevy_system_reflection::{ReflectSchedule, ReflectSystem}; use parking_lot::RwLock; -use std::{any::TypeId, collections::HashMap, sync::Arc}; - +use std::{any::TypeId, sync::Arc}; #[derive(Default, Clone, Resource)] /// A Send + Sync registry of bevy schedules. pub struct AppScheduleRegistry(Arc>); @@ -173,7 +174,7 @@ impl WorldAccessGuard<'_> { schedule: &ReflectSchedule, builder: ScriptSystemBuilder, ) -> Result { - bevy::log::debug!( + debug!( "Adding script system '{}' for script '{}' to schedule '{}'", builder.name, builder.attachment, @@ -191,18 +192,19 @@ impl WorldAccessGuard<'_> { reason = "tests are there but not working currently" )] mod tests { - use bevy::{ - app::Update, - ecs::{ - schedule::{NodeId, Schedules}, - system::IntoSystem, - }, - }; - use test_utils::make_test_plugin; - - use super::*; - - #[test] + use ::{ + bevy_app::{App, Plugin, Update}, + bevy_ecs::{ + entity::Entity, + schedule::{NodeId, Schedules}, + system::IntoSystem, + }, + }; + use test_utils::make_test_plugin; + + use super::*; + + #[test] fn test_schedule_registry() { let mut registry = ScheduleRegistry::default(); registry.register(Update); @@ -230,7 +232,10 @@ mod tests { let system = ReflectSystem::from_system(&system, NodeId::Set(0)); assert_eq!(system.identifier(), "test_system_generic"); - assert_eq!(system.path(), "bevy_mod_scripting_core::bindings::schedule::tests::test_system_generic"); + assert_eq!( + system.path(), + "bevy_mod_scripting_core::bindings::schedule::tests::test_system_generic" + ); let system = IntoSystem::into_system(test_system); let system = ReflectSystem::from_system(&system, NodeId::Set(0)); @@ -279,7 +284,7 @@ mod tests { /// * `expected_nodes` - A slice of node names expected to be present. /// * `expected_edges` - A slice of tuples representing expected edges (from, to). pub fn verify_schedule_graph( - app: &mut bevy::prelude::App, + app: &mut App, schedule_label: T, expected_nodes: &[&str], expected_edges: &[(&str, &str)], diff --git a/crates/bevy_mod_scripting_core/src/bindings/script_component.rs b/crates/bevy_mod_scripting_core/src/bindings/script_component.rs index b97ad88d46..18725f3d07 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/script_component.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/script_component.rs @@ -2,16 +2,17 @@ use super::{ScriptComponentRegistration, ScriptTypeRegistration, ScriptValue, WorldAccessGuard}; use crate::error::InteropError; -use bevy::{ - app::{App, Plugin}, - ecs::component::{Component, ComponentDescriptor, StorageType, ComponentCloneBehavior, Mutable}, - platform::collections::HashMap, - prelude::Resource, - reflect::{prelude::ReflectDefault, GetTypeRegistration, Reflect}, +use ::{ + bevy_app::{App, Plugin}, + bevy_ecs::component::{ + Component, ComponentCloneBehavior, ComponentDescriptor, Mutable, StorageType, + }, + bevy_reflect::{GetTypeRegistration, Reflect, prelude::ReflectDefault}, }; +use bevy_ecs::resource::Resource; +use bevy_platform::collections::HashMap; use parking_lot::RwLock; use std::{alloc::Layout, mem::needs_drop, sync::Arc}; - /// A dynamic script component #[derive(Reflect, Clone, Default)] #[reflect(Default)] @@ -136,10 +137,11 @@ impl Plugin for DynamicScriptComponentPlugin { #[cfg(test)] mod test { - use super::*; - use bevy::ecs::world::World; + use bevy_ecs::world::World; + + use super::*; - #[test] + #[test] fn test_script_component() { let mut world = World::new(); let registration = { diff --git a/crates/bevy_mod_scripting_core/src/bindings/script_system.rs b/crates/bevy_mod_scripting_core/src/bindings/script_system.rs index d3a48acd98..443f32cdcc 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/script_system.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/script_system.rs @@ -20,8 +20,8 @@ use crate::{ runtime::RuntimeContainer, script::{ScriptAttachment, ScriptContext}, }; -use bevy::{ - ecs::{ +use ::{ + bevy_ecs::{ archetype::{ArchetypeComponentId, ArchetypeGeneration}, component::{ComponentId, Tick}, entity::Entity, @@ -31,13 +31,21 @@ use bevy::{ system::{IntoSystem, System, SystemParamValidationError}, world::{World, unsafe_world_cell::UnsafeWorldCell}, }, - platform::collections::HashSet, - prelude::IntoScheduleConfigs, - reflect::{OffsetAccess, ParsedPath, Reflect}, + bevy_reflect::{OffsetAccess, ParsedPath, Reflect}, }; +use bevy_app::DynEq; +use bevy_ecs::{ + schedule::{InternedSystemSet, IntoScheduleConfigs}, + system::SystemIn, + world::DeferredWorld, +}; +use bevy_log::{error, info, warn_once}; use bevy_system_reflection::{ReflectSchedule, ReflectSystem}; use parking_lot::Mutex; -use std::{any::TypeId, borrow::Cow, hash::Hash, marker::PhantomData, ops::Deref, sync::Arc}; +use std::{ + any::TypeId, borrow::Cow, collections::HashSet, hash::Hash, marker::PhantomData, ops::Deref, + sync::Arc, +}; #[derive(Clone, Hash, PartialEq, Eq)] /// a system set for script systems. pub struct ScriptSystemSet(Cow<'static, str>); @@ -61,11 +69,11 @@ impl ScriptSystemSet { #[profiling::all_functions] impl SystemSet for ScriptSystemSet { - fn dyn_clone(&self) -> bevy::ecs::label::Box { + fn dyn_clone(&self) -> Box { Box::new(self.clone()) } - fn as_dyn_eq(&self) -> &dyn bevy::ecs::label::DynEq { + fn as_dyn_eq(&self) -> &dyn DynEq { self } @@ -172,11 +180,11 @@ impl ScriptSystemBuilder { { for default_set in other.default_system_sets() { if is_before { - bevy::log::info!("before {default_set:?}"); + info!("before {default_set:?}"); system_config = system_config.before(*default_set); } else { - bevy::log::info!("before {default_set:?}"); - bevy::log::info!("after {default_set:?}"); + info!("before {default_set:?}"); + info!("after {default_set:?}"); system_config = system_config.after(*default_set); } } @@ -372,13 +380,11 @@ impl System for DynamicScriptSystem

{ self.name.clone() } - fn component_access(&self) -> &bevy::ecs::query::Access { + fn component_access(&self) -> &Access { self.component_access_set.combined_access() } - fn archetype_component_access( - &self, - ) -> &bevy::ecs::query::Access { + fn archetype_component_access(&self) -> &Access { &self.archetype_component_access } @@ -396,8 +402,8 @@ impl System for DynamicScriptSystem

{ unsafe fn run_unsafe( &mut self, - _input: bevy::ecs::system::SystemIn<'_, Self>, - world: bevy::ecs::world::unsafe_world_cell::UnsafeWorldCell, + _input: SystemIn<'_, Self>, + world: UnsafeWorldCell, ) -> Self::Out { let _change_tick = world.increment_change_tick(); @@ -495,7 +501,7 @@ impl System for DynamicScriptSystem

{ match result { Ok(_) => {} Err(err) => { - bevy::log::error!( + error!( "Error in dynamic script system `{}`: {}", self.name, err.display_with_world(guard) @@ -503,7 +509,7 @@ impl System for DynamicScriptSystem

{ } } } else { - bevy::log::warn_once!( + warn_once!( "Dynamic script system `{}` could not find script for attachment: {}. It will not run until it's loaded.", self.name, self.target_attachment @@ -511,7 +517,7 @@ impl System for DynamicScriptSystem

{ } } - fn initialize(&mut self, world: &mut bevy::ecs::world::World) { + fn initialize(&mut self, world: &mut World) { // we need to register all the: // - resources, simple just need the component ID's // - queries, more difficult the queries need to be built, and archetype access registered on top of component access @@ -598,10 +604,7 @@ impl System for DynamicScriptSystem

{ }) } - fn update_archetype_component_access( - &mut self, - world: bevy::ecs::world::unsafe_world_cell::UnsafeWorldCell, - ) { + fn update_archetype_component_access(&mut self, world: UnsafeWorldCell) { let archetypes = world.archetypes(); let old_generation = @@ -621,7 +624,7 @@ impl System for DynamicScriptSystem

{ } } - fn check_change_tick(&mut self, change_tick: bevy::ecs::component::Tick) { + fn check_change_tick(&mut self, change_tick: Tick) { let last_run = &mut self.last_run; let this_run = change_tick; @@ -631,17 +634,17 @@ impl System for DynamicScriptSystem

{ } } - fn get_last_run(&self) -> bevy::ecs::component::Tick { + fn get_last_run(&self) -> Tick { self.last_run } - fn set_last_run(&mut self, last_run: bevy::ecs::component::Tick) { + fn set_last_run(&mut self, last_run: Tick) { self.last_run = last_run; } fn apply_deferred(&mut self, _world: &mut World) {} - fn queue_deferred(&mut self, _world: bevy::ecs::world::DeferredWorld) {} + fn queue_deferred(&mut self, _world: DeferredWorld) {} unsafe fn validate_param_unsafe( &mut self, @@ -650,7 +653,7 @@ impl System for DynamicScriptSystem

{ Ok(()) } - fn default_system_sets(&self) -> Vec { + fn default_system_sets(&self) -> Vec { vec![ScriptSystemSet::new(self.name.clone()).intern()] } @@ -670,11 +673,14 @@ impl System for DynamicScriptSystem

{ #[cfg(test)] mod test { - use bevy::{ - app::{App, MainScheduleOrder, Update}, - asset::{AssetId, AssetPlugin, Handle}, - diagnostic::DiagnosticsPlugin, - ecs::schedule::{ScheduleLabel, Schedules}, + use ::{ + bevy_app::{App, MainScheduleOrder, Plugin, Update}, + bevy_asset::{AssetId, AssetPlugin, Handle}, + bevy_diagnostic::DiagnosticsPlugin, + bevy_ecs::{ + entity::Entity, + schedule::{ScheduleLabel, Schedules}, + }, }; use test_utils::make_test_plugin; diff --git a/crates/bevy_mod_scripting_core/src/bindings/script_value.rs b/crates/bevy_mod_scripting_core/src/bindings/script_value.rs index 8ffd24cb57..93ed7e0b5c 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/script_value.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/script_value.rs @@ -1,8 +1,8 @@ //! This module contains the `ScriptValue` enum which is used to pass values between scripting languages and Rust. -use std::{borrow::Cow, collections::HashMap}; - -use bevy::reflect::{OffsetAccess, ParsedPath, Reflect}; +use bevy_platform::collections::HashMap; +use bevy_reflect::{Access, OffsetAccess, ParsedPath, Reflect}; +use std::borrow::Cow; use crate::error::InteropError; @@ -170,7 +170,7 @@ impl TryFrom for ParsedPath { fn try_from(value: ScriptValue) -> Result { Ok(match value { ScriptValue::Integer(i) => ParsedPath::from(vec![OffsetAccess { - access: bevy::reflect::Access::ListIndex(i as usize), + access: Access::ListIndex(i as usize), offset: Some(1), }]), ScriptValue::Float(_) => { @@ -185,7 +185,7 @@ impl TryFrom for ParsedPath { && let Ok(index) = tuple_struct_index.parse::() { let parsed_path = ParsedPath::from(vec![OffsetAccess { - access: bevy::reflect::Access::TupleIndex(index), + access: Access::TupleIndex(index), offset: Some(1), }]); return Ok(parsed_path); @@ -217,21 +217,21 @@ mod test { fn test_script_value_to_parsed_path() { let value = ScriptValue::String("test".into()); let parsed_path = ParsedPath::from(vec![OffsetAccess { - access: bevy::reflect::Access::Field("test".to_owned().into()), + access: Access::Field("test".to_owned().into()), offset: Some(4), }]); assert_eq!(parsed_path, ParsedPath::try_from(value).unwrap()); let value = ScriptValue::String("_0".into()); let parsed_path = ParsedPath::from(vec![OffsetAccess { - access: bevy::reflect::Access::TupleIndex(0), + access: Access::TupleIndex(0), offset: Some(1), }]); assert_eq!(parsed_path, ParsedPath::try_from(value).unwrap()); let value = ScriptValue::Integer(0); let parsed_path = ParsedPath::from(vec![OffsetAccess { - access: bevy::reflect::Access::ListIndex(0), + access: Access::ListIndex(0), offset: Some(1), }]); assert_eq!(parsed_path, ParsedPath::try_from(value).unwrap()); diff --git a/crates/bevy_mod_scripting_core/src/bindings/type_data.rs b/crates/bevy_mod_scripting_core/src/bindings/type_data.rs index dd3b06e12d..ebfb28afe1 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/type_data.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/type_data.rs @@ -1,6 +1,6 @@ //! Contains various `Reflect` type data we use in BMS. -use bevy::reflect::FromType; +use bevy_reflect::FromType; /// A marker type to indicate that a type is generated. /// diff --git a/crates/bevy_mod_scripting_core/src/bindings/world.rs b/crates/bevy_mod_scripting_core/src/bindings/world.rs index 33958eb3b9..2731694abd 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/world.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/world.rs @@ -6,6 +6,9 @@ //! we need wrapper types which have owned and ref variants. use super::{ + AppReflectAllocator, AppScriptComponentRegistry, ReflectBase, ReflectBaseType, + ReflectReference, ScriptComponentRegistration, ScriptResourceRegistration, + ScriptTypeRegistration, Union, access_map::{ AccessCount, AccessMapKey, AnyAccessMap, DynamicSystemMeta, ReflectAccessId, ReflectAccessKind, SubsetAccessMap, @@ -17,9 +20,7 @@ use super::{ pretty_print::DisplayWithWorld, schedule::AppScheduleRegistry, script_value::ScriptValue, - with_global_access, AppReflectAllocator, AppScriptComponentRegistry, ReflectBase, - ReflectBaseType, ReflectReference, ScriptComponentRegistration, ScriptResourceRegistration, - ScriptTypeRegistration, Union, + with_global_access, }; use crate::{ asset::ScriptAsset, @@ -32,33 +33,37 @@ use crate::{ reflection_extensions::PartialReflectExt, script::{ScriptAttachment, ScriptComponent}, }; -use bevy::ecs::{component::Mutable, system::Command}; -use bevy::prelude::{ChildOf, Children}; -use bevy::{ - app::AppExit, - asset::{AssetServer, Handle, LoadState}, - ecs::{ +use ::{ + bevy_app::AppExit, + bevy_asset::{AssetServer, Handle, LoadState}, + bevy_ecs::{ component::{Component, ComponentId}, entity::Entity, prelude::Resource, reflect::{AppTypeRegistry, ReflectFromWorld, ReflectResource}, system::Commands, - world::{unsafe_world_cell::UnsafeWorldCell, CommandQueue, Mut, World}, + world::{CommandQueue, Mut, World, unsafe_world_cell::UnsafeWorldCell}, }, - reflect::{ - std_traits::ReflectDefault, DynamicEnum, DynamicStruct, DynamicTuple, DynamicTupleStruct, - DynamicVariant, ParsedPath, PartialReflect, TypeRegistryArc, + bevy_reflect::{ + DynamicEnum, DynamicStruct, DynamicTuple, DynamicTupleStruct, DynamicVariant, ParsedPath, + PartialReflect, TypeRegistryArc, std_traits::ReflectDefault, }, }; +use bevy_ecs::{ + component::Mutable, + hierarchy::{ChildOf, Children}, + system::Command, +}; +use bevy_platform::collections::HashMap; +use bevy_reflect::{TypeInfo, VariantInfo}; use bevy_system_reflection::ReflectSchedule; use std::{ any::TypeId, borrow::Cow, cell::RefCell, - collections::HashMap, fmt::Debug, rc::Rc, - sync::{atomic::AtomicBool, Arc}, + sync::{Arc, atomic::AtomicBool}, }; /// Prefer to directly using [`WorldAccessGuard`]. If the underlying type changes, this alias will be updated. @@ -697,7 +702,7 @@ impl WorldAccessGuard<'_> { // then build the corresponding dynamic structure, whatever it may be let dynamic: Box = match type_info { - bevy::reflect::TypeInfo::Struct(struct_info) => { + TypeInfo::Struct(struct_info) => { let fields_iter = struct_info .field_names() .iter() @@ -719,7 +724,7 @@ impl WorldAccessGuard<'_> { dynamic.set_represented_type(Some(type_info)); Box::new(dynamic) } - bevy::reflect::TypeInfo::TupleStruct(tuple_struct_info) => { + TypeInfo::TupleStruct(tuple_struct_info) => { let fields_iter = (0..tuple_struct_info.field_len()) .map(|f| { Ok(tuple_struct_info @@ -738,7 +743,7 @@ impl WorldAccessGuard<'_> { dynamic.set_represented_type(Some(type_info)); Box::new(dynamic) } - bevy::reflect::TypeInfo::Tuple(tuple_info) => { + TypeInfo::Tuple(tuple_info) => { let fields_iter = (0..tuple_info.field_len()) .map(|f| { Ok(tuple_info @@ -757,7 +762,7 @@ impl WorldAccessGuard<'_> { dynamic.set_represented_type(Some(type_info)); Box::new(dynamic) } - bevy::reflect::TypeInfo::Enum(enum_info) => { + TypeInfo::Enum(enum_info) => { // extract variant from "variant" let variant = payload.remove("variant").ok_or_else(|| { InteropError::missing_data_in_constructor( @@ -773,7 +778,7 @@ impl WorldAccessGuard<'_> { })?; let variant = match variant { - bevy::reflect::VariantInfo::Struct(struct_variant_info) => { + VariantInfo::Struct(struct_variant_info) => { // same as above struct variant let fields_iter = struct_variant_info .field_names() @@ -796,7 +801,7 @@ impl WorldAccessGuard<'_> { let dynamic = self.construct_dynamic_struct(&mut payload, fields_iter)?; DynamicVariant::Struct(dynamic) } - bevy::reflect::VariantInfo::Tuple(tuple_variant_info) => { + VariantInfo::Tuple(tuple_variant_info) => { // same as tuple variant let fields_iter = (0..tuple_variant_info.field_len()) .map(|f| { @@ -815,7 +820,7 @@ impl WorldAccessGuard<'_> { self.construct_dynamic_tuple(&mut payload, fields_iter, one_indexed)?; DynamicVariant::Tuple(dynamic) } - bevy::reflect::VariantInfo::Unit(_) => DynamicVariant::Unit, + VariantInfo::Unit(_) => DynamicVariant::Unit, }; let mut dynamic = DynamicEnum::new(variant_name, variant); dynamic.set_represented_type(Some(type_info)); @@ -826,7 +831,7 @@ impl WorldAccessGuard<'_> { Some(type_info.type_id()), Some(Box::new(payload)), "Type constructor not supported", - )) + )); } }; @@ -1311,8 +1316,8 @@ impl WorldContainer for ThreadWorldContainer { #[cfg(test)] mod test { use super::*; - use bevy::reflect::{GetTypeRegistration, ReflectFromReflect}; - use test_utils::test_data::{setup_world, SimpleEnum, SimpleStruct, SimpleTupleStruct}; + use bevy_reflect::{GetTypeRegistration, ReflectFromReflect}; + use test_utils::test_data::{SimpleEnum, SimpleStruct, SimpleTupleStruct, setup_world}; #[test] fn test_construct_struct() { diff --git a/crates/bevy_mod_scripting_core/src/commands.rs b/crates/bevy_mod_scripting_core/src/commands.rs index 2d87449429..e7ca24f216 100644 --- a/crates/bevy_mod_scripting_core/src/commands.rs +++ b/crates/bevy_mod_scripting_core/src/commands.rs @@ -2,13 +2,6 @@ use std::marker::PhantomData; -use bevy::{ - asset::{Assets, Handle}, - ecs::event::Events, - log::{debug, warn}, - prelude::Command, -}; - use crate::{ IntoScriptPluginParams, ScriptContext, asset::ScriptAsset, @@ -23,6 +16,13 @@ use crate::{ handler::{handle_script_errors, send_callback_response}, script::{DisplayProxy, ScriptAttachment, StaticScripts}, }; +use ::{ + bevy_asset::{Assets, Handle}, + bevy_ecs::event::Events, + bevy_log::{debug, warn}, +}; +use bevy_ecs::{system::Command, world::World}; +use bevy_log::{error, info, trace}; /// Detaches a script, invoking the `on_script_unloaded` callback if it exists, and removes the script from the static scripts collection. pub struct DeleteScript { @@ -52,7 +52,7 @@ impl DeleteScript

{ } impl Command for DeleteScript

{ - fn apply(mut self, world: &mut bevy::prelude::World) { + fn apply(mut self, world: &mut World) { // we demote to weak from here on out, so as not to hold the asset hostage self.context_key = self.context_key.into_weak(); @@ -89,13 +89,13 @@ impl Command for DeleteScript

{ let delete_context = residents_count == 1; let script_id = self.context_key.script(); if delete_context && script_contexts.remove(&self.context_key).is_some() { - bevy::log::info!( + info!( "{}: Deleted context for script {:?}", P::LANGUAGE, script_id.display() ); } else { - bevy::log::info!( + info!( "{}: Context for script {:?} was not deleted, as it still has {} residents", P::LANGUAGE, script_id.display(), @@ -151,7 +151,7 @@ impl CreateOrUpdateScript

{ guard: WorldGuard, handler_ctxt: &HandlerContext

, ) -> Result<(), ScriptError> { - bevy::log::debug!("{}: reloading context {}", P::LANGUAGE, attachment); + debug!("{}: reloading context {}", P::LANGUAGE, attachment); // reload context P::reload( attachment, @@ -172,7 +172,7 @@ impl CreateOrUpdateScript

{ guard: WorldGuard, handler_ctxt: &HandlerContext

, ) -> Result { - bevy::log::debug!("{}: loading context {}", P::LANGUAGE, attachment); + debug!("{}: loading context {}", P::LANGUAGE, attachment); let context = P::load( attachment, content, @@ -313,7 +313,7 @@ impl CreateOrUpdateScript

{ ))) })?; - bevy::log::debug!( + debug!( "{}: script {} successfully {}", P::LANGUAGE, attachment, @@ -350,7 +350,7 @@ impl CreateOrUpdateScript

{ #[profiling::all_functions] impl Command for CreateOrUpdateScript

{ - fn apply(self, world: &mut bevy::prelude::World) { + fn apply(self, world: &mut World) { let content = match self.content { Some(content) => content, None => match world @@ -360,7 +360,7 @@ impl Command for CreateOrUpdateScript

{ { Some(content) => content, None => { - bevy::log::error!( + error!( "{}: No content provided for script attachment {}. Cannot attach script.", P::LANGUAGE, self.attachment.script().display() @@ -437,7 +437,7 @@ impl RunScriptCallback

{ ); if self.trigger_response { - bevy::log::trace!( + trace!( "{}: Sending callback response for callback: {}, attachment: {}", P::LANGUAGE, self.callback, @@ -471,7 +471,7 @@ impl RunScriptCallback

{ /// Equivalent to running the command, but also returns the result of the callback. /// /// The returned error will already be handled and logged. - pub fn run(self, world: &mut bevy::prelude::World) -> Result { + pub fn run(self, world: &mut World) -> Result { with_handler_system_state(world, |guard, handler_ctxt: &mut HandlerContext

| { self.run_with_handler(guard, handler_ctxt) }) @@ -479,7 +479,7 @@ impl RunScriptCallback

{ } impl Command for RunScriptCallback

{ - fn apply(self, world: &mut bevy::prelude::World) { + fn apply(self, world: &mut World) { // Internals handle this. let _ = self.run(world); } @@ -498,7 +498,7 @@ impl AddStaticScript { } /// Runs the command emitting the appropriate script event - pub fn run(self, events: &mut bevy::prelude::Events) { + pub fn run(self, events: &mut Events) { events.send(ScriptEvent::Attached { key: ScriptAttachment::StaticScript(self.id.clone()), }); @@ -506,7 +506,7 @@ impl AddStaticScript { } impl Command for AddStaticScript { - fn apply(self, world: &mut bevy::prelude::World) { + fn apply(self, world: &mut World) { let mut events = world.get_resource_or_init::>(); self.run(&mut events); } @@ -534,7 +534,7 @@ impl RemoveStaticScript { #[profiling::all_functions] impl Command for RemoveStaticScript { - fn apply(self, world: &mut bevy::prelude::World) { + fn apply(self, world: &mut World) { let mut events = world.get_resource_or_init::>(); self.run(&mut events); } diff --git a/crates/bevy_mod_scripting_core/src/context.rs b/crates/bevy_mod_scripting_core/src/context.rs index f849f5d00f..bef89a315f 100644 --- a/crates/bevy_mod_scripting_core/src/context.rs +++ b/crates/bevy_mod_scripting_core/src/context.rs @@ -1,6 +1,6 @@ //! Traits and types for managing script contexts. -use bevy::prelude::Resource; +use bevy_ecs::resource::Resource; use crate::{ IntoScriptPluginParams, diff --git a/crates/bevy_mod_scripting_core/src/docgen/info.rs b/crates/bevy_mod_scripting_core/src/docgen/info.rs index 949286c0d3..c8601fb0cf 100644 --- a/crates/bevy_mod_scripting_core/src/docgen/info.rs +++ b/crates/bevy_mod_scripting_core/src/docgen/info.rs @@ -2,7 +2,7 @@ use crate::bindings::function::arg_meta::ArgMeta; use crate::bindings::function::namespace::Namespace; -use bevy::reflect::Reflect; +use bevy_reflect::Reflect; use std::{any::TypeId, borrow::Cow}; use super::typed_through::{ThroughTypeInfo, TypedThrough}; @@ -195,14 +195,14 @@ variadics_please::all_tuples!(impl_documentable, 0, 13, T); #[cfg(test)] mod test { - use crate::{ - bindings::function::from::{Mut, Ref, Val}, - docgen::typed_through::UntypedWrapperKind, - }; + use crate::{ + bindings::function::from::{Mut, Ref, Val}, + docgen::typed_through::UntypedWrapperKind, + }; - use super::*; + use super::*; - #[test] + #[test] fn test_get_function_info() { fn test_fn(a: i32, b: f32) -> f64 { (a as f64) + (b as f64) diff --git a/crates/bevy_mod_scripting_core/src/docgen/typed_through.rs b/crates/bevy_mod_scripting_core/src/docgen/typed_through.rs index 694711af35..995eae56cd 100644 --- a/crates/bevy_mod_scripting_core/src/docgen/typed_through.rs +++ b/crates/bevy_mod_scripting_core/src/docgen/typed_through.rs @@ -3,21 +3,22 @@ use std::{ffi::OsString, path::PathBuf}; -use bevy::reflect::{TypeInfo, Typed}; +use bevy_platform::collections::HashMap; +use bevy_reflect::{TypeInfo, Typed}; use crate::{ - bindings::{ - function::{ - from::{Mut, Ref, Union, Val}, - script_function::{ - DynamicScriptFunction, DynamicScriptFunctionMut, FunctionCallContext, - }, - }, - script_value::ScriptValue, - ReflectReference, - }, - error::InteropError, - reflection_extensions::TypeInfoExtensions, + bindings::{ + ReflectReference, + function::{ + from::{Mut, Ref, Union, Val}, + script_function::{ + DynamicScriptFunction, DynamicScriptFunctionMut, FunctionCallContext, + }, + }, + script_value::ScriptValue, + }, + error::InteropError, + reflection_extensions::TypeInfoExtensions, }; /// All Through types follow one rule: @@ -186,6 +187,15 @@ impl TypedThrough for Vec { } } +impl TypedThrough for HashMap { + fn through_type_info() -> ThroughTypeInfo { + ThroughTypeInfo::TypedWrapper(TypedWrapperKind::HashMap( + Box::new(K::through_type_info()), + Box::new(V::through_type_info()), + )) + } +} + impl TypedThrough for std::collections::HashMap { fn through_type_info() -> ThroughTypeInfo { ThroughTypeInfo::TypedWrapper(TypedWrapperKind::HashMap( @@ -220,7 +230,7 @@ macro_rules! impl_through_typed { $( impl $crate::docgen::typed_through::TypedThrough for $ty { fn through_type_info() -> $crate::docgen::typed_through::ThroughTypeInfo { - $crate::docgen::typed_through::ThroughTypeInfo::TypeInfo(<$ty as bevy::reflect::Typed>::type_info()) + $crate::docgen::typed_through::ThroughTypeInfo::TypeInfo(<$ty as bevy_reflect::Typed>::type_info()) } } )* @@ -269,9 +279,9 @@ variadics_please::all_tuples!(impl_through_typed_tuple, 0, 13, T); #[cfg(test)] mod test { - use super::*; + use super::*; - fn assert_type_info_is_through() { + fn assert_type_info_is_through() { let type_info = T::type_info(); let through_type_info = T::through_type_info(); @@ -355,7 +365,7 @@ mod test { )); assert!(matches!( - std::collections::HashMap::::through_type_info(), + HashMap::::through_type_info(), ThroughTypeInfo::TypedWrapper(TypedWrapperKind::HashMap(..)) )); @@ -388,7 +398,7 @@ mod test { )); assert!(matches!( - into_through_type_info(std::collections::HashMap::::type_info()), + into_through_type_info(HashMap::::type_info()), ThroughTypeInfo::TypedWrapper(TypedWrapperKind::HashMap(..)) )); diff --git a/crates/bevy_mod_scripting_core/src/error.rs b/crates/bevy_mod_scripting_core/src/error.rs index 6c9a2c29fd..14e6d8b9e9 100644 --- a/crates/bevy_mod_scripting_core/src/error.rs +++ b/crates/bevy_mod_scripting_core/src/error.rs @@ -9,14 +9,15 @@ use std::{ sync::Arc, }; -use bevy::{ - asset::{AssetPath, Handle}, - ecs::{ +use bevy_ecs::entity::Entity; + +use ::{ + bevy_asset::{AssetPath, Handle}, + bevy_ecs::{ component::ComponentId, schedule::{ScheduleBuildError, ScheduleNotInitialized}, }, - prelude::Entity, - reflect::{PartialReflect, Reflect}, + bevy_reflect::{PartialReflect, Reflect}, }; use crate::{ @@ -1622,7 +1623,8 @@ impl Default for InteropErrorInner { #[cfg(test)] mod test { - use bevy::prelude::{AppTypeRegistry, World}; + + use bevy_ecs::{reflect::AppTypeRegistry, world::World}; use super::*; use crate::bindings::{ diff --git a/crates/bevy_mod_scripting_core/src/event.rs b/crates/bevy_mod_scripting_core/src/event.rs index efda855d4c..d06c3312f4 100644 --- a/crates/bevy_mod_scripting_core/src/event.rs +++ b/crates/bevy_mod_scripting_core/src/event.rs @@ -2,7 +2,8 @@ use std::sync::Arc; -use bevy::{asset::Handle, ecs::entity::Entity, prelude::Event, reflect::Reflect}; +use ::{bevy_asset::Handle, bevy_ecs::entity::Entity, bevy_reflect::Reflect}; +use bevy_ecs::event::Event; use parking_lot::Mutex; use crate::{ @@ -409,9 +410,10 @@ static FORBIDDEN_KEYWORDS: [&str; 82] = [ mod test { use std::sync::Arc; - use bevy::{ - asset::{AssetId, AssetIndex, Handle}, - ecs::entity::Entity, + use ::{ + bevy_app::{App, Plugin}, + bevy_asset::{AssetId, AssetIndex, Handle}, + bevy_ecs::entity::Entity, }; use parking_lot::Mutex; use test_utils::make_test_plugin; diff --git a/crates/bevy_mod_scripting_core/src/extractors.rs b/crates/bevy_mod_scripting_core/src/extractors.rs index 413113a6e8..38c9e4f966 100644 --- a/crates/bevy_mod_scripting_core/src/extractors.rs +++ b/crates/bevy_mod_scripting_core/src/extractors.rs @@ -7,13 +7,14 @@ use std::{ sync::Arc, }; -use bevy::ecs::{ - component::ComponentId, +use bevy_ecs::{ + archetype::Archetype, + component::{ComponentId, Tick}, query::{Access, AccessConflicts}, resource::Resource, storage::SparseSetIndex, - system::{SystemParam, SystemParamValidationError}, - world::World, + system::{SystemMeta, SystemParam, SystemParamValidationError}, + world::{DeferredWorld, World, unsafe_world_cell::UnsafeWorldCell}, }; use fixedbitset::FixedBitSet; use parking_lot::Mutex; @@ -89,19 +90,16 @@ unsafe impl SystemParam for ResScope<'_, T> { type Item<'world, 'state> = ResScope<'state, T>; - fn init_state( - _world: &mut World, - system_meta: &mut bevy::ecs::system::SystemMeta, - ) -> Self::State { + fn init_state(_world: &mut World, system_meta: &mut SystemMeta) -> Self::State { system_meta.set_has_deferred(); (T::default(), false) } unsafe fn get_param<'world, 'state>( state: &'state mut Self::State, - _system_meta: &bevy::ecs::system::SystemMeta, - world: bevy::ecs::world::unsafe_world_cell::UnsafeWorldCell<'world>, - _change_tick: bevy::ecs::component::Tick, + _system_meta: &SystemMeta, + world: UnsafeWorldCell<'world>, + _change_tick: Tick, ) -> Self::Item<'world, 'state> { state.1 = true; if let Some(mut r) = unsafe { world.get_resource_mut::() } { @@ -110,11 +108,7 @@ unsafe impl SystemParam for ResScope<'_, T> { ResScope(&mut state.0) } - fn apply( - state: &mut Self::State, - _system_meta: &bevy::ecs::system::SystemMeta, - world: &mut bevy::ecs::world::World, - ) { + fn apply(state: &mut Self::State, _system_meta: &SystemMeta, world: &mut World) { if state.1 { world.insert_resource(std::mem::take(&mut state.0)); state.1 = false; @@ -275,10 +269,7 @@ unsafe impl SystemParam for WithWorldGuard<'_, '_, T> { type Item<'world, 'state> = WithWorldGuard<'world, 'state, T>; - fn init_state( - world: &mut bevy::ecs::world::World, - system_meta: &mut bevy::ecs::system::SystemMeta, - ) -> Self::State { + fn init_state(world: &mut World, system_meta: &mut SystemMeta) -> Self::State { // verify there are no accesses previously let other_accessed_components = system_meta.component_access_set().combined_access().clone(); @@ -306,9 +297,9 @@ unsafe impl SystemParam for WithWorldGuard<'_, '_, T> { unsafe fn get_param<'world, 'state>( state: &'state mut Self::State, - system_meta: &bevy::ecs::system::SystemMeta, - world: bevy::ecs::world::unsafe_world_cell::UnsafeWorldCell<'world>, - change_tick: bevy::ecs::component::Tick, + system_meta: &SystemMeta, + world: UnsafeWorldCell<'world>, + change_tick: Tick, ) -> Self::Item<'world, 'state> { // create a guard which can only access the resources/components specified by the system. let guard = WorldAccessGuard::new_exclusive(unsafe { world.world_mut() }); @@ -341,32 +332,24 @@ unsafe impl SystemParam for WithWorldGuard<'_, '_, T> { unsafe fn new_archetype( state: &mut Self::State, - archetype: &bevy::ecs::archetype::Archetype, - system_meta: &mut bevy::ecs::system::SystemMeta, + archetype: &Archetype, + system_meta: &mut SystemMeta, ) { unsafe { T::new_archetype(&mut state.0, archetype, system_meta) } } - fn apply( - state: &mut Self::State, - system_meta: &bevy::ecs::system::SystemMeta, - world: &mut World, - ) { + fn apply(state: &mut Self::State, system_meta: &SystemMeta, world: &mut World) { T::apply(&mut state.0, system_meta, world) } - fn queue( - state: &mut Self::State, - system_meta: &bevy::ecs::system::SystemMeta, - world: bevy::ecs::world::DeferredWorld, - ) { + fn queue(state: &mut Self::State, system_meta: &SystemMeta, world: DeferredWorld) { T::queue(&mut state.0, system_meta, world) } unsafe fn validate_param( state: &Self::State, - system_meta: &bevy::ecs::system::SystemMeta, - world: bevy::ecs::world::unsafe_world_cell::UnsafeWorldCell, + system_meta: &SystemMeta, + world: UnsafeWorldCell, ) -> Result<(), SystemParamValidationError> { unsafe { T::validate_param(&state.0, system_meta, world) } } @@ -414,15 +397,15 @@ pub(crate) fn get_all_access_ids(access: &Access) -> Vec<(ReflectAc #[cfg(test)] mod test { - use bevy::{ - app::{App, Update}, - ecs::{ + use ::{ + bevy_app::{App, Plugin, Update}, + bevy_ecs::{ component::Component, + entity::Entity, event::{Event, EventReader}, system::{Query, ResMut, SystemState}, world::FromWorld, }, - prelude::Resource, }; use test_utils::make_test_plugin; @@ -455,7 +438,7 @@ mod test { ); }; - let mut app = bevy::app::App::new(); + let mut app = App::new(); app.add_systems(Update, system_fn); app.insert_resource(Res); app.world_mut().spawn(Comp); @@ -472,7 +455,7 @@ mod test { pub fn check_with_world_panics_when_used_with_resource_top_level() { let system_fn = |_res: ResMut, mut _guard: WithWorldGuard>| {}; - let mut app = bevy::app::App::new(); + let mut app = App::new(); app.add_systems(Update, system_fn); app.insert_resource(Res); app.world_mut().spawn(Comp); @@ -492,7 +475,7 @@ mod test { let system_fn = |_res: EventReader, mut _guard: WithWorldGuard>| {}; - let mut app = bevy::app::App::new(); + let mut app = App::new(); app.add_systems(Update, system_fn); app.insert_resource(Res); app.world_mut().spawn(Comp); diff --git a/crates/bevy_mod_scripting_core/src/handler.rs b/crates/bevy_mod_scripting_core/src/handler.rs index 01d12e2b97..96d796a0e2 100644 --- a/crates/bevy_mod_scripting_core/src/handler.rs +++ b/crates/bevy_mod_scripting_core/src/handler.rs @@ -1,12 +1,12 @@ //! Contains the logic for handling script callback events -use bevy::{ - ecs::{ +use ::{ + bevy_ecs::{ event::EventCursor, + event::Events, system::{Local, SystemState}, world::{Mut, World}, }, - log::error, - prelude::Events, + bevy_log::error, }; use crate::{ @@ -184,7 +184,7 @@ pub fn send_callback_response(world: WorldGuard, response: ScriptCallbackRespons }); if let Err(err) = err { - bevy::log::error!( + error!( "Failed to send script callback response: {}", err.display_with_world(world.clone()) ); @@ -200,13 +200,13 @@ pub fn handle_script_errors + Clone>(world: Worl }); if let Err(err) = err { - bevy::log::error!( + error!( "Failed to send script error events: {}", err.display_with_world(world.clone()) ); } for error in errors { - bevy::log::error!("{}", error.display_with_world(world.clone())); + error!("{}", error.display_with_world(world.clone())); } } diff --git a/crates/bevy_mod_scripting_core/src/lib.rs b/crates/bevy_mod_scripting_core/src/lib.rs index 4709968f1f..b74775169a 100644 --- a/crates/bevy_mod_scripting_core/src/lib.rs +++ b/crates/bevy_mod_scripting_core/src/lib.rs @@ -2,11 +2,26 @@ //! //! Contains language agnostic systems and types for handling scripting in bevy. +use crate::{ + bindings::MarkAsCore, + context::{ContextLoadFn, ContextReloadFn}, + event::ScriptErrorEvent, +}; use asset::{ Language, ScriptAsset, ScriptAssetLoader, configure_asset_systems, configure_asset_systems_for_plugin, }; -use bevy::{platform::collections::HashMap, prelude::*}; +use bevy_app::{App, Plugin, PostStartup, PostUpdate}; +use bevy_asset::{AssetApp, Handle}; +use bevy_ecs::{ + reflect::{AppTypeRegistry, ReflectComponent}, + resource::Resource, + schedule::SystemSet, + system::{Command, In}, +}; +use bevy_ecs::{schedule::IntoScheduleConfigs, system::IntoSystem}; +use bevy_log::error; +use bevy_platform::collections::HashMap; use bindings::{ AppReflectAllocator, DynamicScriptComponentPlugin, ReflectAllocator, ReflectReference, ScriptTypeRegistration, function::script_function::AppScriptFunctionRegistry, @@ -19,12 +34,7 @@ use event::{ScriptCallbackEvent, ScriptCallbackResponseEvent, ScriptEvent}; use handler::HandlerFn; use runtime::{Runtime, RuntimeContainer, RuntimeInitializer, RuntimeSettings, initialize_runtime}; use script::{ContextPolicy, ScriptComponent, ScriptContext, StaticScripts}; - -use crate::{ - bindings::MarkAsCore, - context::{ContextLoadFn, ContextReloadFn}, - event::ScriptErrorEvent, -}; +use std::ops::{Deref, DerefMut}; pub mod asset; pub mod bindings; @@ -137,7 +147,7 @@ impl Default for ScriptingPlugin

{ #[profiling::all_functions] impl Plugin for ScriptingPlugin

{ - fn build(&self, app: &mut bevy::prelude::App) { + fn build(&self, app: &mut App) { app.insert_resource(self.runtime_settings.clone()) .insert_resource::>(RuntimeContainer { runtime: P::build_runtime(), @@ -399,9 +409,23 @@ pub trait ConfigureScriptAssetSettings { /// Collect the language extensions supported during initialization. /// /// NOTE: This resource is removed after plugin setup. -#[derive(Debug, Resource, Deref, DerefMut)] +#[derive(Debug, Resource)] pub struct LanguageExtensions(HashMap<&'static str, Language>); +impl Deref for LanguageExtensions { + type Target = HashMap<&'static str, Language>; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl DerefMut for LanguageExtensions { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} + impl Default for LanguageExtensions { fn default() -> Self { LanguageExtensions( @@ -436,6 +460,10 @@ impl ConfigureScriptAssetSettings for App { #[cfg(test)] mod test { + use bevy_asset::{AssetPlugin, AssetServer}; + use bevy_ecs::prelude::*; + use bevy_reflect::Reflect; + use super::*; #[tokio::test] diff --git a/crates/bevy_mod_scripting_core/src/reflection_extensions.rs b/crates/bevy_mod_scripting_core/src/reflection_extensions.rs index 7c3b638d28..18ef2a0cfa 100644 --- a/crates/bevy_mod_scripting_core/src/reflection_extensions.rs +++ b/crates/bevy_mod_scripting_core/src/reflection_extensions.rs @@ -5,7 +5,7 @@ use std::{ cmp::max, }; -use bevy::reflect::{PartialReflect, Reflect, ReflectFromReflect, ReflectMut, TypeInfo}; +use bevy_reflect::{PartialReflect, Reflect, ReflectFromReflect, ReflectMut, ReflectRef, TypeInfo}; use crate::{ bindings::{ReflectReference, WorldGuard}, @@ -140,7 +140,7 @@ impl PartialReflectExt for T { } fn as_option(&self) -> Result, InteropError> { - if let bevy::reflect::ReflectRef::Enum(e) = self.reflect_ref() + if let ReflectRef::Enum(e) = self.reflect_ref() && e.is_type(Some("core"), "Option") { if let Some(field) = e.field_at(0) { @@ -159,7 +159,7 @@ impl PartialReflectExt for T { fn as_option_mut(&mut self) -> Result, InteropError> { let type_info = self.get_represented_type_info().map(|ti| ti.type_path()); match self.reflect_mut() { - bevy::reflect::ReflectMut::Enum(e) => { + ReflectMut::Enum(e) => { if let Some(field) = e.field_at_mut(0) { Ok(Some(field)) } else { @@ -174,7 +174,7 @@ impl PartialReflectExt for T { } fn as_list(&self) -> Result, InteropError> { - if let bevy::reflect::ReflectRef::List(l) = self.reflect_ref() { + if let ReflectRef::List(l) = self.reflect_ref() { Ok(l.iter()) } else { Err(InteropError::string_type_mismatch( @@ -254,15 +254,15 @@ impl PartialReflectExt for T { value: Box, ) -> Result<(), InteropError> { match self.reflect_mut() { - bevy::reflect::ReflectMut::List(l) => { + ReflectMut::List(l) => { l.insert(key.as_usize()?, value); Ok(()) } - bevy::reflect::ReflectMut::Map(m) => { + ReflectMut::Map(m) => { m.insert_boxed(key, value); Ok(()) } - bevy::reflect::ReflectMut::Set(s) => { + ReflectMut::Set(s) => { s.insert_boxed(value); Ok(()) } @@ -276,11 +276,11 @@ impl PartialReflectExt for T { fn try_push_boxed(&mut self, value: Box) -> Result<(), InteropError> { match self.reflect_mut() { - bevy::reflect::ReflectMut::List(l) => { + ReflectMut::List(l) => { l.push(value); Ok(()) } - bevy::reflect::ReflectMut::Set(s) => { + ReflectMut::Set(s) => { s.insert_boxed(value); Ok(()) } @@ -303,15 +303,15 @@ impl PartialReflectExt for T { fn try_clear(&mut self) -> Result<(), InteropError> { match self.reflect_mut() { - bevy::reflect::ReflectMut::List(l) => { + ReflectMut::List(l) => { let _ = l.drain(); Ok(()) } - bevy::reflect::ReflectMut::Map(m) => { + ReflectMut::Map(m) => { let _ = m.drain(); Ok(()) } - bevy::reflect::ReflectMut::Set(s) => { + ReflectMut::Set(s) => { let _ = s.drain(); Ok(()) } @@ -328,7 +328,7 @@ impl PartialReflectExt for T { key: &dyn PartialReflect, ) -> Result, InteropError> { match self.reflect_ref() { - bevy::reflect::ReflectRef::Map(m) => Ok(m.get(key)), + ReflectRef::Map(m) => Ok(m.get(key)), _ => Err(InteropError::unsupported_operation( self.get_represented_type_info().map(|ti| ti.type_id()), None, @@ -339,7 +339,7 @@ impl PartialReflectExt for T { fn try_pop_boxed(&mut self) -> Result, InteropError> { match self.reflect_mut() { - bevy::reflect::ReflectMut::List(l) => l.pop().ok_or_else(|| { + ReflectMut::List(l) => l.pop().ok_or_else(|| { InteropError::unsupported_operation( self.get_represented_type_info().map(|ti| ti.type_id()), None, @@ -359,9 +359,9 @@ impl PartialReflectExt for T { key: Box, ) -> Result>, InteropError> { match self.reflect_mut() { - bevy::reflect::ReflectMut::List(l) => Ok(Some(l.remove(key.as_usize()?))), - bevy::reflect::ReflectMut::Map(m) => Ok(m.remove(key.as_partial_reflect())), - bevy::reflect::ReflectMut::Set(s) => { + ReflectMut::List(l) => Ok(Some(l.remove(key.as_usize()?))), + ReflectMut::Map(m) => Ok(m.remove(key.as_partial_reflect())), + ReflectMut::Set(s) => { let removed = s.remove(key.as_partial_reflect()); Ok(removed.then_some(key)) } @@ -375,10 +375,10 @@ impl PartialReflectExt for T { fn element_type_id(&self) -> Option { let elem: TypeId = match self.get_represented_type_info()? { - bevy::reflect::TypeInfo::List(list_info) => list_info.item_ty().id(), - bevy::reflect::TypeInfo::Array(array_info) => array_info.item_ty().id(), - bevy::reflect::TypeInfo::Map(map_info) => map_info.value_ty().id(), - bevy::reflect::TypeInfo::Set(set_info) => set_info.value_ty().id(), + TypeInfo::List(list_info) => list_info.item_ty().id(), + TypeInfo::Array(array_info) => array_info.item_ty().id(), + TypeInfo::Map(map_info) => map_info.value_ty().id(), + TypeInfo::Set(set_info) => set_info.value_ty().id(), _ => return None, }; Some(elem) @@ -386,10 +386,8 @@ impl PartialReflectExt for T { fn key_type_id(&self) -> Option { let key: TypeId = match self.get_represented_type_info()? { - bevy::reflect::TypeInfo::Map(map_info) => map_info.key_ty().id(), - bevy::reflect::TypeInfo::List(_) | bevy::reflect::TypeInfo::Array(_) => { - TypeId::of::() - } + TypeInfo::Map(map_info) => map_info.key_ty().id(), + TypeInfo::List(_) | TypeInfo::Array(_) => TypeId::of::(), _ => return None, }; Some(key) @@ -506,7 +504,8 @@ impl TypeInfoExtensions for TypeInfo { #[cfg(test)] mod test { - use bevy::reflect::{DynamicMap, Map}; + use bevy_platform::collections::HashMap; + use bevy_reflect::{DynamicMap, Map}; use super::*; @@ -651,7 +650,7 @@ mod test { #[test] fn test_try_insert_map() { - let mut map = std::collections::HashMap::::default(); + let mut map = HashMap::::default(); let value = 4; let value_ref: Box = Box::new(value); map.insert(1, 2); @@ -675,13 +674,12 @@ mod test { #[test] fn test_try_insert_dynamic_map_into_map_of_maps() { - let mut map = - std::collections::HashMap::>::default(); + let mut map = HashMap::>::default(); let value = DynamicMap::from_iter(vec![(1, 2), (2, 3), (3, 4)]); let value_ref: Box = Box::new(value.to_dynamic_map()); - map.insert(1, std::collections::HashMap::::default()); - map.insert(2, std::collections::HashMap::::default()); - map.insert(3, std::collections::HashMap::::default()); + map.insert(1, HashMap::::default()); + map.insert(2, HashMap::::default()); + map.insert(3, HashMap::::default()); map.try_insert_boxed(Box::new(1), value_ref).unwrap(); assert!(value.reflect_partial_eq(&map[&1]).unwrap()); } diff --git a/crates/bevy_mod_scripting_core/src/runtime.rs b/crates/bevy_mod_scripting_core/src/runtime.rs index ccf740449a..d2e971ffcf 100644 --- a/crates/bevy_mod_scripting_core/src/runtime.rs +++ b/crates/bevy_mod_scripting_core/src/runtime.rs @@ -1,10 +1,7 @@ //! "Runtime" here refers to the execution evironment of scripts. This might be the VM executing bytecode or the interpreter executing source code. //! The important thing is that there is only one runtime which is used to execute all scripts of a particular type or `context`. -use bevy::{ - ecs::system::ResMut, - prelude::{Res, Resource}, -}; +use ::bevy_ecs::{resource::Resource, system::Res, system::ResMut}; use crate::{IntoScriptPluginParams, error::ScriptError}; diff --git a/crates/bevy_mod_scripting_core/src/script/context_key.rs b/crates/bevy_mod_scripting_core/src/script/context_key.rs index eba9346187..294ba51790 100644 --- a/crates/bevy_mod_scripting_core/src/script/context_key.rs +++ b/crates/bevy_mod_scripting_core/src/script/context_key.rs @@ -1,6 +1,6 @@ use std::fmt; -use bevy::prelude::Entity; +use bevy_ecs::entity::Entity; use super::*; use crate::ScriptAsset; diff --git a/crates/bevy_mod_scripting_core/src/script/mod.rs b/crates/bevy_mod_scripting_core/src/script/mod.rs index 01fcda84d2..7d9ab9cb7d 100644 --- a/crates/bevy_mod_scripting_core/src/script/mod.rs +++ b/crates/bevy_mod_scripting_core/src/script/mod.rs @@ -1,19 +1,25 @@ //! Script related types, functions and components -use std::{collections::HashMap, fmt, ops::Deref}; - -use bevy::{ - asset::{Asset, AssetId, Handle}, - ecs::{component::HookContext, entity::Entity, resource::Resource, world::DeferredWorld}, - platform::collections::HashSet, - prelude::ReflectComponent, - reflect::Reflect, +use std::{ + collections::{HashMap, HashSet}, + fmt, + ops::Deref, +}; + +use ::{ + bevy_asset::{Asset, AssetId, Handle}, + bevy_ecs::{ + component::HookContext, entity::Entity, prelude::ReflectComponent, resource::Resource, + world::DeferredWorld, + }, + bevy_reflect::Reflect, }; use crate::{asset::ScriptAsset, event::ScriptEvent}; mod context_key; mod script_context; +use bevy_ecs::component::Component; pub use context_key::*; pub use script_context::*; @@ -64,7 +70,7 @@ impl DisplayProxy for Handle { } } -#[derive(bevy::ecs::component::Component, Reflect, Clone, Default, Debug)] +#[derive(Component, Reflect, Clone, Default, Debug)] #[reflect(Component)] #[component(on_remove=Self::on_remove, on_add=Self::on_add)] /// A component which identifies the scripts existing on an entity. @@ -158,7 +164,7 @@ impl StaticScripts { #[cfg(test)] mod tests { - use bevy::ecs::{event::Events, world::World}; + use bevy_ecs::{event::Events, world::World}; use super::*; diff --git a/crates/bevy_mod_scripting_core/src/script/script_context.rs b/crates/bevy_mod_scripting_core/src/script/script_context.rs index 7a08b38e91..3d66b9bf0a 100644 --- a/crates/bevy_mod_scripting_core/src/script/script_context.rs +++ b/crates/bevy_mod_scripting_core/src/script/script_context.rs @@ -346,7 +346,8 @@ impl Default for ScriptContext

{ #[cfg(test)] mod tests { - use bevy::asset::AssetIndex; + use bevy_app::{App, Plugin}; + use bevy_asset::AssetIndex; use test_utils::make_test_plugin; use super::*; diff --git a/crates/bevy_mod_scripting_derive/Cargo.toml b/crates/bevy_mod_scripting_derive/Cargo.toml index e39b2ff0b7..8cc2f6cd3c 100644 --- a/crates/bevy_mod_scripting_derive/Cargo.toml +++ b/crates/bevy_mod_scripting_derive/Cargo.toml @@ -12,9 +12,9 @@ categories = ["game-development"] readme = "readme.md" [dependencies] -syn = { version = "2", features = ["full"] } -proc-macro2 = "1" -quote = "1" +syn = { workspace = true, features = ["full"] } +proc-macro2 = { workspace = true } +quote = { workspace = true } [lib] proc-macro = true diff --git a/crates/bevy_mod_scripting_derive/src/derive/get_type_dependencies.rs b/crates/bevy_mod_scripting_derive/src/derive/get_type_dependencies.rs index bc1d0734c5..1cebf330b5 100644 --- a/crates/bevy_mod_scripting_derive/src/derive/get_type_dependencies.rs +++ b/crates/bevy_mod_scripting_derive/src/derive/get_type_dependencies.rs @@ -77,12 +77,12 @@ fn get_type_dependencies_from_input(derive_input: DeriveInput) -> TokenStream { }); impl_where.predicates.push( - parse_quote_spanned!(param.ident.span()=> #param_name::Underlying: bevy::reflect::GetTypeRegistration), + parse_quote_spanned!(param.ident.span()=> #param_name::Underlying: GetTypeRegistration), ); } else { - impl_where.predicates.push( - parse_quote_spanned!(param.ident.span()=> #param_name: bevy::reflect::GetTypeRegistration), - ) + impl_where + .predicates + .push(parse_quote_spanned!(param.ident.span()=> #param_name: GetTypeRegistration)) } } @@ -92,7 +92,7 @@ fn get_type_dependencies_from_input(derive_input: DeriveInput) -> TokenStream { impl #impl_generics #bms_core::bindings::GetTypeDependencies for #name #type_generics #impl_where { type Underlying = #underlying; - fn register_type_dependencies(registry: &mut bevy::reflect::TypeRegistry) { + fn register_type_dependencies(registry: &mut TypeRegistry) { #(#recursive_registrations)* registry.register::<#underlying>(); diff --git a/crates/bevy_mod_scripting_derive/src/derive/script_bindings.rs b/crates/bevy_mod_scripting_derive/src/derive/script_bindings.rs index 72b13b8841..dd5ae07844 100644 --- a/crates/bevy_mod_scripting_derive/src/derive/script_bindings.rs +++ b/crates/bevy_mod_scripting_derive/src/derive/script_bindings.rs @@ -54,7 +54,7 @@ pub fn script_bindings( let mark_as_generated = if args.generated { quote_spanned! {impl_span=> - let registry = world.get_resource_or_init::(); + let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry.register_type_data::<#type_ident_with_generics, #bms_core_path::bindings::MarkAsGenerated>(); } @@ -64,7 +64,7 @@ pub fn script_bindings( let mark_as_core = if bms_core_path.is_ident("crate") || args.core { quote_spanned! {impl_span=> - let registry = world.get_resource_or_init::(); + let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry.register_type_data::<#type_ident_with_generics, #bms_core_path::bindings::MarkAsCore>(); } @@ -74,7 +74,7 @@ pub fn script_bindings( let mark_as_significant = if args.significant { quote_spanned! {impl_span=> - let registry = world.get_resource_or_init::(); + let registry = world.get_resource_or_init::(); let mut registry = registry.write(); registry.register_type_data::<#type_ident_with_generics, #bms_core_path::bindings::MarkAsSignificant>(); } @@ -83,7 +83,7 @@ pub fn script_bindings( }; let out = quote_spanned! {impl_span=> - #visibility fn #function_name(world: &mut bevy::ecs::world::World) { + #visibility fn #function_name(world: &mut World) { #bms_core_path::bindings::function::namespace::NamespaceBuilder::<#type_ident_with_generics>::#builder_function_name(world) #(#function_registrations)*; diff --git a/crates/bevy_mod_scripting_derive/src/derive/script_globals.rs b/crates/bevy_mod_scripting_derive/src/derive/script_globals.rs index d64d851c23..c5fe7acd32 100644 --- a/crates/bevy_mod_scripting_derive/src/derive/script_globals.rs +++ b/crates/bevy_mod_scripting_derive/src/derive/script_globals.rs @@ -37,7 +37,7 @@ pub fn script_globals( }; let out = quote_spanned! {impl_span=> - #visibility fn #function_name(world: &mut bevy::ecs::world::World) { + #visibility fn #function_name(world: &mut World) { let registry = world.get_resource_or_init::<#bms_core_path::bindings::globals::AppScriptGlobalsRegistry>(); let mut registry = registry.write(); diff --git a/crates/bevy_mod_scripting_functions/Cargo.toml b/crates/bevy_mod_scripting_functions/Cargo.toml index a99d656012..674aa6a72f 100644 --- a/crates/bevy_mod_scripting_functions/Cargo.toml +++ b/crates/bevy_mod_scripting_functions/Cargo.toml @@ -12,12 +12,12 @@ categories = ["game-development"] readme = "readme.md" [features] -bevy_ecs = [] -bevy_input = [] -bevy_math = ["bevy_math/curve"] -bevy_reflect = ["bevy_reflect/smol_str"] -bevy_time = [] -bevy_transform = [] +bevy_ecs = ["dep:bevy_ecs"] +bevy_input = ["dep:bevy_input"] +bevy_math = ["dep:bevy_math"] +bevy_reflect = ["dep:bevy_reflect", "dep:glam", "dep:uuid", "dep:smol_str"] +bevy_time = ["dep:bevy_time"] +bevy_transform = ["dep:bevy_transform"] core_functions = [] lua_bindings = ["bevy_mod_scripting_lua"] @@ -25,14 +25,21 @@ rhai_bindings = ["bevy_mod_scripting_rhai"] [dependencies] -bevy = { workspace = true } # required since curve has no top level bevy features for these -bevy_math = { workspace = true } -bevy_reflect = { workspace = true } +bevy_ecs = { workspace = true, optional = true } +bevy_input = { workspace = true, optional = true } +bevy_math = { workspace = true, features = ["curve"], optional = true } +bevy_reflect = { workspace = true, features = ["smol_str"], optional = true } +uuid = { workspace = true, optional = true } +smol_str = { workspace = true, optional = true } +bevy_time = { workspace = true, optional = true } +bevy_transform = { workspace = true, optional = true } +bevy_app = { workspace = true, optional = true } +glam = { workspace = true, optional = true } + profiling = { workspace = true } -uuid = "1.11" -smol_str = "0.2.0" + bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_derive = { workspace = true } bevy_mod_scripting_lua = { path = "../languages/bevy_mod_scripting_lua", optional = true, version = "0.15.1" } diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_ecs.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_ecs.rs index ebd8b65a0f..7af5984df4 100644 --- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_ecs.rs +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_ecs.rs @@ -18,20 +18,20 @@ pub struct BevyEcsScriptingPlugin; bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::ecs::entity::Entity { - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( +impl ::bevy_ecs::entity::Entity { + fn clone(_self: Ref<::bevy_ecs::entity::Entity>) -> Val<::bevy_ecs::entity::Entity> { + let output: Val<::bevy_ecs::entity::Entity> = <::bevy_ecs::entity::Entity as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_ecs::entity::Entity>, + other: Ref<::bevy_ecs::entity::Entity>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -40,8 +40,8 @@ impl bevy::ecs::entity::Entity { /// Only useful when applied to results from `to_bits` in the same instance of an application. /// # Panics /// This method will likely panic if given `u64` values that did not come from [`Entity::to_bits`]. - fn from_bits(bits: u64) -> Val { - let output: Val = bevy::ecs::entity::Entity::from_bits( + fn from_bits(bits: u64) -> Val<::bevy_ecs::entity::Entity> { + let output: Val<::bevy_ecs::entity::Entity> = ::bevy_ecs::entity::Entity::from_bits( bits, ) .into(); @@ -56,8 +56,8 @@ impl bevy::ecs::entity::Entity { /// In general, one should not try to synchronize the ECS by attempting to ensure that /// `Entity` lines up between instances, but instead insert a secondary identifier as /// a component. - fn from_raw(index: u32) -> Val { - let output: Val = bevy::ecs::entity::Entity::from_raw( + fn from_raw(index: u32) -> Val<::bevy_ecs::entity::Entity> { + let output: Val<::bevy_ecs::entity::Entity> = ::bevy_ecs::entity::Entity::from_raw( index, ) .into(); @@ -66,8 +66,8 @@ impl bevy::ecs::entity::Entity { /// Returns the generation of this Entity's index. The generation is incremented each time an /// entity with a given index is despawned. This serves as a "count" of the number of times a /// given index has been reused (index, generation) pairs uniquely identify a given Entity. - fn generation(_self: Val) -> u32 { - let output: u32 = bevy::ecs::entity::Entity::generation(_self.into_inner()) + fn generation(_self: Val<::bevy_ecs::entity::Entity>) -> u32 { + let output: u32 = ::bevy_ecs::entity::Entity::generation(_self.into_inner()) .into(); output } @@ -75,16 +75,16 @@ impl bevy::ecs::entity::Entity { /// No two simultaneously-live entities share the same index, but dead entities' indices may collide /// with both live and dead entities. Useful for compactly representing entities within a /// specific snapshot of the world, such as when serializing. - fn index(_self: Val) -> u32 { - let output: u32 = bevy::ecs::entity::Entity::index(_self.into_inner()).into(); + fn index(_self: Val<::bevy_ecs::entity::Entity>) -> u32 { + let output: u32 = ::bevy_ecs::entity::Entity::index(_self.into_inner()).into(); output } /// Convert to a form convenient for passing outside of rust. /// Only useful for identifying entities within the same instance of an application. Do not use /// for serialization between runs. /// No particular structure is guaranteed for the returned bits. - fn to_bits(_self: Val) -> u64 { - let output: u64 = bevy::ecs::entity::Entity::to_bits(_self.into_inner()).into(); + fn to_bits(_self: Val<::bevy_ecs::entity::Entity>) -> u64 { + let output: u64 = ::bevy_ecs::entity::Entity::to_bits(_self.into_inner()).into(); output } } @@ -94,36 +94,38 @@ impl bevy::ecs::entity::Entity { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::ecs::hierarchy::ChildOf { - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( +impl ::bevy_ecs::hierarchy::ChildOf { + fn assert_receiver_is_total_eq(_self: Ref<::bevy_ecs::hierarchy::ChildOf>) -> () { + let output: () = <::bevy_ecs::hierarchy::ChildOf as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_ecs::hierarchy::ChildOf>, + ) -> Val<::bevy_ecs::hierarchy::ChildOf> { + let output: Val<::bevy_ecs::hierarchy::ChildOf> = <::bevy_ecs::hierarchy::ChildOf as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_ecs::hierarchy::ChildOf>, + other: Ref<::bevy_ecs::hierarchy::ChildOf>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// The parent entity of this child entity. - fn get(_self: Ref) -> Val { - let output: Val = bevy::ecs::hierarchy::ChildOf::get( + fn get( + _self: Ref<::bevy_ecs::hierarchy::ChildOf>, + ) -> Val<::bevy_ecs::entity::Entity> { + let output: Val<::bevy_ecs::entity::Entity> = ::bevy_ecs::hierarchy::ChildOf::get( &_self, ) .into(); @@ -131,9 +133,9 @@ impl bevy::ecs::hierarchy::ChildOf { } /// The parent entity of this child entity. fn parent( - _self: Ref, - ) -> Val { - let output: Val = bevy::ecs::hierarchy::ChildOf::parent( + _self: Ref<::bevy_ecs::hierarchy::ChildOf>, + ) -> Val<::bevy_ecs::entity::Entity> { + let output: Val<::bevy_ecs::entity::Entity> = ::bevy_ecs::hierarchy::ChildOf::parent( &_self, ) .into(); @@ -146,31 +148,31 @@ impl bevy::ecs::hierarchy::ChildOf { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::ecs::hierarchy::Children { - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( +impl ::bevy_ecs::hierarchy::Children { + fn assert_receiver_is_total_eq(_self: Ref<::bevy_ecs::hierarchy::Children>) -> () { + let output: () = <::bevy_ecs::hierarchy::Children as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_ecs::hierarchy::Children>, + other: Ref<::bevy_ecs::hierarchy::Children>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Swaps the child at `a_index` with the child at `b_index`. fn swap( - mut _self: Mut, + mut _self: Mut<::bevy_ecs::hierarchy::Children>, a_index: usize, b_index: usize, ) -> () { - let output: () = bevy::ecs::hierarchy::Children::swap( + let output: () = ::bevy_ecs::hierarchy::Children::swap( &mut _self, a_index, b_index, @@ -185,17 +187,20 @@ impl bevy::ecs::hierarchy::Children { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::ecs::name::Name { - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( +impl ::bevy_ecs::name::Name { + fn clone(_self: Ref<::bevy_ecs::name::Name>) -> Val<::bevy_ecs::name::Name> { + let output: Val<::bevy_ecs::name::Name> = <::bevy_ecs::name::Name as ::core::clone::Clone>::clone( &_self, ) .into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , + other: Ref<::bevy_ecs::name::Name>, + ) -> bool { + let output: bool = <::bevy_ecs::name::Name as ::core::cmp::PartialEq< + ::bevy_ecs::name::Name, >>::eq(&_self, &other) .into(); output @@ -207,72 +212,74 @@ impl bevy::ecs::name::Name { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::ecs::world::OnAdd {} +impl ::bevy_ecs::world::OnAdd {} #[script_bindings( remote, name = "on_insert_functions", bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::ecs::world::OnInsert {} +impl ::bevy_ecs::world::OnInsert {} #[script_bindings( remote, name = "on_remove_functions", bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::ecs::world::OnRemove {} +impl ::bevy_ecs::world::OnRemove {} #[script_bindings( remote, name = "on_replace_functions", bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::ecs::world::OnReplace {} +impl ::bevy_ecs::world::OnReplace {} #[script_bindings( remote, name = "component_id_functions", bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::ecs::component::ComponentId { - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( +impl ::bevy_ecs::component::ComponentId { + fn assert_receiver_is_total_eq( + _self: Ref<::bevy_ecs::component::ComponentId>, + ) -> () { + let output: () = <::bevy_ecs::component::ComponentId as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_ecs::component::ComponentId>, + ) -> Val<::bevy_ecs::component::ComponentId> { + let output: Val<::bevy_ecs::component::ComponentId> = <::bevy_ecs::component::ComponentId as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_ecs::component::ComponentId>, + other: Ref<::bevy_ecs::component::ComponentId>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Returns the index of the current component. - fn index(_self: Val) -> usize { - let output: usize = bevy::ecs::component::ComponentId::index(_self.into_inner()) + fn index(_self: Val<::bevy_ecs::component::ComponentId>) -> usize { + let output: usize = ::bevy_ecs::component::ComponentId::index(_self.into_inner()) .into(); output } /// Creates a new [`ComponentId`]. /// The `index` is a unique value associated with each type of component in a given world. /// Usually, this value is taken from a counter incremented for each type of component registered with the world. - fn new(index: usize) -> Val { - let output: Val = bevy::ecs::component::ComponentId::new( + fn new(index: usize) -> Val<::bevy_ecs::component::ComponentId> { + let output: Val<::bevy_ecs::component::ComponentId> = ::bevy_ecs::component::ComponentId::new( index, ) .into(); @@ -285,12 +292,12 @@ impl bevy::ecs::component::ComponentId { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::ecs::entity_disabling::DefaultQueryFilters { +impl ::bevy_ecs::entity_disabling::DefaultQueryFilters { /// Creates a new, completely empty [`DefaultQueryFilters`]. /// This is provided as an escape hatch; in most cases you should initialize this using [`FromWorld`], /// which is automatically called when creating a new [`World`]. - fn empty() -> Val { - let output: Val = bevy::ecs::entity_disabling::DefaultQueryFilters::empty() + fn empty() -> Val<::bevy_ecs::entity_disabling::DefaultQueryFilters> { + let output: Val<::bevy_ecs::entity_disabling::DefaultQueryFilters> = ::bevy_ecs::entity_disabling::DefaultQueryFilters::empty() .into(); output } @@ -303,10 +310,10 @@ impl bevy::ecs::entity_disabling::DefaultQueryFilters { /// As discussed in the [module docs](crate::entity_disabling), this can have performance implications, /// as well as create interoperability issues, and should be used with caution. fn register_disabling_component( - mut _self: Mut, - component_id: Val, + mut _self: Mut<::bevy_ecs::entity_disabling::DefaultQueryFilters>, + component_id: Val<::bevy_ecs::component::ComponentId>, ) -> () { - let output: () = bevy::ecs::entity_disabling::DefaultQueryFilters::register_disabling_component( + let output: () = ::bevy_ecs::entity_disabling::DefaultQueryFilters::register_disabling_component( &mut _self, component_id.into_inner(), ) @@ -320,44 +327,46 @@ impl bevy::ecs::entity_disabling::DefaultQueryFilters { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::ecs::component::Tick { - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( +impl ::bevy_ecs::component::Tick { + fn assert_receiver_is_total_eq(_self: Ref<::bevy_ecs::component::Tick>) -> () { + let output: () = <::bevy_ecs::component::Tick as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone( + _self: Ref<::bevy_ecs::component::Tick>, + ) -> Val<::bevy_ecs::component::Tick> { + let output: Val<::bevy_ecs::component::Tick> = <::bevy_ecs::component::Tick as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_ecs::component::Tick>, + other: Ref<::bevy_ecs::component::Tick>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Gets the value of this change tick. - fn get(_self: Val) -> u32 { - let output: u32 = bevy::ecs::component::Tick::get(_self.into_inner()).into(); + fn get(_self: Val<::bevy_ecs::component::Tick>) -> u32 { + let output: u32 = ::bevy_ecs::component::Tick::get(_self.into_inner()).into(); output } /// Returns `true` if this `Tick` occurred since the system's `last_run`. /// `this_run` is the current tick of the system, used as a reference to help deal with wraparound. fn is_newer_than( - _self: Val, - last_run: Val, - this_run: Val, + _self: Val<::bevy_ecs::component::Tick>, + last_run: Val<::bevy_ecs::component::Tick>, + this_run: Val<::bevy_ecs::component::Tick>, ) -> bool { - let output: bool = bevy::ecs::component::Tick::is_newer_than( + let output: bool = ::bevy_ecs::component::Tick::is_newer_than( _self.into_inner(), last_run.into_inner(), this_run.into_inner(), @@ -366,16 +375,16 @@ impl bevy::ecs::component::Tick { output } /// Creates a new [`Tick`] wrapping the given value. - fn new(tick: u32) -> Val { - let output: Val = bevy::ecs::component::Tick::new( + fn new(tick: u32) -> Val<::bevy_ecs::component::Tick> { + let output: Val<::bevy_ecs::component::Tick> = ::bevy_ecs::component::Tick::new( tick, ) .into(); output } /// Sets the value of this change tick. - fn set(mut _self: Mut, tick: u32) -> () { - let output: () = bevy::ecs::component::Tick::set(&mut _self, tick).into(); + fn set(mut _self: Mut<::bevy_ecs::component::Tick>, tick: u32) -> () { + let output: () = ::bevy_ecs::component::Tick::set(&mut _self, tick).into(); output } } @@ -385,11 +394,11 @@ impl bevy::ecs::component::Tick { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::ecs::component::ComponentTicks { +impl ::bevy_ecs::component::ComponentTicks { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_ecs::component::ComponentTicks>, + ) -> Val<::bevy_ecs::component::ComponentTicks> { + let output: Val<::bevy_ecs::component::ComponentTicks> = <::bevy_ecs::component::ComponentTicks as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -398,11 +407,11 @@ impl bevy::ecs::component::ComponentTicks { /// Returns `true` if the component or resource was added after the system last ran /// (or the system is running for the first time). fn is_added( - _self: Ref, - last_run: Val, - this_run: Val, + _self: Ref<::bevy_ecs::component::ComponentTicks>, + last_run: Val<::bevy_ecs::component::Tick>, + this_run: Val<::bevy_ecs::component::Tick>, ) -> bool { - let output: bool = bevy::ecs::component::ComponentTicks::is_added( + let output: bool = ::bevy_ecs::component::ComponentTicks::is_added( &_self, last_run.into_inner(), this_run.into_inner(), @@ -413,11 +422,11 @@ impl bevy::ecs::component::ComponentTicks { /// Returns `true` if the component or resource was added or mutably dereferenced after the system last ran /// (or the system is running for the first time). fn is_changed( - _self: Ref, - last_run: Val, - this_run: Val, + _self: Ref<::bevy_ecs::component::ComponentTicks>, + last_run: Val<::bevy_ecs::component::Tick>, + this_run: Val<::bevy_ecs::component::Tick>, ) -> bool { - let output: bool = bevy::ecs::component::ComponentTicks::is_changed( + let output: bool = ::bevy_ecs::component::ComponentTicks::is_changed( &_self, last_run.into_inner(), this_run.into_inner(), @@ -427,9 +436,9 @@ impl bevy::ecs::component::ComponentTicks { } /// Creates a new instance with the same change tick for `added` and `changed`. fn new( - change_tick: Val, - ) -> Val { - let output: Val = bevy::ecs::component::ComponentTicks::new( + change_tick: Val<::bevy_ecs::component::Tick>, + ) -> Val<::bevy_ecs::component::ComponentTicks> { + let output: Val<::bevy_ecs::component::ComponentTicks> = ::bevy_ecs::component::ComponentTicks::new( change_tick.into_inner(), ) .into(); @@ -447,10 +456,10 @@ impl bevy::ecs::component::ComponentTicks { /// component_ticks.set_changed(world.read_change_tick()); /// ``` fn set_changed( - mut _self: Mut, - change_tick: Val, + mut _self: Mut<::bevy_ecs::component::ComponentTicks>, + change_tick: Val<::bevy_ecs::component::Tick>, ) -> () { - let output: () = bevy::ecs::component::ComponentTicks::set_changed( + let output: () = ::bevy_ecs::component::ComponentTicks::set_changed( &mut _self, change_tick.into_inner(), ) @@ -464,60 +473,60 @@ impl bevy::ecs::component::ComponentTicks { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::ecs::entity::hash_set::EntityHashSet { +impl ::bevy_ecs::entity::hash_set::EntityHashSet { fn assert_receiver_is_total_eq( - _self: Ref, + _self: Ref<::bevy_ecs::entity::hash_set::EntityHashSet>, ) -> () { - let output: () = ::assert_receiver_is_total_eq( + let output: () = <::bevy_ecs::entity::hash_set::EntityHashSet as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_ecs::entity::hash_set::EntityHashSet>, + ) -> Val<::bevy_ecs::entity::hash_set::EntityHashSet> { + let output: Val<::bevy_ecs::entity::hash_set::EntityHashSet> = <::bevy_ecs::entity::hash_set::EntityHashSet as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_ecs::entity::hash_set::EntityHashSet>, + other: Ref<::bevy_ecs::entity::hash_set::EntityHashSet>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Returns `true` if the set contains no elements. - fn is_empty(_self: Ref) -> bool { - let output: bool = bevy::ecs::entity::hash_set::EntityHashSet::is_empty(&_self) + fn is_empty(_self: Ref<::bevy_ecs::entity::hash_set::EntityHashSet>) -> bool { + let output: bool = ::bevy_ecs::entity::hash_set::EntityHashSet::is_empty(&_self) .into(); output } /// Returns the number of elements in the set. - fn len(_self: Ref) -> usize { - let output: usize = bevy::ecs::entity::hash_set::EntityHashSet::len(&_self) + fn len(_self: Ref<::bevy_ecs::entity::hash_set::EntityHashSet>) -> usize { + let output: usize = ::bevy_ecs::entity::hash_set::EntityHashSet::len(&_self) .into(); output } /// Creates an empty `EntityHashSet`. /// Equivalent to [`HashSet::with_hasher(EntityHash)`]. /// [`HashSet::with_hasher(EntityHash)`]: HashSet::with_hasher - fn new() -> Val { - let output: Val = bevy::ecs::entity::hash_set::EntityHashSet::new() + fn new() -> Val<::bevy_ecs::entity::hash_set::EntityHashSet> { + let output: Val<::bevy_ecs::entity::hash_set::EntityHashSet> = ::bevy_ecs::entity::hash_set::EntityHashSet::new() .into(); output } /// Creates an empty `EntityHashSet` with the specified capacity. /// Equivalent to [`HashSet::with_capacity_and_hasher(n, EntityHash)`]. /// [`HashSet::with_capacity_and_hasher(n, EntityHash)`]: HashSet::with_capacity_and_hasher - fn with_capacity(n: usize) -> Val { - let output: Val = bevy::ecs::entity::hash_set::EntityHashSet::with_capacity( + fn with_capacity(n: usize) -> Val<::bevy_ecs::entity::hash_set::EntityHashSet> { + let output: Val<::bevy_ecs::entity::hash_set::EntityHashSet> = ::bevy_ecs::entity::hash_set::EntityHashSet::with_capacity( n, ) .into(); @@ -530,22 +539,22 @@ impl bevy::ecs::entity::hash_set::EntityHashSet { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::ecs::identifier::Identifier { +impl ::bevy_ecs::identifier::Identifier { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_ecs::identifier::Identifier>, + ) -> Val<::bevy_ecs::identifier::Identifier> { + let output: Val<::bevy_ecs::identifier::Identifier> = <::bevy_ecs::identifier::Identifier as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_ecs::identifier::Identifier>, + other: Ref<::bevy_ecs::identifier::Identifier>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -553,31 +562,31 @@ impl bevy::ecs::identifier::Identifier { /// Convert a `u64` into an [`Identifier`]. /// # Panics /// This method will likely panic if given `u64` values that did not come from [`Identifier::to_bits`]. - fn from_bits(value: u64) -> Val { - let output: Val = bevy::ecs::identifier::Identifier::from_bits( + fn from_bits(value: u64) -> Val<::bevy_ecs::identifier::Identifier> { + let output: Val<::bevy_ecs::identifier::Identifier> = ::bevy_ecs::identifier::Identifier::from_bits( value, ) .into(); output } /// Returns the value of the low segment of the [`Identifier`]. - fn low(_self: Val) -> u32 { - let output: u32 = bevy::ecs::identifier::Identifier::low(_self.into_inner()) + fn low(_self: Val<::bevy_ecs::identifier::Identifier>) -> u32 { + let output: u32 = ::bevy_ecs::identifier::Identifier::low(_self.into_inner()) .into(); output } /// Returns the masked value of the high segment of the [`Identifier`]. /// Does not include the flag bits. - fn masked_high(_self: Val) -> u32 { - let output: u32 = bevy::ecs::identifier::Identifier::masked_high( + fn masked_high(_self: Val<::bevy_ecs::identifier::Identifier>) -> u32 { + let output: u32 = ::bevy_ecs::identifier::Identifier::masked_high( _self.into_inner(), ) .into(); output } /// Convert the [`Identifier`] into a `u64`. - fn to_bits(_self: Val) -> u64 { - let output: u64 = bevy::ecs::identifier::Identifier::to_bits(_self.into_inner()) + fn to_bits(_self: Val<::bevy_ecs::identifier::Identifier>) -> u64 { + let output: u64 = ::bevy_ecs::identifier::Identifier::to_bits(_self.into_inner()) .into(); output } @@ -588,11 +597,11 @@ impl bevy::ecs::identifier::Identifier { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::ecs::entity::EntityHash { +impl ::bevy_ecs::entity::EntityHash { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_ecs::entity::EntityHash>, + ) -> Val<::bevy_ecs::entity::EntityHash> { + let output: Val<::bevy_ecs::entity::EntityHash> = <::bevy_ecs::entity::EntityHash as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -605,11 +614,11 @@ impl bevy::ecs::entity::EntityHash { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::ecs::entity_disabling::Disabled { +impl ::bevy_ecs::entity_disabling::Disabled { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_ecs::entity_disabling::Disabled>, + ) -> Val<::bevy_ecs::entity_disabling::Disabled> { + let output: Val<::bevy_ecs::entity_disabling::Disabled> = <::bevy_ecs::entity_disabling::Disabled as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -622,11 +631,11 @@ impl bevy::ecs::entity_disabling::Disabled { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::ecs::removal_detection::RemovedComponentEntity { +impl ::bevy_ecs::removal_detection::RemovedComponentEntity { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_ecs::removal_detection::RemovedComponentEntity>, + ) -> Val<::bevy_ecs::removal_detection::RemovedComponentEntity> { + let output: Val<::bevy_ecs::removal_detection::RemovedComponentEntity> = <::bevy_ecs::removal_detection::RemovedComponentEntity as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -639,14 +648,14 @@ impl bevy::ecs::removal_detection::RemovedComponentEntity { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::ecs::system::SystemIdMarker {} +impl ::bevy_ecs::system::SystemIdMarker {} #[script_bindings( remote, name = "on_despawn_functions", bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::ecs::world::OnDespawn {} +impl ::bevy_ecs::world::OnDespawn {} impl ::bevy::app::Plugin for BevyEcsScriptingPlugin { fn build(&self, app: &mut ::bevy::prelude::App) { let mut world = app.world_mut(); diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_input.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_input.rs index 886412123b..66c1c40f88 100644 --- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_input.rs +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_input.rs @@ -18,20 +18,20 @@ pub struct BevyInputScriptingPlugin; bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::gamepad::Gamepad { +impl ::bevy_input::gamepad::Gamepad { /// Returns the directional pad as a [`Vec2`]. - fn dpad(_self: Ref) -> Val { - let output: Val = bevy::input::gamepad::Gamepad::dpad(&_self) + fn dpad(_self: Ref<::bevy_input::gamepad::Gamepad>) -> Val<::bevy_math::Vec2> { + let output: Val<::bevy_math::Vec2> = ::bevy_input::gamepad::Gamepad::dpad(&_self) .into(); output } /// Returns `true` if the [`GamepadButton`] has been pressed during the current frame. /// Note: This function does not imply information regarding the current state of [`ButtonInput::pressed`] or [`ButtonInput::just_released`]. fn just_pressed( - _self: Ref, - button_type: Val, + _self: Ref<::bevy_input::gamepad::Gamepad>, + button_type: Val<::bevy_input::gamepad::GamepadButton>, ) -> bool { - let output: bool = bevy::input::gamepad::Gamepad::just_pressed( + let output: bool = ::bevy_input::gamepad::Gamepad::just_pressed( &_self, button_type.into_inner(), ) @@ -41,10 +41,10 @@ impl bevy::input::gamepad::Gamepad { /// Returns `true` if the [`GamepadButton`] has been released during the current frame. /// Note: This function does not imply information regarding the current state of [`ButtonInput::pressed`] or [`ButtonInput::just_pressed`]. fn just_released( - _self: Ref, - button_type: Val, + _self: Ref<::bevy_input::gamepad::Gamepad>, + button_type: Val<::bevy_input::gamepad::GamepadButton>, ) -> bool { - let output: bool = bevy::input::gamepad::Gamepad::just_released( + let output: bool = ::bevy_input::gamepad::Gamepad::just_released( &_self, button_type.into_inner(), ) @@ -52,8 +52,8 @@ impl bevy::input::gamepad::Gamepad { output } /// Returns the left stick as a [`Vec2`]. - fn left_stick(_self: Ref) -> Val { - let output: Val = bevy::input::gamepad::Gamepad::left_stick( + fn left_stick(_self: Ref<::bevy_input::gamepad::Gamepad>) -> Val<::bevy_math::Vec2> { + let output: Val<::bevy_math::Vec2> = ::bevy_input::gamepad::Gamepad::left_stick( &_self, ) .into(); @@ -61,10 +61,10 @@ impl bevy::input::gamepad::Gamepad { } /// Returns `true` if the [`GamepadButton`] has been pressed. fn pressed( - _self: Ref, - button_type: Val, + _self: Ref<::bevy_input::gamepad::Gamepad>, + button_type: Val<::bevy_input::gamepad::GamepadButton>, ) -> bool { - let output: bool = bevy::input::gamepad::Gamepad::pressed( + let output: bool = ::bevy_input::gamepad::Gamepad::pressed( &_self, button_type.into_inner(), ) @@ -74,17 +74,19 @@ impl bevy::input::gamepad::Gamepad { /// Returns the USB product ID as assigned by the [vendor], if available. /// [vendor]: Self::vendor_id fn product_id( - _self: Ref, + _self: Ref<::bevy_input::gamepad::Gamepad>, ) -> ::core::option::Option { - let output: ::core::option::Option = bevy::input::gamepad::Gamepad::product_id( + let output: ::core::option::Option = ::bevy_input::gamepad::Gamepad::product_id( &_self, ) .into(); output } /// Returns the right stick as a [`Vec2`]. - fn right_stick(_self: Ref) -> Val { - let output: Val = bevy::input::gamepad::Gamepad::right_stick( + fn right_stick( + _self: Ref<::bevy_input::gamepad::Gamepad>, + ) -> Val<::bevy_math::Vec2> { + let output: Val<::bevy_math::Vec2> = ::bevy_input::gamepad::Gamepad::right_stick( &_self, ) .into(); @@ -92,9 +94,9 @@ impl bevy::input::gamepad::Gamepad { } /// Returns the USB vendor ID as assigned by the USB-IF, if available. fn vendor_id( - _self: Ref, + _self: Ref<::bevy_input::gamepad::Gamepad>, ) -> ::core::option::Option { - let output: ::core::option::Option = bevy::input::gamepad::Gamepad::vendor_id( + let output: ::core::option::Option = ::bevy_input::gamepad::Gamepad::vendor_id( &_self, ) .into(); @@ -107,29 +109,31 @@ impl bevy::input::gamepad::Gamepad { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::gamepad::GamepadAxis { - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( +impl ::bevy_input::gamepad::GamepadAxis { + fn assert_receiver_is_total_eq( + _self: Ref<::bevy_input::gamepad::GamepadAxis>, + ) -> () { + let output: () = <::bevy_input::gamepad::GamepadAxis as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::gamepad::GamepadAxis>, + ) -> Val<::bevy_input::gamepad::GamepadAxis> { + let output: Val<::bevy_input::gamepad::GamepadAxis> = <::bevy_input::gamepad::GamepadAxis as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::gamepad::GamepadAxis>, + other: Ref<::bevy_input::gamepad::GamepadAxis>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -141,31 +145,31 @@ impl bevy::input::gamepad::GamepadAxis { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::gamepad::GamepadButton { +impl ::bevy_input::gamepad::GamepadButton { fn assert_receiver_is_total_eq( - _self: Ref, + _self: Ref<::bevy_input::gamepad::GamepadButton>, ) -> () { - let output: () = ::assert_receiver_is_total_eq( + let output: () = <::bevy_input::gamepad::GamepadButton as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::gamepad::GamepadButton>, + ) -> Val<::bevy_input::gamepad::GamepadButton> { + let output: Val<::bevy_input::gamepad::GamepadButton> = <::bevy_input::gamepad::GamepadButton as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::gamepad::GamepadButton>, + other: Ref<::bevy_input::gamepad::GamepadButton>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -177,11 +181,11 @@ impl bevy::input::gamepad::GamepadButton { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::gamepad::GamepadSettings { +impl ::bevy_input::gamepad::GamepadSettings { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::gamepad::GamepadSettings>, + ) -> Val<::bevy_input::gamepad::GamepadSettings> { + let output: Val<::bevy_input::gamepad::GamepadSettings> = <::bevy_input::gamepad::GamepadSettings as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -194,29 +198,29 @@ impl bevy::input::gamepad::GamepadSettings { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::keyboard::KeyCode { - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( +impl ::bevy_input::keyboard::KeyCode { + fn assert_receiver_is_total_eq(_self: Ref<::bevy_input::keyboard::KeyCode>) -> () { + let output: () = <::bevy_input::keyboard::KeyCode as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::keyboard::KeyCode>, + ) -> Val<::bevy_input::keyboard::KeyCode> { + let output: Val<::bevy_input::keyboard::KeyCode> = <::bevy_input::keyboard::KeyCode as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::keyboard::KeyCode>, + other: Ref<::bevy_input::keyboard::KeyCode>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -228,29 +232,29 @@ impl bevy::input::keyboard::KeyCode { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::mouse::MouseButton { - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( +impl ::bevy_input::mouse::MouseButton { + fn assert_receiver_is_total_eq(_self: Ref<::bevy_input::mouse::MouseButton>) -> () { + let output: () = <::bevy_input::mouse::MouseButton as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::mouse::MouseButton>, + ) -> Val<::bevy_input::mouse::MouseButton> { + let output: Val<::bevy_input::mouse::MouseButton> = <::bevy_input::mouse::MouseButton as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::mouse::MouseButton>, + other: Ref<::bevy_input::mouse::MouseButton>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -262,22 +266,22 @@ impl bevy::input::mouse::MouseButton { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::touch::TouchInput { +impl ::bevy_input::touch::TouchInput { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::touch::TouchInput>, + ) -> Val<::bevy_input::touch::TouchInput> { + let output: Val<::bevy_input::touch::TouchInput> = <::bevy_input::touch::TouchInput as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::touch::TouchInput>, + other: Ref<::bevy_input::touch::TouchInput>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -289,31 +293,31 @@ impl bevy::input::touch::TouchInput { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::keyboard::KeyboardFocusLost { +impl ::bevy_input::keyboard::KeyboardFocusLost { fn assert_receiver_is_total_eq( - _self: Ref, + _self: Ref<::bevy_input::keyboard::KeyboardFocusLost>, ) -> () { - let output: () = ::assert_receiver_is_total_eq( + let output: () = <::bevy_input::keyboard::KeyboardFocusLost as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::keyboard::KeyboardFocusLost>, + ) -> Val<::bevy_input::keyboard::KeyboardFocusLost> { + let output: Val<::bevy_input::keyboard::KeyboardFocusLost> = <::bevy_input::keyboard::KeyboardFocusLost as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::keyboard::KeyboardFocusLost>, + other: Ref<::bevy_input::keyboard::KeyboardFocusLost>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -325,31 +329,31 @@ impl bevy::input::keyboard::KeyboardFocusLost { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::keyboard::KeyboardInput { +impl ::bevy_input::keyboard::KeyboardInput { fn assert_receiver_is_total_eq( - _self: Ref, + _self: Ref<::bevy_input::keyboard::KeyboardInput>, ) -> () { - let output: () = ::assert_receiver_is_total_eq( + let output: () = <::bevy_input::keyboard::KeyboardInput as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::keyboard::KeyboardInput>, + ) -> Val<::bevy_input::keyboard::KeyboardInput> { + let output: Val<::bevy_input::keyboard::KeyboardInput> = <::bevy_input::keyboard::KeyboardInput as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::keyboard::KeyboardInput>, + other: Ref<::bevy_input::keyboard::KeyboardInput>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -361,22 +365,22 @@ impl bevy::input::keyboard::KeyboardInput { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::mouse::AccumulatedMouseMotion { +impl ::bevy_input::mouse::AccumulatedMouseMotion { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::mouse::AccumulatedMouseMotion>, + ) -> Val<::bevy_input::mouse::AccumulatedMouseMotion> { + let output: Val<::bevy_input::mouse::AccumulatedMouseMotion> = <::bevy_input::mouse::AccumulatedMouseMotion as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::mouse::AccumulatedMouseMotion>, + other: Ref<::bevy_input::mouse::AccumulatedMouseMotion>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -388,22 +392,22 @@ impl bevy::input::mouse::AccumulatedMouseMotion { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::mouse::AccumulatedMouseScroll { +impl ::bevy_input::mouse::AccumulatedMouseScroll { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::mouse::AccumulatedMouseScroll>, + ) -> Val<::bevy_input::mouse::AccumulatedMouseScroll> { + let output: Val<::bevy_input::mouse::AccumulatedMouseScroll> = <::bevy_input::mouse::AccumulatedMouseScroll as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::mouse::AccumulatedMouseScroll>, + other: Ref<::bevy_input::mouse::AccumulatedMouseScroll>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -415,31 +419,31 @@ impl bevy::input::mouse::AccumulatedMouseScroll { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::mouse::MouseButtonInput { +impl ::bevy_input::mouse::MouseButtonInput { fn assert_receiver_is_total_eq( - _self: Ref, + _self: Ref<::bevy_input::mouse::MouseButtonInput>, ) -> () { - let output: () = ::assert_receiver_is_total_eq( + let output: () = <::bevy_input::mouse::MouseButtonInput as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::mouse::MouseButtonInput>, + ) -> Val<::bevy_input::mouse::MouseButtonInput> { + let output: Val<::bevy_input::mouse::MouseButtonInput> = <::bevy_input::mouse::MouseButtonInput as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::mouse::MouseButtonInput>, + other: Ref<::bevy_input::mouse::MouseButtonInput>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -451,22 +455,22 @@ impl bevy::input::mouse::MouseButtonInput { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::mouse::MouseMotion { +impl ::bevy_input::mouse::MouseMotion { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::mouse::MouseMotion>, + ) -> Val<::bevy_input::mouse::MouseMotion> { + let output: Val<::bevy_input::mouse::MouseMotion> = <::bevy_input::mouse::MouseMotion as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::mouse::MouseMotion>, + other: Ref<::bevy_input::mouse::MouseMotion>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -478,22 +482,22 @@ impl bevy::input::mouse::MouseMotion { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::mouse::MouseWheel { +impl ::bevy_input::mouse::MouseWheel { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::mouse::MouseWheel>, + ) -> Val<::bevy_input::mouse::MouseWheel> { + let output: Val<::bevy_input::mouse::MouseWheel> = <::bevy_input::mouse::MouseWheel as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::mouse::MouseWheel>, + other: Ref<::bevy_input::mouse::MouseWheel>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -505,33 +509,33 @@ impl bevy::input::mouse::MouseWheel { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::gamepad::GamepadAxisChangedEvent { +impl ::bevy_input::gamepad::GamepadAxisChangedEvent { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::gamepad::GamepadAxisChangedEvent>, + ) -> Val<::bevy_input::gamepad::GamepadAxisChangedEvent> { + let output: Val<::bevy_input::gamepad::GamepadAxisChangedEvent> = <::bevy_input::gamepad::GamepadAxisChangedEvent as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::gamepad::GamepadAxisChangedEvent>, + other: Ref<::bevy_input::gamepad::GamepadAxisChangedEvent>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Creates a new [`GamepadAxisChangedEvent`]. fn new( - entity: Val, - axis: Val, + entity: Val<::bevy_ecs::entity::Entity>, + axis: Val<::bevy_input::gamepad::GamepadAxis>, value: f32, - ) -> Val { - let output: Val = bevy::input::gamepad::GamepadAxisChangedEvent::new( + ) -> Val<::bevy_input::gamepad::GamepadAxisChangedEvent> { + let output: Val<::bevy_input::gamepad::GamepadAxisChangedEvent> = ::bevy_input::gamepad::GamepadAxisChangedEvent::new( entity.into_inner(), axis.into_inner(), value, @@ -546,34 +550,34 @@ impl bevy::input::gamepad::GamepadAxisChangedEvent { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::gamepad::GamepadButtonChangedEvent { +impl ::bevy_input::gamepad::GamepadButtonChangedEvent { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::gamepad::GamepadButtonChangedEvent>, + ) -> Val<::bevy_input::gamepad::GamepadButtonChangedEvent> { + let output: Val<::bevy_input::gamepad::GamepadButtonChangedEvent> = <::bevy_input::gamepad::GamepadButtonChangedEvent as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::gamepad::GamepadButtonChangedEvent>, + other: Ref<::bevy_input::gamepad::GamepadButtonChangedEvent>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Creates a new [`GamepadButtonChangedEvent`]. fn new( - entity: Val, - button: Val, - state: Val, + entity: Val<::bevy_ecs::entity::Entity>, + button: Val<::bevy_input::gamepad::GamepadButton>, + state: Val<::bevy_input::ButtonState>, value: f32, - ) -> Val { - let output: Val = bevy::input::gamepad::GamepadButtonChangedEvent::new( + ) -> Val<::bevy_input::gamepad::GamepadButtonChangedEvent> { + let output: Val<::bevy_input::gamepad::GamepadButtonChangedEvent> = ::bevy_input::gamepad::GamepadButtonChangedEvent::new( entity.into_inner(), button.into_inner(), state.into_inner(), @@ -589,42 +593,42 @@ impl bevy::input::gamepad::GamepadButtonChangedEvent { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::gamepad::GamepadButtonStateChangedEvent { +impl ::bevy_input::gamepad::GamepadButtonStateChangedEvent { fn assert_receiver_is_total_eq( - _self: Ref, + _self: Ref<::bevy_input::gamepad::GamepadButtonStateChangedEvent>, ) -> () { - let output: () = ::assert_receiver_is_total_eq( + let output: () = <::bevy_input::gamepad::GamepadButtonStateChangedEvent as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::gamepad::GamepadButtonStateChangedEvent>, + ) -> Val<::bevy_input::gamepad::GamepadButtonStateChangedEvent> { + let output: Val<::bevy_input::gamepad::GamepadButtonStateChangedEvent> = <::bevy_input::gamepad::GamepadButtonStateChangedEvent as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::gamepad::GamepadButtonStateChangedEvent>, + other: Ref<::bevy_input::gamepad::GamepadButtonStateChangedEvent>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Creates a new [`GamepadButtonStateChangedEvent`]. fn new( - entity: Val, - button: Val, - state: Val, - ) -> Val { - let output: Val = bevy::input::gamepad::GamepadButtonStateChangedEvent::new( + entity: Val<::bevy_ecs::entity::Entity>, + button: Val<::bevy_input::gamepad::GamepadButton>, + state: Val<::bevy_input::ButtonState>, + ) -> Val<::bevy_input::gamepad::GamepadButtonStateChangedEvent> { + let output: Val<::bevy_input::gamepad::GamepadButtonStateChangedEvent> = ::bevy_input::gamepad::GamepadButtonStateChangedEvent::new( entity.into_inner(), button.into_inner(), state.into_inner(), @@ -639,22 +643,22 @@ impl bevy::input::gamepad::GamepadButtonStateChangedEvent { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::gamepad::GamepadConnection { +impl ::bevy_input::gamepad::GamepadConnection { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::gamepad::GamepadConnection>, + ) -> Val<::bevy_input::gamepad::GamepadConnection> { + let output: Val<::bevy_input::gamepad::GamepadConnection> = <::bevy_input::gamepad::GamepadConnection as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::gamepad::GamepadConnection>, + other: Ref<::bevy_input::gamepad::GamepadConnection>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -666,48 +670,48 @@ impl bevy::input::gamepad::GamepadConnection { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::gamepad::GamepadConnectionEvent { +impl ::bevy_input::gamepad::GamepadConnectionEvent { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::gamepad::GamepadConnectionEvent>, + ) -> Val<::bevy_input::gamepad::GamepadConnectionEvent> { + let output: Val<::bevy_input::gamepad::GamepadConnectionEvent> = <::bevy_input::gamepad::GamepadConnectionEvent as ::core::clone::Clone>::clone( &_self, ) .into(); output } /// Whether the gamepad is connected. - fn connected(_self: Ref) -> bool { - let output: bool = bevy::input::gamepad::GamepadConnectionEvent::connected( + fn connected(_self: Ref<::bevy_input::gamepad::GamepadConnectionEvent>) -> bool { + let output: bool = ::bevy_input::gamepad::GamepadConnectionEvent::connected( &_self, ) .into(); output } /// Whether the gamepad is disconnected. - fn disconnected(_self: Ref) -> bool { - let output: bool = bevy::input::gamepad::GamepadConnectionEvent::disconnected( + fn disconnected(_self: Ref<::bevy_input::gamepad::GamepadConnectionEvent>) -> bool { + let output: bool = ::bevy_input::gamepad::GamepadConnectionEvent::disconnected( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::gamepad::GamepadConnectionEvent>, + other: Ref<::bevy_input::gamepad::GamepadConnectionEvent>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Creates a [`GamepadConnectionEvent`]. fn new( - gamepad: Val, - connection: Val, - ) -> Val { - let output: Val = bevy::input::gamepad::GamepadConnectionEvent::new( + gamepad: Val<::bevy_ecs::entity::Entity>, + connection: Val<::bevy_input::gamepad::GamepadConnection>, + ) -> Val<::bevy_input::gamepad::GamepadConnectionEvent> { + let output: Val<::bevy_input::gamepad::GamepadConnectionEvent> = ::bevy_input::gamepad::GamepadConnectionEvent::new( gamepad.into_inner(), connection.into_inner(), ) @@ -721,22 +725,22 @@ impl bevy::input::gamepad::GamepadConnectionEvent { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::gamepad::GamepadEvent { +impl ::bevy_input::gamepad::GamepadEvent { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::gamepad::GamepadEvent>, + ) -> Val<::bevy_input::gamepad::GamepadEvent> { + let output: Val<::bevy_input::gamepad::GamepadEvent> = <::bevy_input::gamepad::GamepadEvent as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::gamepad::GamepadEvent>, + other: Ref<::bevy_input::gamepad::GamepadEvent>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -748,31 +752,31 @@ impl bevy::input::gamepad::GamepadEvent { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::gamepad::GamepadInput { +impl ::bevy_input::gamepad::GamepadInput { fn assert_receiver_is_total_eq( - _self: Ref, + _self: Ref<::bevy_input::gamepad::GamepadInput>, ) -> () { - let output: () = ::assert_receiver_is_total_eq( + let output: () = <::bevy_input::gamepad::GamepadInput as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::gamepad::GamepadInput>, + ) -> Val<::bevy_input::gamepad::GamepadInput> { + let output: Val<::bevy_input::gamepad::GamepadInput> = <::bevy_input::gamepad::GamepadInput as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::gamepad::GamepadInput>, + other: Ref<::bevy_input::gamepad::GamepadInput>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -784,11 +788,11 @@ impl bevy::input::gamepad::GamepadInput { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::gamepad::GamepadRumbleRequest { +impl ::bevy_input::gamepad::GamepadRumbleRequest { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::gamepad::GamepadRumbleRequest>, + ) -> Val<::bevy_input::gamepad::GamepadRumbleRequest> { + let output: Val<::bevy_input::gamepad::GamepadRumbleRequest> = <::bevy_input::gamepad::GamepadRumbleRequest as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -796,9 +800,9 @@ impl bevy::input::gamepad::GamepadRumbleRequest { } /// Get the [`Entity`] associated with this request. fn gamepad( - _self: Ref, - ) -> Val { - let output: Val = bevy::input::gamepad::GamepadRumbleRequest::gamepad( + _self: Ref<::bevy_input::gamepad::GamepadRumbleRequest>, + ) -> Val<::bevy_ecs::entity::Entity> { + let output: Val<::bevy_ecs::entity::Entity> = ::bevy_input::gamepad::GamepadRumbleRequest::gamepad( &_self, ) .into(); @@ -811,33 +815,33 @@ impl bevy::input::gamepad::GamepadRumbleRequest { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::gamepad::RawGamepadAxisChangedEvent { +impl ::bevy_input::gamepad::RawGamepadAxisChangedEvent { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::gamepad::RawGamepadAxisChangedEvent>, + ) -> Val<::bevy_input::gamepad::RawGamepadAxisChangedEvent> { + let output: Val<::bevy_input::gamepad::RawGamepadAxisChangedEvent> = <::bevy_input::gamepad::RawGamepadAxisChangedEvent as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::gamepad::RawGamepadAxisChangedEvent>, + other: Ref<::bevy_input::gamepad::RawGamepadAxisChangedEvent>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Creates a [`RawGamepadAxisChangedEvent`]. fn new( - gamepad: Val, - axis_type: Val, + gamepad: Val<::bevy_ecs::entity::Entity>, + axis_type: Val<::bevy_input::gamepad::GamepadAxis>, value: f32, - ) -> Val { - let output: Val = bevy::input::gamepad::RawGamepadAxisChangedEvent::new( + ) -> Val<::bevy_input::gamepad::RawGamepadAxisChangedEvent> { + let output: Val<::bevy_input::gamepad::RawGamepadAxisChangedEvent> = ::bevy_input::gamepad::RawGamepadAxisChangedEvent::new( gamepad.into_inner(), axis_type.into_inner(), value, @@ -852,33 +856,33 @@ impl bevy::input::gamepad::RawGamepadAxisChangedEvent { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::gamepad::RawGamepadButtonChangedEvent { +impl ::bevy_input::gamepad::RawGamepadButtonChangedEvent { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::gamepad::RawGamepadButtonChangedEvent>, + ) -> Val<::bevy_input::gamepad::RawGamepadButtonChangedEvent> { + let output: Val<::bevy_input::gamepad::RawGamepadButtonChangedEvent> = <::bevy_input::gamepad::RawGamepadButtonChangedEvent as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::gamepad::RawGamepadButtonChangedEvent>, + other: Ref<::bevy_input::gamepad::RawGamepadButtonChangedEvent>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Creates a [`RawGamepadButtonChangedEvent`]. fn new( - gamepad: Val, - button_type: Val, + gamepad: Val<::bevy_ecs::entity::Entity>, + button_type: Val<::bevy_input::gamepad::GamepadButton>, value: f32, - ) -> Val { - let output: Val = bevy::input::gamepad::RawGamepadButtonChangedEvent::new( + ) -> Val<::bevy_input::gamepad::RawGamepadButtonChangedEvent> { + let output: Val<::bevy_input::gamepad::RawGamepadButtonChangedEvent> = ::bevy_input::gamepad::RawGamepadButtonChangedEvent::new( gamepad.into_inner(), button_type.into_inner(), value, @@ -893,22 +897,22 @@ impl bevy::input::gamepad::RawGamepadButtonChangedEvent { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::gamepad::RawGamepadEvent { +impl ::bevy_input::gamepad::RawGamepadEvent { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::gamepad::RawGamepadEvent>, + ) -> Val<::bevy_input::gamepad::RawGamepadEvent> { + let output: Val<::bevy_input::gamepad::RawGamepadEvent> = <::bevy_input::gamepad::RawGamepadEvent as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::gamepad::RawGamepadEvent>, + other: Ref<::bevy_input::gamepad::RawGamepadEvent>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -920,22 +924,22 @@ impl bevy::input::gamepad::RawGamepadEvent { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::gestures::PinchGesture { +impl ::bevy_input::gestures::PinchGesture { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::gestures::PinchGesture>, + ) -> Val<::bevy_input::gestures::PinchGesture> { + let output: Val<::bevy_input::gestures::PinchGesture> = <::bevy_input::gestures::PinchGesture as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::gestures::PinchGesture>, + other: Ref<::bevy_input::gestures::PinchGesture>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -947,22 +951,22 @@ impl bevy::input::gestures::PinchGesture { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::gestures::RotationGesture { +impl ::bevy_input::gestures::RotationGesture { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::gestures::RotationGesture>, + ) -> Val<::bevy_input::gestures::RotationGesture> { + let output: Val<::bevy_input::gestures::RotationGesture> = <::bevy_input::gestures::RotationGesture as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::gestures::RotationGesture>, + other: Ref<::bevy_input::gestures::RotationGesture>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -974,22 +978,22 @@ impl bevy::input::gestures::RotationGesture { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::gestures::DoubleTapGesture { +impl ::bevy_input::gestures::DoubleTapGesture { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::gestures::DoubleTapGesture>, + ) -> Val<::bevy_input::gestures::DoubleTapGesture> { + let output: Val<::bevy_input::gestures::DoubleTapGesture> = <::bevy_input::gestures::DoubleTapGesture as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::gestures::DoubleTapGesture>, + other: Ref<::bevy_input::gestures::DoubleTapGesture>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -1001,22 +1005,22 @@ impl bevy::input::gestures::DoubleTapGesture { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::gestures::PanGesture { +impl ::bevy_input::gestures::PanGesture { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::gestures::PanGesture>, + ) -> Val<::bevy_input::gestures::PanGesture> { + let output: Val<::bevy_input::gestures::PanGesture> = <::bevy_input::gestures::PanGesture as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::gestures::PanGesture>, + other: Ref<::bevy_input::gestures::PanGesture>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -1028,34 +1032,34 @@ impl bevy::input::gestures::PanGesture { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::ButtonState { - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( +impl ::bevy_input::ButtonState { + fn assert_receiver_is_total_eq(_self: Ref<::bevy_input::ButtonState>) -> () { + let output: () = <::bevy_input::ButtonState as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::bevy_input::ButtonState>) -> Val<::bevy_input::ButtonState> { + let output: Val<::bevy_input::ButtonState> = <::bevy_input::ButtonState as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::ButtonState>, + other: Ref<::bevy_input::ButtonState>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Is this button pressed? - fn is_pressed(_self: Ref) -> bool { - let output: bool = bevy::input::ButtonState::is_pressed(&_self).into(); + fn is_pressed(_self: Ref<::bevy_input::ButtonState>) -> bool { + let output: bool = ::bevy_input::ButtonState::is_pressed(&_self).into(); output } } @@ -1065,30 +1069,33 @@ impl bevy::input::ButtonState { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::gamepad::ButtonSettings { +impl ::bevy_input::gamepad::ButtonSettings { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::gamepad::ButtonSettings>, + ) -> Val<::bevy_input::gamepad::ButtonSettings> { + let output: Val<::bevy_input::gamepad::ButtonSettings> = <::bevy_input::gamepad::ButtonSettings as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::gamepad::ButtonSettings>, + other: Ref<::bevy_input::gamepad::ButtonSettings>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Returns `true` if the button is pressed. /// A button is considered pressed if the `value` passed is greater than or equal to the press threshold. - fn is_pressed(_self: Ref, value: f32) -> bool { - let output: bool = bevy::input::gamepad::ButtonSettings::is_pressed( + fn is_pressed( + _self: Ref<::bevy_input::gamepad::ButtonSettings>, + value: f32, + ) -> bool { + let output: bool = ::bevy_input::gamepad::ButtonSettings::is_pressed( &_self, value, ) @@ -1098,10 +1105,10 @@ impl bevy::input::gamepad::ButtonSettings { /// Returns `true` if the button is released. /// A button is considered released if the `value` passed is lower than or equal to the release threshold. fn is_released( - _self: Ref, + _self: Ref<::bevy_input::gamepad::ButtonSettings>, value: f32, ) -> bool { - let output: bool = bevy::input::gamepad::ButtonSettings::is_released( + let output: bool = ::bevy_input::gamepad::ButtonSettings::is_released( &_self, value, ) @@ -1109,14 +1116,16 @@ impl bevy::input::gamepad::ButtonSettings { output } /// Get the button input threshold above which the button is considered pressed. - fn press_threshold(_self: Ref) -> f32 { - let output: f32 = bevy::input::gamepad::ButtonSettings::press_threshold(&_self) + fn press_threshold(_self: Ref<::bevy_input::gamepad::ButtonSettings>) -> f32 { + let output: f32 = ::bevy_input::gamepad::ButtonSettings::press_threshold(&_self) .into(); output } /// Get the button input threshold below which the button is considered released. - fn release_threshold(_self: Ref) -> f32 { - let output: f32 = bevy::input::gamepad::ButtonSettings::release_threshold(&_self) + fn release_threshold(_self: Ref<::bevy_input::gamepad::ButtonSettings>) -> f32 { + let output: f32 = ::bevy_input::gamepad::ButtonSettings::release_threshold( + &_self, + ) .into(); output } @@ -1124,10 +1133,10 @@ impl bevy::input::gamepad::ButtonSettings { /// If the value passed is outside the range [release threshold..=1.0], the value will not be changed. /// Returns the new value of the press threshold. fn set_press_threshold( - mut _self: Mut, + mut _self: Mut<::bevy_input::gamepad::ButtonSettings>, value: f32, ) -> f32 { - let output: f32 = bevy::input::gamepad::ButtonSettings::set_press_threshold( + let output: f32 = ::bevy_input::gamepad::ButtonSettings::set_press_threshold( &mut _self, value, ) @@ -1138,10 +1147,10 @@ impl bevy::input::gamepad::ButtonSettings { /// value passed is outside the range [0.0..=press threshold], the value will not be changed. /// Returns the new value of the release threshold. fn set_release_threshold( - mut _self: Mut, + mut _self: Mut<::bevy_input::gamepad::ButtonSettings>, value: f32, ) -> f32 { - let output: f32 = bevy::input::gamepad::ButtonSettings::set_release_threshold( + let output: f32 = ::bevy_input::gamepad::ButtonSettings::set_release_threshold( &mut _self, value, ) @@ -1155,53 +1164,61 @@ impl bevy::input::gamepad::ButtonSettings { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::gamepad::AxisSettings { +impl ::bevy_input::gamepad::AxisSettings { /// Clamps the `raw_value` according to the `AxisSettings`. - fn clamp(_self: Ref, raw_value: f32) -> f32 { - let output: f32 = bevy::input::gamepad::AxisSettings::clamp(&_self, raw_value) + fn clamp(_self: Ref<::bevy_input::gamepad::AxisSettings>, raw_value: f32) -> f32 { + let output: f32 = ::bevy_input::gamepad::AxisSettings::clamp(&_self, raw_value) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::gamepad::AxisSettings>, + ) -> Val<::bevy_input::gamepad::AxisSettings> { + let output: Val<::bevy_input::gamepad::AxisSettings> = <::bevy_input::gamepad::AxisSettings as ::core::clone::Clone>::clone( &_self, ) .into(); output } /// Get the value above which inputs will be rounded up to 0.0. - fn deadzone_lowerbound(_self: Ref) -> f32 { - let output: f32 = bevy::input::gamepad::AxisSettings::deadzone_lowerbound(&_self) + fn deadzone_lowerbound(_self: Ref<::bevy_input::gamepad::AxisSettings>) -> f32 { + let output: f32 = ::bevy_input::gamepad::AxisSettings::deadzone_lowerbound( + &_self, + ) .into(); output } /// Get the value below which positive inputs will be rounded down to 0.0. - fn deadzone_upperbound(_self: Ref) -> f32 { - let output: f32 = bevy::input::gamepad::AxisSettings::deadzone_upperbound(&_self) + fn deadzone_upperbound(_self: Ref<::bevy_input::gamepad::AxisSettings>) -> f32 { + let output: f32 = ::bevy_input::gamepad::AxisSettings::deadzone_upperbound( + &_self, + ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::gamepad::AxisSettings>, + other: Ref<::bevy_input::gamepad::AxisSettings>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Get the value below which negative inputs will be rounded down to -1.0. - fn livezone_lowerbound(_self: Ref) -> f32 { - let output: f32 = bevy::input::gamepad::AxisSettings::livezone_lowerbound(&_self) + fn livezone_lowerbound(_self: Ref<::bevy_input::gamepad::AxisSettings>) -> f32 { + let output: f32 = ::bevy_input::gamepad::AxisSettings::livezone_lowerbound( + &_self, + ) .into(); output } /// Get the value above which inputs will be rounded up to 1.0. - fn livezone_upperbound(_self: Ref) -> f32 { - let output: f32 = bevy::input::gamepad::AxisSettings::livezone_upperbound(&_self) + fn livezone_upperbound(_self: Ref<::bevy_input::gamepad::AxisSettings>) -> f32 { + let output: f32 = ::bevy_input::gamepad::AxisSettings::livezone_upperbound( + &_self, + ) .into(); output } @@ -1210,10 +1227,10 @@ impl bevy::input::gamepad::AxisSettings { /// the value will not be changed. /// Returns the new value of `deadzone_lowerbound`. fn set_deadzone_lowerbound( - mut _self: Mut, + mut _self: Mut<::bevy_input::gamepad::AxisSettings>, value: f32, ) -> f32 { - let output: f32 = bevy::input::gamepad::AxisSettings::set_deadzone_lowerbound( + let output: f32 = ::bevy_input::gamepad::AxisSettings::set_deadzone_lowerbound( &mut _self, value, ) @@ -1225,10 +1242,10 @@ impl bevy::input::gamepad::AxisSettings { /// the value will not be changed. /// Returns the new value of `deadzone_upperbound`. fn set_deadzone_upperbound( - mut _self: Mut, + mut _self: Mut<::bevy_input::gamepad::AxisSettings>, value: f32, ) -> f32 { - let output: f32 = bevy::input::gamepad::AxisSettings::set_deadzone_upperbound( + let output: f32 = ::bevy_input::gamepad::AxisSettings::set_deadzone_upperbound( &mut _self, value, ) @@ -1240,10 +1257,10 @@ impl bevy::input::gamepad::AxisSettings { /// the value will not be changed. /// Returns the new value of `livezone_lowerbound`. fn set_livezone_lowerbound( - mut _self: Mut, + mut _self: Mut<::bevy_input::gamepad::AxisSettings>, value: f32, ) -> f32 { - let output: f32 = bevy::input::gamepad::AxisSettings::set_livezone_lowerbound( + let output: f32 = ::bevy_input::gamepad::AxisSettings::set_livezone_lowerbound( &mut _self, value, ) @@ -1255,10 +1272,10 @@ impl bevy::input::gamepad::AxisSettings { /// the value will not be changed. /// Returns the new value of `livezone_upperbound`. fn set_livezone_upperbound( - mut _self: Mut, + mut _self: Mut<::bevy_input::gamepad::AxisSettings>, value: f32, ) -> f32 { - let output: f32 = bevy::input::gamepad::AxisSettings::set_livezone_upperbound( + let output: f32 = ::bevy_input::gamepad::AxisSettings::set_livezone_upperbound( &mut _self, value, ) @@ -1269,10 +1286,10 @@ impl bevy::input::gamepad::AxisSettings { /// If the value passed is not within [0.0..=2.0], the value will not be changed. /// Returns the new value of threshold. fn set_threshold( - mut _self: Mut, + mut _self: Mut<::bevy_input::gamepad::AxisSettings>, value: f32, ) -> f32 { - let output: f32 = bevy::input::gamepad::AxisSettings::set_threshold( + let output: f32 = ::bevy_input::gamepad::AxisSettings::set_threshold( &mut _self, value, ) @@ -1280,8 +1297,8 @@ impl bevy::input::gamepad::AxisSettings { output } /// Get the minimum value by which input must change before the change is registered. - fn threshold(_self: Ref) -> f32 { - let output: f32 = bevy::input::gamepad::AxisSettings::threshold(&_self).into(); + fn threshold(_self: Ref<::bevy_input::gamepad::AxisSettings>) -> f32 { + let output: f32 = ::bevy_input::gamepad::AxisSettings::threshold(&_self).into(); output } } @@ -1291,11 +1308,11 @@ impl bevy::input::gamepad::AxisSettings { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::gamepad::ButtonAxisSettings { +impl ::bevy_input::gamepad::ButtonAxisSettings { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::gamepad::ButtonAxisSettings>, + ) -> Val<::bevy_input::gamepad::ButtonAxisSettings> { + let output: Val<::bevy_input::gamepad::ButtonAxisSettings> = <::bevy_input::gamepad::ButtonAxisSettings as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -1308,22 +1325,22 @@ impl bevy::input::gamepad::ButtonAxisSettings { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::gamepad::GamepadRumbleIntensity { +impl ::bevy_input::gamepad::GamepadRumbleIntensity { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::gamepad::GamepadRumbleIntensity>, + ) -> Val<::bevy_input::gamepad::GamepadRumbleIntensity> { + let output: Val<::bevy_input::gamepad::GamepadRumbleIntensity> = <::bevy_input::gamepad::GamepadRumbleIntensity as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::gamepad::GamepadRumbleIntensity>, + other: Ref<::bevy_input::gamepad::GamepadRumbleIntensity>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -1332,8 +1349,8 @@ impl bevy::input::gamepad::GamepadRumbleIntensity { /// Clamped within the `0.0` to `1.0` range. fn strong_motor( intensity: f32, - ) -> Val { - let output: Val = bevy::input::gamepad::GamepadRumbleIntensity::strong_motor( + ) -> Val<::bevy_input::gamepad::GamepadRumbleIntensity> { + let output: Val<::bevy_input::gamepad::GamepadRumbleIntensity> = ::bevy_input::gamepad::GamepadRumbleIntensity::strong_motor( intensity, ) .into(); @@ -1341,8 +1358,8 @@ impl bevy::input::gamepad::GamepadRumbleIntensity { } /// Creates a new rumble intensity with weak motor intensity set to the given value. /// Clamped within the `0.0` to `1.0` range. - fn weak_motor(intensity: f32) -> Val { - let output: Val = bevy::input::gamepad::GamepadRumbleIntensity::weak_motor( + fn weak_motor(intensity: f32) -> Val<::bevy_input::gamepad::GamepadRumbleIntensity> { + let output: Val<::bevy_input::gamepad::GamepadRumbleIntensity> = ::bevy_input::gamepad::GamepadRumbleIntensity::weak_motor( intensity, ) .into(); @@ -1355,27 +1372,29 @@ impl bevy::input::gamepad::GamepadRumbleIntensity { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::keyboard::Key { - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( +impl ::bevy_input::keyboard::Key { + fn assert_receiver_is_total_eq(_self: Ref<::bevy_input::keyboard::Key>) -> () { + let output: () = <::bevy_input::keyboard::Key as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone( + _self: Ref<::bevy_input::keyboard::Key>, + ) -> Val<::bevy_input::keyboard::Key> { + let output: Val<::bevy_input::keyboard::Key> = <::bevy_input::keyboard::Key as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::keyboard::Key>, + other: Ref<::bevy_input::keyboard::Key>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -1387,31 +1406,31 @@ impl bevy::input::keyboard::Key { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::keyboard::NativeKeyCode { +impl ::bevy_input::keyboard::NativeKeyCode { fn assert_receiver_is_total_eq( - _self: Ref, + _self: Ref<::bevy_input::keyboard::NativeKeyCode>, ) -> () { - let output: () = ::assert_receiver_is_total_eq( + let output: () = <::bevy_input::keyboard::NativeKeyCode as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::keyboard::NativeKeyCode>, + ) -> Val<::bevy_input::keyboard::NativeKeyCode> { + let output: Val<::bevy_input::keyboard::NativeKeyCode> = <::bevy_input::keyboard::NativeKeyCode as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::keyboard::NativeKeyCode>, + other: Ref<::bevy_input::keyboard::NativeKeyCode>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -1423,29 +1442,29 @@ impl bevy::input::keyboard::NativeKeyCode { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::keyboard::NativeKey { - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( +impl ::bevy_input::keyboard::NativeKey { + fn assert_receiver_is_total_eq(_self: Ref<::bevy_input::keyboard::NativeKey>) -> () { + let output: () = <::bevy_input::keyboard::NativeKey as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::keyboard::NativeKey>, + ) -> Val<::bevy_input::keyboard::NativeKey> { + let output: Val<::bevy_input::keyboard::NativeKey> = <::bevy_input::keyboard::NativeKey as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::keyboard::NativeKey>, + other: Ref<::bevy_input::keyboard::NativeKey>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -1457,31 +1476,31 @@ impl bevy::input::keyboard::NativeKey { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::mouse::MouseScrollUnit { +impl ::bevy_input::mouse::MouseScrollUnit { fn assert_receiver_is_total_eq( - _self: Ref, + _self: Ref<::bevy_input::mouse::MouseScrollUnit>, ) -> () { - let output: () = ::assert_receiver_is_total_eq( + let output: () = <::bevy_input::mouse::MouseScrollUnit as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::mouse::MouseScrollUnit>, + ) -> Val<::bevy_input::mouse::MouseScrollUnit> { + let output: Val<::bevy_input::mouse::MouseScrollUnit> = <::bevy_input::mouse::MouseScrollUnit as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::mouse::MouseScrollUnit>, + other: Ref<::bevy_input::mouse::MouseScrollUnit>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -1493,29 +1512,29 @@ impl bevy::input::mouse::MouseScrollUnit { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::touch::TouchPhase { - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( +impl ::bevy_input::touch::TouchPhase { + fn assert_receiver_is_total_eq(_self: Ref<::bevy_input::touch::TouchPhase>) -> () { + let output: () = <::bevy_input::touch::TouchPhase as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::touch::TouchPhase>, + ) -> Val<::bevy_input::touch::TouchPhase> { + let output: Val<::bevy_input::touch::TouchPhase> = <::bevy_input::touch::TouchPhase as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::touch::TouchPhase>, + other: Ref<::bevy_input::touch::TouchPhase>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -1527,22 +1546,22 @@ impl bevy::input::touch::TouchPhase { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::input::touch::ForceTouch { +impl ::bevy_input::touch::ForceTouch { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_input::touch::ForceTouch>, + ) -> Val<::bevy_input::touch::ForceTouch> { + let output: Val<::bevy_input::touch::ForceTouch> = <::bevy_input::touch::ForceTouch as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_input::touch::ForceTouch>, + other: Ref<::bevy_input::touch::ForceTouch>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_math.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_math.rs index 29c99b82c2..a0ab749712 100644 --- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_math.rs +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_math.rs @@ -18,50 +18,50 @@ pub struct BevyMathScriptingPlugin; bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::AspectRatio { - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( +impl ::bevy_math::AspectRatio { + fn clone(_self: Ref<::bevy_math::AspectRatio>) -> Val<::bevy_math::AspectRatio> { + let output: Val<::bevy_math::AspectRatio> = <::bevy_math::AspectRatio as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::AspectRatio>, + other: Ref<::bevy_math::AspectRatio>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Returns the inverse of this aspect ratio (height/width). - fn inverse(_self: Ref) -> Val { - let output: Val = bevy::math::AspectRatio::inverse( + fn inverse(_self: Ref<::bevy_math::AspectRatio>) -> Val<::bevy_math::AspectRatio> { + let output: Val<::bevy_math::AspectRatio> = ::bevy_math::AspectRatio::inverse( &_self, ) .into(); output } /// Returns true if the aspect ratio represents a landscape orientation. - fn is_landscape(_self: Ref) -> bool { - let output: bool = bevy::math::AspectRatio::is_landscape(&_self).into(); + fn is_landscape(_self: Ref<::bevy_math::AspectRatio>) -> bool { + let output: bool = ::bevy_math::AspectRatio::is_landscape(&_self).into(); output } /// Returns true if the aspect ratio represents a portrait orientation. - fn is_portrait(_self: Ref) -> bool { - let output: bool = bevy::math::AspectRatio::is_portrait(&_self).into(); + fn is_portrait(_self: Ref<::bevy_math::AspectRatio>) -> bool { + let output: bool = ::bevy_math::AspectRatio::is_portrait(&_self).into(); output } /// Returns true if the aspect ratio is exactly square. - fn is_square(_self: Ref) -> bool { - let output: bool = bevy::math::AspectRatio::is_square(&_self).into(); + fn is_square(_self: Ref<::bevy_math::AspectRatio>) -> bool { + let output: bool = ::bevy_math::AspectRatio::is_square(&_self).into(); output } /// Returns the aspect ratio as a f32 value. - fn ratio(_self: Ref) -> f32 { - let output: f32 = bevy::math::AspectRatio::ratio(&_self).into(); + fn ratio(_self: Ref<::bevy_math::AspectRatio>) -> f32 { + let output: f32 = ::bevy_math::AspectRatio::ratio(&_self).into(); output } } @@ -71,33 +71,33 @@ impl bevy::math::AspectRatio { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::CompassOctant { - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( +impl ::bevy_math::CompassOctant { + fn assert_receiver_is_total_eq(_self: Ref<::bevy_math::CompassOctant>) -> () { + let output: () = <::bevy_math::CompassOctant as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::bevy_math::CompassOctant>) -> Val<::bevy_math::CompassOctant> { + let output: Val<::bevy_math::CompassOctant> = <::bevy_math::CompassOctant as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::CompassOctant>, + other: Ref<::bevy_math::CompassOctant>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::bevy_math::CompassOctant>) -> Val<::bevy_math::CompassOctant> { + let output: Val<::bevy_math::CompassOctant> = <::bevy_math::CompassOctant as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -106,9 +106,9 @@ impl bevy::math::CompassOctant { /// Returns the opposite [`CompassOctant`], located 180 degrees from `self`. /// This can also be accessed via the `-` operator, using the [`Neg`] trait. fn opposite( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::CompassOctant::opposite( + _self: Ref<::bevy_math::CompassOctant>, + ) -> Val<::bevy_math::CompassOctant> { + let output: Val<::bevy_math::CompassOctant> = ::bevy_math::CompassOctant::opposite( &_self, ) .into(); @@ -116,8 +116,8 @@ impl bevy::math::CompassOctant { } /// Converts a [`CompassOctant`] to a standard index. /// Starts at 0 for [`CompassOctant::North`] and increments clockwise. - fn to_index(_self: Val) -> usize { - let output: usize = bevy::math::CompassOctant::to_index(_self.into_inner()) + fn to_index(_self: Val<::bevy_math::CompassOctant>) -> usize { + let output: usize = ::bevy_math::CompassOctant::to_index(_self.into_inner()) .into(); output } @@ -128,35 +128,37 @@ impl bevy::math::CompassOctant { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::CompassQuadrant { - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( +impl ::bevy_math::CompassQuadrant { + fn assert_receiver_is_total_eq(_self: Ref<::bevy_math::CompassQuadrant>) -> () { + let output: () = <::bevy_math::CompassQuadrant as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::CompassQuadrant>, + ) -> Val<::bevy_math::CompassQuadrant> { + let output: Val<::bevy_math::CompassQuadrant> = <::bevy_math::CompassQuadrant as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::CompassQuadrant>, + other: Ref<::bevy_math::CompassQuadrant>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg( + _self: Val<::bevy_math::CompassQuadrant>, + ) -> Val<::bevy_math::CompassQuadrant> { + let output: Val<::bevy_math::CompassQuadrant> = <::bevy_math::CompassQuadrant as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -165,9 +167,9 @@ impl bevy::math::CompassQuadrant { /// Returns the opposite [`CompassQuadrant`], located 180 degrees from `self`. /// This can also be accessed via the `-` operator, using the [`Neg`] trait. fn opposite( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::CompassQuadrant::opposite( + _self: Ref<::bevy_math::CompassQuadrant>, + ) -> Val<::bevy_math::CompassQuadrant> { + let output: Val<::bevy_math::CompassQuadrant> = ::bevy_math::CompassQuadrant::opposite( &_self, ) .into(); @@ -175,8 +177,8 @@ impl bevy::math::CompassQuadrant { } /// Converts a [`CompassQuadrant`] to a standard index. /// Starts at 0 for [`CompassQuadrant::North`] and increments clockwise. - fn to_index(_self: Val) -> usize { - let output: usize = bevy::math::CompassQuadrant::to_index(_self.into_inner()) + fn to_index(_self: Val<::bevy_math::CompassQuadrant>) -> usize { + let output: usize = ::bevy_math::CompassQuadrant::to_index(_self.into_inner()) .into(); output } @@ -187,27 +189,27 @@ impl bevy::math::CompassQuadrant { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::Isometry2d { - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( +impl ::bevy_math::Isometry2d { + fn clone(_self: Ref<::bevy_math::Isometry2d>) -> Val<::bevy_math::Isometry2d> { + let output: Val<::bevy_math::Isometry2d> = <::bevy_math::Isometry2d as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::Isometry2d>, + other: Ref<::bevy_math::Isometry2d>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Create a two-dimensional isometry from a rotation. - fn from_rotation(rotation: Val) -> Val { - let output: Val = bevy::math::Isometry2d::from_rotation( + fn from_rotation(rotation: Val<::bevy_math::Rot2>) -> Val<::bevy_math::Isometry2d> { + let output: Val<::bevy_math::Isometry2d> = ::bevy_math::Isometry2d::from_rotation( rotation.into_inner(), ) .into(); @@ -215,23 +217,25 @@ impl bevy::math::Isometry2d { } /// Create a two-dimensional isometry from a translation. fn from_translation( - translation: Val, - ) -> Val { - let output: Val = bevy::math::Isometry2d::from_translation( + translation: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::Isometry2d> { + let output: Val<::bevy_math::Isometry2d> = ::bevy_math::Isometry2d::from_translation( translation.into_inner(), ) .into(); output } /// Create a two-dimensional isometry from a translation with the given `x` and `y` components. - fn from_xy(x: f32, y: f32) -> Val { - let output: Val = bevy::math::Isometry2d::from_xy(x, y) + fn from_xy(x: f32, y: f32) -> Val<::bevy_math::Isometry2d> { + let output: Val<::bevy_math::Isometry2d> = ::bevy_math::Isometry2d::from_xy(x, y) .into(); output } /// The inverse isometry that undoes this one. - fn inverse(_self: Ref) -> Val { - let output: Val = bevy::math::Isometry2d::inverse(&_self) + fn inverse(_self: Ref<::bevy_math::Isometry2d>) -> Val<::bevy_math::Isometry2d> { + let output: Val<::bevy_math::Isometry2d> = ::bevy_math::Isometry2d::inverse( + &_self, + ) .into(); output } @@ -239,10 +243,10 @@ impl bevy::math::Isometry2d { /// If the same isometry is used multiple times, it is more efficient to instead compute /// the inverse once and use that for each transformation. fn inverse_mul( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Isometry2d::inverse_mul( + _self: Ref<::bevy_math::Isometry2d>, + rhs: Val<::bevy_math::Isometry2d>, + ) -> Val<::bevy_math::Isometry2d> { + let output: Val<::bevy_math::Isometry2d> = ::bevy_math::Isometry2d::inverse_mul( &_self, rhs.into_inner(), ) @@ -254,10 +258,10 @@ impl bevy::math::Isometry2d { /// If the same isometry is used multiple times, it is more efficient to instead compute /// the inverse once and use that for each transformation. fn inverse_transform_point( - _self: Ref, - point: Val, - ) -> Val { - let output: Val = bevy::math::Isometry2d::inverse_transform_point( + _self: Ref<::bevy_math::Isometry2d>, + point: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::Isometry2d::inverse_transform_point( &_self, point.into_inner(), ) @@ -265,41 +269,41 @@ impl bevy::math::Isometry2d { output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::bevy_math::Isometry2d>, + ) -> Val<::bevy_math::Isometry2d> { + let output: Val<::bevy_math::Isometry2d> = <::bevy_math::Isometry2d as ::core::ops::Mul< + ::bevy_math::Isometry2d, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::bevy_math::prelude::Dir2>, + ) -> Val<::bevy_math::prelude::Dir2> { + let output: Val<::bevy_math::prelude::Dir2> = <::bevy_math::Isometry2d as ::core::ops::Mul< + ::bevy_math::prelude::Dir2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = <::bevy_math::Isometry2d as ::core::ops::Mul< + ::bevy_math::prelude::Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } /// Create a two-dimensional isometry from a rotation and a translation. fn new( - translation: Val, - rotation: Val, - ) -> Val { - let output: Val = bevy::math::Isometry2d::new( + translation: Val<::bevy_math::prelude::Vec2>, + rotation: Val<::bevy_math::Rot2>, + ) -> Val<::bevy_math::Isometry2d> { + let output: Val<::bevy_math::Isometry2d> = ::bevy_math::Isometry2d::new( translation.into_inner(), rotation.into_inner(), ) @@ -308,10 +312,10 @@ impl bevy::math::Isometry2d { } /// Transform a point by rotating and translating it using this isometry. fn transform_point( - _self: Ref, - point: Val, - ) -> Val { - let output: Val = bevy::math::Isometry2d::transform_point( + _self: Ref<::bevy_math::Isometry2d>, + point: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::Isometry2d::transform_point( &_self, point.into_inner(), ) @@ -325,37 +329,37 @@ impl bevy::math::Isometry2d { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::Isometry3d { - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( +impl ::bevy_math::Isometry3d { + fn clone(_self: Ref<::bevy_math::Isometry3d>) -> Val<::bevy_math::Isometry3d> { + let output: Val<::bevy_math::Isometry3d> = <::bevy_math::Isometry3d as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::Isometry3d>, + other: Ref<::bevy_math::Isometry3d>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Create a three-dimensional isometry from a rotation. fn from_rotation( - rotation: Val, - ) -> Val { - let output: Val = bevy::math::Isometry3d::from_rotation( + rotation: Val<::bevy_math::prelude::Quat>, + ) -> Val<::bevy_math::Isometry3d> { + let output: Val<::bevy_math::Isometry3d> = ::bevy_math::Isometry3d::from_rotation( rotation.into_inner(), ) .into(); output } /// Create a three-dimensional isometry from a translation with the given `x`, `y`, and `z` components. - fn from_xyz(x: f32, y: f32, z: f32) -> Val { - let output: Val = bevy::math::Isometry3d::from_xyz( + fn from_xyz(x: f32, y: f32, z: f32) -> Val<::bevy_math::Isometry3d> { + let output: Val<::bevy_math::Isometry3d> = ::bevy_math::Isometry3d::from_xyz( x, y, z, @@ -364,8 +368,10 @@ impl bevy::math::Isometry3d { output } /// The inverse isometry that undoes this one. - fn inverse(_self: Ref) -> Val { - let output: Val = bevy::math::Isometry3d::inverse(&_self) + fn inverse(_self: Ref<::bevy_math::Isometry3d>) -> Val<::bevy_math::Isometry3d> { + let output: Val<::bevy_math::Isometry3d> = ::bevy_math::Isometry3d::inverse( + &_self, + ) .into(); output } @@ -373,10 +379,10 @@ impl bevy::math::Isometry3d { /// If the same isometry is used multiple times, it is more efficient to instead compute /// the inverse once and use that for each transformation. fn inverse_mul( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Isometry3d::inverse_mul( + _self: Ref<::bevy_math::Isometry3d>, + rhs: Val<::bevy_math::Isometry3d>, + ) -> Val<::bevy_math::Isometry3d> { + let output: Val<::bevy_math::Isometry3d> = ::bevy_math::Isometry3d::inverse_mul( &_self, rhs.into_inner(), ) @@ -384,41 +390,41 @@ impl bevy::math::Isometry3d { output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::bevy_math::Isometry3d>, + ) -> Val<::bevy_math::Isometry3d> { + let output: Val<::bevy_math::Isometry3d> = <::bevy_math::Isometry3d as ::core::ops::Mul< + ::bevy_math::Isometry3d, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::bevy_math::prelude::Dir3>, + ) -> Val<::bevy_math::prelude::Dir3> { + let output: Val<::bevy_math::prelude::Dir3> = <::bevy_math::Isometry3d as ::core::ops::Mul< + ::bevy_math::prelude::Dir3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::bevy_math::prelude::Vec3>, + ) -> Val<::bevy_math::prelude::Vec3> { + let output: Val<::bevy_math::prelude::Vec3> = <::bevy_math::Isometry3d as ::core::ops::Mul< + ::bevy_math::prelude::Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::bevy_math::prelude::Vec3A>, + ) -> Val<::bevy_math::prelude::Vec3A> { + let output: Val<::bevy_math::prelude::Vec3A> = <::bevy_math::Isometry3d as ::core::ops::Mul< + ::bevy_math::prelude::Vec3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output @@ -430,27 +436,27 @@ impl bevy::math::Isometry3d { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::Ray2d { - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( +impl ::bevy_math::Ray2d { + fn clone(_self: Ref<::bevy_math::Ray2d>) -> Val<::bevy_math::Ray2d> { + let output: Val<::bevy_math::Ray2d> = <::bevy_math::Ray2d as ::core::clone::Clone>::clone( &_self, ) .into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::bevy_math::Ray2d>) -> bool { + let output: bool = <::bevy_math::Ray2d as ::core::cmp::PartialEq< + ::bevy_math::Ray2d, >>::eq(&_self, &other) .into(); output } /// Get a point at a given distance along the ray fn get_point( - _self: Ref, + _self: Ref<::bevy_math::Ray2d>, distance: f32, - ) -> Val { - let output: Val = bevy::math::Ray2d::get_point( + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::Ray2d::get_point( &_self, distance, ) @@ -459,11 +465,11 @@ impl bevy::math::Ray2d { } /// Get the distance to a plane if the ray intersects it fn intersect_plane( - _self: Ref, - plane_origin: Val, - plane: Val, + _self: Ref<::bevy_math::Ray2d>, + plane_origin: Val<::bevy_math::prelude::Vec2>, + plane: Val<::bevy_math::primitives::Plane2d>, ) -> ::core::option::Option { - let output: ::core::option::Option = bevy::math::Ray2d::intersect_plane( + let output: ::core::option::Option = ::bevy_math::Ray2d::intersect_plane( &_self, plane_origin.into_inner(), plane.into_inner(), @@ -473,10 +479,10 @@ impl bevy::math::Ray2d { } /// Create a new `Ray2d` from a given origin and direction fn new( - origin: Val, - direction: Val, - ) -> Val { - let output: Val = bevy::math::Ray2d::new( + origin: Val<::bevy_math::prelude::Vec2>, + direction: Val<::bevy_math::prelude::Dir2>, + ) -> Val<::bevy_math::Ray2d> { + let output: Val<::bevy_math::Ray2d> = ::bevy_math::Ray2d::new( origin.into_inner(), direction.into_inner(), ) @@ -490,27 +496,27 @@ impl bevy::math::Ray2d { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::Ray3d { - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( +impl ::bevy_math::Ray3d { + fn clone(_self: Ref<::bevy_math::Ray3d>) -> Val<::bevy_math::Ray3d> { + let output: Val<::bevy_math::Ray3d> = <::bevy_math::Ray3d as ::core::clone::Clone>::clone( &_self, ) .into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::bevy_math::Ray3d>) -> bool { + let output: bool = <::bevy_math::Ray3d as ::core::cmp::PartialEq< + ::bevy_math::Ray3d, >>::eq(&_self, &other) .into(); output } /// Get a point at a given distance along the ray fn get_point( - _self: Ref, + _self: Ref<::bevy_math::Ray3d>, distance: f32, - ) -> Val { - let output: Val = bevy::math::Ray3d::get_point( + ) -> Val<::bevy_math::prelude::Vec3> { + let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::Ray3d::get_point( &_self, distance, ) @@ -519,11 +525,11 @@ impl bevy::math::Ray3d { } /// Get the distance to a plane if the ray intersects it fn intersect_plane( - _self: Ref, - plane_origin: Val, - plane: Val, + _self: Ref<::bevy_math::Ray3d>, + plane_origin: Val<::bevy_math::prelude::Vec3>, + plane: Val<::bevy_math::primitives::InfinitePlane3d>, ) -> ::core::option::Option { - let output: ::core::option::Option = bevy::math::Ray3d::intersect_plane( + let output: ::core::option::Option = ::bevy_math::Ray3d::intersect_plane( &_self, plane_origin.into_inner(), plane.into_inner(), @@ -533,10 +539,10 @@ impl bevy::math::Ray3d { } /// Create a new `Ray3d` from a given origin and direction fn new( - origin: Val, - direction: Val, - ) -> Val { - let output: Val = bevy::math::Ray3d::new( + origin: Val<::bevy_math::prelude::Vec3>, + direction: Val<::bevy_math::prelude::Dir3>, + ) -> Val<::bevy_math::Ray3d> { + let output: Val<::bevy_math::Ray3d> = ::bevy_math::Ray3d::new( origin.into_inner(), direction.into_inner(), ) @@ -550,10 +556,10 @@ impl bevy::math::Ray3d { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::Rot2 { +impl ::bevy_math::Rot2 { /// Returns the angle in radians needed to make `self` and `other` coincide. - fn angle_to(_self: Val, other: Val) -> f32 { - let output: f32 = bevy::math::Rot2::angle_to( + fn angle_to(_self: Val<::bevy_math::Rot2>, other: Val<::bevy_math::Rot2>) -> f32 { + let output: f32 = ::bevy_math::Rot2::angle_to( _self.into_inner(), other.into_inner(), ) @@ -561,22 +567,22 @@ impl bevy::math::Rot2 { output } /// Returns the rotation in degrees in the `(-180, 180]` range. - fn as_degrees(_self: Val) -> f32 { - let output: f32 = bevy::math::Rot2::as_degrees(_self.into_inner()).into(); + fn as_degrees(_self: Val<::bevy_math::Rot2>) -> f32 { + let output: f32 = ::bevy_math::Rot2::as_degrees(_self.into_inner()).into(); output } /// Returns the rotation in radians in the `(-pi, pi]` range. - fn as_radians(_self: Val) -> f32 { - let output: f32 = bevy::math::Rot2::as_radians(_self.into_inner()).into(); + fn as_radians(_self: Val<::bevy_math::Rot2>) -> f32 { + let output: f32 = ::bevy_math::Rot2::as_radians(_self.into_inner()).into(); output } /// Returns the rotation as a fraction of a full 360 degree turn. - fn as_turn_fraction(_self: Val) -> f32 { - let output: f32 = bevy::math::Rot2::as_turn_fraction(_self.into_inner()).into(); + fn as_turn_fraction(_self: Val<::bevy_math::Rot2>) -> f32 { + let output: f32 = ::bevy_math::Rot2::as_turn_fraction(_self.into_inner()).into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::bevy_math::Rot2>) -> Val<::bevy_math::Rot2> { + let output: Val<::bevy_math::Rot2> = <::bevy_math::Rot2 as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -597,13 +603,13 @@ impl bevy::math::Rot2 { /// #[cfg(feature = "approx")] /// assert_relative_eq!(rot1 * rot1, rot3); /// ``` - fn degrees(degrees: f32) -> Val { - let output: Val = bevy::math::Rot2::degrees(degrees).into(); + fn degrees(degrees: f32) -> Val<::bevy_math::Rot2> { + let output: Val<::bevy_math::Rot2> = ::bevy_math::Rot2::degrees(degrees).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::bevy_math::Rot2>) -> bool { + let output: bool = <::bevy_math::Rot2 as ::core::cmp::PartialEq< + ::bevy_math::Rot2, >>::eq(&_self, &other) .into(); output @@ -611,8 +617,8 @@ impl bevy::math::Rot2 { /// Returns `self` after an approximate normalization, assuming the value is already nearly normalized. /// Useful for preventing numerical error accumulation. /// See [`Dir3::fast_renormalize`](crate::Dir3::fast_renormalize) for an example of when such error accumulation might occur. - fn fast_renormalize(_self: Val) -> Val { - let output: Val = bevy::math::Rot2::fast_renormalize( + fn fast_renormalize(_self: Val<::bevy_math::Rot2>) -> Val<::bevy_math::Rot2> { + let output: Val<::bevy_math::Rot2> = ::bevy_math::Rot2::fast_renormalize( _self.into_inner(), ) .into(); @@ -622,51 +628,54 @@ impl bevy::math::Rot2 { /// The rotation is only valid if `sin * sin + cos * cos == 1.0`. /// # Panics /// Panics if `sin * sin + cos * cos != 1.0` when the `glam_assert` feature is enabled. - fn from_sin_cos(sin: f32, cos: f32) -> Val { - let output: Val = bevy::math::Rot2::from_sin_cos(sin, cos) + fn from_sin_cos(sin: f32, cos: f32) -> Val<::bevy_math::Rot2> { + let output: Val<::bevy_math::Rot2> = ::bevy_math::Rot2::from_sin_cos(sin, cos) .into(); output } /// Returns the inverse of the rotation. This is also the conjugate /// of the unit complex number representing the rotation. - fn inverse(_self: Val) -> Val { - let output: Val = bevy::math::Rot2::inverse(_self.into_inner()) + fn inverse(_self: Val<::bevy_math::Rot2>) -> Val<::bevy_math::Rot2> { + let output: Val<::bevy_math::Rot2> = ::bevy_math::Rot2::inverse( + _self.into_inner(), + ) .into(); output } /// Returns `true` if the rotation is neither infinite nor NaN. - fn is_finite(_self: Val) -> bool { - let output: bool = bevy::math::Rot2::is_finite(_self.into_inner()).into(); + fn is_finite(_self: Val<::bevy_math::Rot2>) -> bool { + let output: bool = ::bevy_math::Rot2::is_finite(_self.into_inner()).into(); output } /// Returns `true` if the rotation is NaN. - fn is_nan(_self: Val) -> bool { - let output: bool = bevy::math::Rot2::is_nan(_self.into_inner()).into(); + fn is_nan(_self: Val<::bevy_math::Rot2>) -> bool { + let output: bool = ::bevy_math::Rot2::is_nan(_self.into_inner()).into(); output } /// Returns `true` if the rotation is near [`Rot2::IDENTITY`]. - fn is_near_identity(_self: Val) -> bool { - let output: bool = bevy::math::Rot2::is_near_identity(_self.into_inner()).into(); + fn is_near_identity(_self: Val<::bevy_math::Rot2>) -> bool { + let output: bool = ::bevy_math::Rot2::is_near_identity(_self.into_inner()) + .into(); output } /// Returns whether `self` has a length of `1.0` or not. /// Uses a precision threshold of approximately `1e-4`. - fn is_normalized(_self: Val) -> bool { - let output: bool = bevy::math::Rot2::is_normalized(_self.into_inner()).into(); + fn is_normalized(_self: Val<::bevy_math::Rot2>) -> bool { + let output: bool = ::bevy_math::Rot2::is_normalized(_self.into_inner()).into(); output } /// Computes the length or norm of the complex number used to represent the rotation. /// The length is typically expected to be `1.0`. Unexpectedly denormalized rotations /// can be a result of incorrect construction or floating point error caused by /// successive operations. - fn length(_self: Val) -> f32 { - let output: f32 = bevy::math::Rot2::length(_self.into_inner()).into(); + fn length(_self: Val<::bevy_math::Rot2>) -> f32 { + let output: f32 = ::bevy_math::Rot2::length(_self.into_inner()).into(); output } /// Computes `1.0 / self.length()`. /// For valid results, `self` must _not_ have a length of zero. - fn length_recip(_self: Val) -> f32 { - let output: f32 = bevy::math::Rot2::length_recip(_self.into_inner()).into(); + fn length_recip(_self: Val<::bevy_math::Rot2>) -> f32 { + let output: f32 = ::bevy_math::Rot2::length_recip(_self.into_inner()).into(); output } /// Computes the squared length or norm of the complex number used to represent the rotation. @@ -675,38 +684,38 @@ impl bevy::math::Rot2 { /// The length is typically expected to be `1.0`. Unexpectedly denormalized rotations /// can be a result of incorrect construction or floating point error caused by /// successive operations. - fn length_squared(_self: Val) -> f32 { - let output: f32 = bevy::math::Rot2::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::bevy_math::Rot2>) -> f32 { + let output: f32 = ::bevy_math::Rot2::length_squared(_self.into_inner()).into(); output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::bevy_math::Rot2>, + ) -> Val<::bevy_math::Rot2> { + let output: Val<::bevy_math::Rot2> = <::bevy_math::Rot2 as ::core::ops::Mul< + ::bevy_math::Rot2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } /// Rotates the [`Dir2`] using a [`Rot2`]. fn mul( - _self: Val, - direction: Val, - ) -> Val { - let output: Val = , + direction: Val<::bevy_math::prelude::Dir2>, + ) -> Val<::bevy_math::prelude::Dir2> { + let output: Val<::bevy_math::prelude::Dir2> = <::bevy_math::Rot2 as ::core::ops::Mul< + ::bevy_math::prelude::Dir2, >>::mul(_self.into_inner(), direction.into_inner()) .into(); output } /// Rotates a [`Vec2`] by a [`Rot2`]. fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = <::bevy_math::Rot2 as ::core::ops::Mul< + ::bevy_math::prelude::Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output @@ -739,11 +748,11 @@ impl bevy::math::Rot2 { /// assert_eq!(result2.as_degrees(), 67.5); /// ``` fn nlerp( - _self: Val, - end: Val, + _self: Val<::bevy_math::Rot2>, + end: Val<::bevy_math::Rot2>, s: f32, - ) -> Val { - let output: Val = bevy::math::Rot2::nlerp( + ) -> Val<::bevy_math::Rot2> { + let output: Val<::bevy_math::Rot2> = ::bevy_math::Rot2::nlerp( _self.into_inner(), end.into_inner(), s, @@ -758,8 +767,8 @@ impl bevy::math::Rot2 { /// with invalid values. /// # Panics /// Panics if `self` has a length of zero, NaN, or infinity when debug assertions are enabled. - fn normalize(_self: Val) -> Val { - let output: Val = bevy::math::Rot2::normalize( + fn normalize(_self: Val<::bevy_math::Rot2>) -> Val<::bevy_math::Rot2> { + let output: Val<::bevy_math::Rot2> = ::bevy_math::Rot2::normalize( _self.into_inner(), ) .into(); @@ -781,13 +790,13 @@ impl bevy::math::Rot2 { /// #[cfg(feature = "approx")] /// assert_relative_eq!(rot1 * rot1, rot3); /// ``` - fn radians(radians: f32) -> Val { - let output: Val = bevy::math::Rot2::radians(radians).into(); + fn radians(radians: f32) -> Val<::bevy_math::Rot2> { + let output: Val<::bevy_math::Rot2> = ::bevy_math::Rot2::radians(radians).into(); output } /// Returns the sine and cosine of the rotation angle in radians. - fn sin_cos(_self: Val) -> (f32, f32) { - let output: (f32, f32) = bevy::math::Rot2::sin_cos(_self.into_inner()).into(); + fn sin_cos(_self: Val<::bevy_math::Rot2>) -> (f32, f32) { + let output: (f32, f32) = ::bevy_math::Rot2::sin_cos(_self.into_inner()).into(); output } /// Performs a spherical linear interpolation between `self` and `end` @@ -809,11 +818,11 @@ impl bevy::math::Rot2 { /// assert_eq!(result2.as_degrees(), 67.5); /// ``` fn slerp( - _self: Val, - end: Val, + _self: Val<::bevy_math::Rot2>, + end: Val<::bevy_math::Rot2>, s: f32, - ) -> Val { - let output: Val = bevy::math::Rot2::slerp( + ) -> Val<::bevy_math::Rot2> { + let output: Val<::bevy_math::Rot2> = ::bevy_math::Rot2::slerp( _self.into_inner(), end.into_inner(), s, @@ -836,8 +845,8 @@ impl bevy::math::Rot2 { /// #[cfg(feature = "approx")] /// assert_relative_eq!(rot1 * rot1, rot3); /// ``` - fn turn_fraction(fraction: f32) -> Val { - let output: Val = bevy::math::Rot2::turn_fraction(fraction) + fn turn_fraction(fraction: f32) -> Val<::bevy_math::Rot2> { + let output: Val<::bevy_math::Rot2> = ::bevy_math::Rot2::turn_fraction(fraction) .into(); output } @@ -848,28 +857,30 @@ impl bevy::math::Rot2 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::prelude::Dir2 { +impl ::bevy_math::prelude::Dir2 { /// Returns the inner [`Vec2`] - fn as_vec2(_self: Ref) -> Val { - let output: Val = bevy::math::prelude::Dir2::as_vec2( + fn as_vec2( + _self: Ref<::bevy_math::prelude::Dir2>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::prelude::Dir2::as_vec2( &_self, ) .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::bevy_math::prelude::Dir2>) -> Val<::bevy_math::prelude::Dir2> { + let output: Val<::bevy_math::prelude::Dir2> = <::bevy_math::prelude::Dir2 as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::prelude::Dir2>, + other: Ref<::bevy_math::prelude::Dir2>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -878,9 +889,9 @@ impl bevy::math::prelude::Dir2 { /// Useful for preventing numerical error accumulation. /// See [`Dir3::fast_renormalize`] for an example of when such error accumulation might occur. fn fast_renormalize( - _self: Val, - ) -> Val { - let output: Val = bevy::math::prelude::Dir2::fast_renormalize( + _self: Val<::bevy_math::prelude::Dir2>, + ) -> Val<::bevy_math::prelude::Dir2> { + let output: Val<::bevy_math::prelude::Dir2> = ::bevy_math::prelude::Dir2::fast_renormalize( _self.into_inner(), ) .into(); @@ -889,8 +900,8 @@ impl bevy::math::prelude::Dir2 { /// Create a direction from its `x` and `y` components, assuming the resulting vector is normalized. /// # Warning /// The vector produced from `x` and `y` must be normalized, i.e its length must be `1.0`. - fn from_xy_unchecked(x: f32, y: f32) -> Val { - let output: Val = bevy::math::prelude::Dir2::from_xy_unchecked( + fn from_xy_unchecked(x: f32, y: f32) -> Val<::bevy_math::prelude::Dir2> { + let output: Val<::bevy_math::prelude::Dir2> = ::bevy_math::prelude::Dir2::from_xy_unchecked( x, y, ) @@ -898,17 +909,17 @@ impl bevy::math::prelude::Dir2 { output } fn mul( - _self: Val, + _self: Val<::bevy_math::prelude::Dir2>, rhs: f32, - ) -> Val { - let output: Val = Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = <::bevy_math::prelude::Dir2 as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::bevy_math::prelude::Dir2>) -> Val<::bevy_math::prelude::Dir2> { + let output: Val<::bevy_math::prelude::Dir2> = <::bevy_math::prelude::Dir2 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -918,9 +929,9 @@ impl bevy::math::prelude::Dir2 { /// # Warning /// `value` must be normalized, i.e its length must be `1.0`. fn new_unchecked( - value: Val, - ) -> Val { - let output: Val = bevy::math::prelude::Dir2::new_unchecked( + value: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::prelude::Dir2> { + let output: Val<::bevy_math::prelude::Dir2> = ::bevy_math::prelude::Dir2::new_unchecked( value.into_inner(), ) .into(); @@ -928,10 +939,10 @@ impl bevy::math::prelude::Dir2 { } /// Get the rotation that rotates `other` to this direction. fn rotation_from( - _self: Val, - other: Val, - ) -> Val { - let output: Val = bevy::math::prelude::Dir2::rotation_from( + _self: Val<::bevy_math::prelude::Dir2>, + other: Val<::bevy_math::prelude::Dir2>, + ) -> Val<::bevy_math::Rot2> { + let output: Val<::bevy_math::Rot2> = ::bevy_math::prelude::Dir2::rotation_from( _self.into_inner(), other.into_inner(), ) @@ -939,16 +950,20 @@ impl bevy::math::prelude::Dir2 { output } /// Get the rotation that rotates the X-axis to this direction. - fn rotation_from_x(_self: Val) -> Val { - let output: Val = bevy::math::prelude::Dir2::rotation_from_x( + fn rotation_from_x( + _self: Val<::bevy_math::prelude::Dir2>, + ) -> Val<::bevy_math::Rot2> { + let output: Val<::bevy_math::Rot2> = ::bevy_math::prelude::Dir2::rotation_from_x( _self.into_inner(), ) .into(); output } /// Get the rotation that rotates the Y-axis to this direction. - fn rotation_from_y(_self: Val) -> Val { - let output: Val = bevy::math::prelude::Dir2::rotation_from_y( + fn rotation_from_y( + _self: Val<::bevy_math::prelude::Dir2>, + ) -> Val<::bevy_math::Rot2> { + let output: Val<::bevy_math::Rot2> = ::bevy_math::prelude::Dir2::rotation_from_y( _self.into_inner(), ) .into(); @@ -956,10 +971,10 @@ impl bevy::math::prelude::Dir2 { } /// Get the rotation that rotates this direction to `other`. fn rotation_to( - _self: Val, - other: Val, - ) -> Val { - let output: Val = bevy::math::prelude::Dir2::rotation_to( + _self: Val<::bevy_math::prelude::Dir2>, + other: Val<::bevy_math::prelude::Dir2>, + ) -> Val<::bevy_math::Rot2> { + let output: Val<::bevy_math::Rot2> = ::bevy_math::prelude::Dir2::rotation_to( _self.into_inner(), other.into_inner(), ) @@ -967,16 +982,16 @@ impl bevy::math::prelude::Dir2 { output } /// Get the rotation that rotates this direction to the X-axis. - fn rotation_to_x(_self: Val) -> Val { - let output: Val = bevy::math::prelude::Dir2::rotation_to_x( + fn rotation_to_x(_self: Val<::bevy_math::prelude::Dir2>) -> Val<::bevy_math::Rot2> { + let output: Val<::bevy_math::Rot2> = ::bevy_math::prelude::Dir2::rotation_to_x( _self.into_inner(), ) .into(); output } /// Get the rotation that rotates this direction to the Y-axis. - fn rotation_to_y(_self: Val) -> Val { - let output: Val = bevy::math::prelude::Dir2::rotation_to_y( + fn rotation_to_y(_self: Val<::bevy_math::prelude::Dir2>) -> Val<::bevy_math::Rot2> { + let output: Val<::bevy_math::Rot2> = ::bevy_math::prelude::Dir2::rotation_to_y( _self.into_inner(), ) .into(); @@ -1002,11 +1017,11 @@ impl bevy::math::prelude::Dir2 { /// assert_relative_eq!(result2, Dir2::from_xy(0.5_f32.sqrt(), 0.5_f32.sqrt()).unwrap()); /// ``` fn slerp( - _self: Val, - rhs: Val, + _self: Val<::bevy_math::prelude::Dir2>, + rhs: Val<::bevy_math::prelude::Dir2>, s: f32, - ) -> Val { - let output: Val = bevy::math::prelude::Dir2::slerp( + ) -> Val<::bevy_math::prelude::Dir2> { + let output: Val<::bevy_math::prelude::Dir2> = ::bevy_math::prelude::Dir2::slerp( _self.into_inner(), rhs.into_inner(), s, @@ -1021,28 +1036,30 @@ impl bevy::math::prelude::Dir2 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::prelude::Dir3 { +impl ::bevy_math::prelude::Dir3 { /// Returns the inner [`Vec3`] - fn as_vec3(_self: Ref) -> Val { - let output: Val = bevy::math::prelude::Dir3::as_vec3( + fn as_vec3( + _self: Ref<::bevy_math::prelude::Dir3>, + ) -> Val<::bevy_math::prelude::Vec3> { + let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::prelude::Dir3::as_vec3( &_self, ) .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::bevy_math::prelude::Dir3>) -> Val<::bevy_math::prelude::Dir3> { + let output: Val<::bevy_math::prelude::Dir3> = <::bevy_math::prelude::Dir3 as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::prelude::Dir3>, + other: Ref<::bevy_math::prelude::Dir3>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -1073,9 +1090,9 @@ impl bevy::math::prelude::Dir3 { /// } /// ``` fn fast_renormalize( - _self: Val, - ) -> Val { - let output: Val = bevy::math::prelude::Dir3::fast_renormalize( + _self: Val<::bevy_math::prelude::Dir3>, + ) -> Val<::bevy_math::prelude::Dir3> { + let output: Val<::bevy_math::prelude::Dir3> = ::bevy_math::prelude::Dir3::fast_renormalize( _self.into_inner(), ) .into(); @@ -1084,8 +1101,8 @@ impl bevy::math::prelude::Dir3 { /// Create a direction from its `x`, `y`, and `z` components, assuming the resulting vector is normalized. /// # Warning /// The vector produced from `x`, `y`, and `z` must be normalized, i.e its length must be `1.0`. - fn from_xyz_unchecked(x: f32, y: f32, z: f32) -> Val { - let output: Val = bevy::math::prelude::Dir3::from_xyz_unchecked( + fn from_xyz_unchecked(x: f32, y: f32, z: f32) -> Val<::bevy_math::prelude::Dir3> { + let output: Val<::bevy_math::prelude::Dir3> = ::bevy_math::prelude::Dir3::from_xyz_unchecked( x, y, z, @@ -1094,17 +1111,17 @@ impl bevy::math::prelude::Dir3 { output } fn mul( - _self: Val, + _self: Val<::bevy_math::prelude::Dir3>, rhs: f32, - ) -> Val { - let output: Val = Val<::bevy_math::prelude::Vec3> { + let output: Val<::bevy_math::prelude::Vec3> = <::bevy_math::prelude::Dir3 as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::bevy_math::prelude::Dir3>) -> Val<::bevy_math::prelude::Dir3> { + let output: Val<::bevy_math::prelude::Dir3> = <::bevy_math::prelude::Dir3 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -1114,9 +1131,9 @@ impl bevy::math::prelude::Dir3 { /// # Warning /// `value` must be normalized, i.e its length must be `1.0`. fn new_unchecked( - value: Val, - ) -> Val { - let output: Val = bevy::math::prelude::Dir3::new_unchecked( + value: Val<::bevy_math::prelude::Vec3>, + ) -> Val<::bevy_math::prelude::Dir3> { + let output: Val<::bevy_math::prelude::Dir3> = ::bevy_math::prelude::Dir3::new_unchecked( value.into_inner(), ) .into(); @@ -1146,11 +1163,11 @@ impl bevy::math::prelude::Dir3 { /// assert_relative_eq!(result2, Dir3::from_xyz(0.5_f32.sqrt(), 0.5_f32.sqrt(), 0.0).unwrap()); /// ``` fn slerp( - _self: Val, - rhs: Val, + _self: Val<::bevy_math::prelude::Dir3>, + rhs: Val<::bevy_math::prelude::Dir3>, s: f32, - ) -> Val { - let output: Val = bevy::math::prelude::Dir3::slerp( + ) -> Val<::bevy_math::prelude::Dir3> { + let output: Val<::bevy_math::prelude::Dir3> = ::bevy_math::prelude::Dir3::slerp( _self.into_inner(), rhs.into_inner(), s, @@ -1165,30 +1182,32 @@ impl bevy::math::prelude::Dir3 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::prelude::Dir3A { +impl ::bevy_math::prelude::Dir3A { /// Returns the inner [`Vec3A`] fn as_vec3a( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::prelude::Dir3A::as_vec3a( + _self: Ref<::bevy_math::prelude::Dir3A>, + ) -> Val<::bevy_math::prelude::Vec3A> { + let output: Val<::bevy_math::prelude::Vec3A> = ::bevy_math::prelude::Dir3A::as_vec3a( &_self, ) .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone( + _self: Ref<::bevy_math::prelude::Dir3A>, + ) -> Val<::bevy_math::prelude::Dir3A> { + let output: Val<::bevy_math::prelude::Dir3A> = <::bevy_math::prelude::Dir3A as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::prelude::Dir3A>, + other: Ref<::bevy_math::prelude::Dir3A>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -1197,9 +1216,9 @@ impl bevy::math::prelude::Dir3A { /// Useful for preventing numerical error accumulation. /// See [`Dir3::fast_renormalize`] for an example of when such error accumulation might occur. fn fast_renormalize( - _self: Val, - ) -> Val { - let output: Val = bevy::math::prelude::Dir3A::fast_renormalize( + _self: Val<::bevy_math::prelude::Dir3A>, + ) -> Val<::bevy_math::prelude::Dir3A> { + let output: Val<::bevy_math::prelude::Dir3A> = ::bevy_math::prelude::Dir3A::fast_renormalize( _self.into_inner(), ) .into(); @@ -1208,8 +1227,8 @@ impl bevy::math::prelude::Dir3A { /// Create a direction from its `x`, `y`, and `z` components, assuming the resulting vector is normalized. /// # Warning /// The vector produced from `x`, `y`, and `z` must be normalized, i.e its length must be `1.0`. - fn from_xyz_unchecked(x: f32, y: f32, z: f32) -> Val { - let output: Val = bevy::math::prelude::Dir3A::from_xyz_unchecked( + fn from_xyz_unchecked(x: f32, y: f32, z: f32) -> Val<::bevy_math::prelude::Dir3A> { + let output: Val<::bevy_math::prelude::Dir3A> = ::bevy_math::prelude::Dir3A::from_xyz_unchecked( x, y, z, @@ -1218,17 +1237,17 @@ impl bevy::math::prelude::Dir3A { output } fn mul( - _self: Val, + _self: Val<::bevy_math::prelude::Dir3A>, rhs: f32, - ) -> Val { - let output: Val = Val<::bevy_math::prelude::Vec3A> { + let output: Val<::bevy_math::prelude::Vec3A> = <::bevy_math::prelude::Dir3A as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::bevy_math::prelude::Dir3A>) -> Val<::bevy_math::prelude::Dir3A> { + let output: Val<::bevy_math::prelude::Dir3A> = <::bevy_math::prelude::Dir3A as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -1238,9 +1257,9 @@ impl bevy::math::prelude::Dir3A { /// # Warning /// `value` must be normalized, i.e its length must be `1.0`. fn new_unchecked( - value: Val, - ) -> Val { - let output: Val = bevy::math::prelude::Dir3A::new_unchecked( + value: Val<::bevy_math::prelude::Vec3A>, + ) -> Val<::bevy_math::prelude::Dir3A> { + let output: Val<::bevy_math::prelude::Dir3A> = ::bevy_math::prelude::Dir3A::new_unchecked( value.into_inner(), ) .into(); @@ -1270,11 +1289,11 @@ impl bevy::math::prelude::Dir3A { /// assert_relative_eq!(result2, Dir3A::from_xyz(0.5_f32.sqrt(), 0.5_f32.sqrt(), 0.0).unwrap()); /// ``` fn slerp( - _self: Val, - rhs: Val, + _self: Val<::bevy_math::prelude::Dir3A>, + rhs: Val<::bevy_math::prelude::Dir3A>, s: f32, - ) -> Val { - let output: Val = bevy::math::prelude::Dir3A::slerp( + ) -> Val<::bevy_math::prelude::Dir3A> { + let output: Val<::bevy_math::prelude::Dir3A> = ::bevy_math::prelude::Dir3A::slerp( _self.into_inner(), rhs.into_inner(), s, @@ -1289,12 +1308,12 @@ impl bevy::math::prelude::Dir3A { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::prelude::IRect { +impl ::bevy_math::prelude::IRect { /// Returns self as [`Rect`] (f32) fn as_rect( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::prelude::IRect::as_rect( + _self: Ref<::bevy_math::prelude::IRect>, + ) -> Val<::bevy_math::prelude::Rect> { + let output: Val<::bevy_math::prelude::Rect> = ::bevy_math::prelude::IRect::as_rect( &_self, ) .into(); @@ -1302,16 +1321,16 @@ impl bevy::math::prelude::IRect { } /// Returns self as [`URect`] (u32) fn as_urect( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::prelude::IRect::as_urect( + _self: Ref<::bevy_math::prelude::IRect>, + ) -> Val<::bevy_math::prelude::URect> { + let output: Val<::bevy_math::prelude::URect> = ::bevy_math::prelude::IRect::as_urect( &_self, ) .into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::bevy_math::prelude::IRect>) -> () { + let output: () = <::bevy_math::prelude::IRect as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -1327,16 +1346,18 @@ impl bevy::math::prelude::IRect { /// assert_eq!(r.center(), IVec2::new(2, 1)); /// ``` fn center( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::prelude::IRect::center( + _self: Ref<::bevy_math::prelude::IRect>, + ) -> Val<::bevy_math::prelude::IVec2> { + let output: Val<::bevy_math::prelude::IVec2> = ::bevy_math::prelude::IRect::center( &_self, ) .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone( + _self: Ref<::bevy_math::prelude::IRect>, + ) -> Val<::bevy_math::prelude::IRect> { + let output: Val<::bevy_math::prelude::IRect> = <::bevy_math::prelude::IRect as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -1352,10 +1373,10 @@ impl bevy::math::prelude::IRect { /// assert!(r.contains(r.max)); /// ``` fn contains( - _self: Ref, - point: Val, + _self: Ref<::bevy_math::prelude::IRect>, + point: Val<::bevy_math::prelude::IVec2>, ) -> bool { - let output: bool = bevy::math::prelude::IRect::contains( + let output: bool = ::bevy_math::prelude::IRect::contains( &_self, point.into_inner(), ) @@ -1363,11 +1384,11 @@ impl bevy::math::prelude::IRect { output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::prelude::IRect>, + other: Ref<::bevy_math::prelude::IRect>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -1383,10 +1404,10 @@ impl bevy::math::prelude::IRect { /// assert_eq!(r.max, IVec2::splat(1)); /// ``` fn from_center_half_size( - origin: Val, - half_size: Val, - ) -> Val { - let output: Val = bevy::math::prelude::IRect::from_center_half_size( + origin: Val<::bevy_math::prelude::IVec2>, + half_size: Val<::bevy_math::prelude::IVec2>, + ) -> Val<::bevy_math::prelude::IRect> { + let output: Val<::bevy_math::prelude::IRect> = ::bevy_math::prelude::IRect::from_center_half_size( origin.into_inner(), half_size.into_inner(), ) @@ -1406,10 +1427,10 @@ impl bevy::math::prelude::IRect { /// assert_eq!(r.max, IVec2::splat(1)); /// ``` fn from_center_size( - origin: Val, - size: Val, - ) -> Val { - let output: Val = bevy::math::prelude::IRect::from_center_size( + origin: Val<::bevy_math::prelude::IVec2>, + size: Val<::bevy_math::prelude::IVec2>, + ) -> Val<::bevy_math::prelude::IRect> { + let output: Val<::bevy_math::prelude::IRect> = ::bevy_math::prelude::IRect::from_center_size( origin.into_inner(), size.into_inner(), ) @@ -1428,10 +1449,10 @@ impl bevy::math::prelude::IRect { /// let r = IRect::from_corners(IVec2::ONE, IVec2::ZERO); // w=1 h=1 /// ``` fn from_corners( - p0: Val, - p1: Val, - ) -> Val { - let output: Val = bevy::math::prelude::IRect::from_corners( + p0: Val<::bevy_math::prelude::IVec2>, + p1: Val<::bevy_math::prelude::IVec2>, + ) -> Val<::bevy_math::prelude::IRect> { + let output: Val<::bevy_math::prelude::IRect> = ::bevy_math::prelude::IRect::from_corners( p0.into_inner(), p1.into_inner(), ) @@ -1448,9 +1469,9 @@ impl bevy::math::prelude::IRect { /// assert_eq!(r.half_size(), IVec2::new(2, 1)); /// ``` fn half_size( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::prelude::IRect::half_size( + _self: Ref<::bevy_math::prelude::IRect>, + ) -> Val<::bevy_math::prelude::IVec2> { + let output: Val<::bevy_math::prelude::IVec2> = ::bevy_math::prelude::IRect::half_size( &_self, ) .into(); @@ -1463,8 +1484,8 @@ impl bevy::math::prelude::IRect { /// let r = IRect::new(0, 0, 5, 1); // w=5 h=1 /// assert_eq!(r.height(), 1); /// ``` - fn height(_self: Ref) -> i32 { - let output: i32 = bevy::math::prelude::IRect::height(&_self).into(); + fn height(_self: Ref<::bevy_math::prelude::IRect>) -> i32 { + let output: i32 = ::bevy_math::prelude::IRect::height(&_self).into(); output } /// Create a new rectangle by expanding it evenly on all sides. @@ -1484,10 +1505,10 @@ impl bevy::math::prelude::IRect { /// assert_eq!(r2.max, IVec2::new(3, 2)); /// ``` fn inflate( - _self: Ref, + _self: Ref<::bevy_math::prelude::IRect>, expansion: i32, - ) -> Val { - let output: Val = bevy::math::prelude::IRect::inflate( + ) -> Val<::bevy_math::prelude::IRect> { + let output: Val<::bevy_math::prelude::IRect> = ::bevy_math::prelude::IRect::inflate( &_self, expansion, ) @@ -1508,10 +1529,10 @@ impl bevy::math::prelude::IRect { /// assert_eq!(r.max, IVec2::new(3, 1)); /// ``` fn intersect( - _self: Ref, - other: Val, - ) -> Val { - let output: Val = bevy::math::prelude::IRect::intersect( + _self: Ref<::bevy_math::prelude::IRect>, + other: Val<::bevy_math::prelude::IRect>, + ) -> Val<::bevy_math::prelude::IRect> { + let output: Val<::bevy_math::prelude::IRect> = ::bevy_math::prelude::IRect::intersect( &_self, other.into_inner(), ) @@ -1525,8 +1546,8 @@ impl bevy::math::prelude::IRect { /// let r = IRect::from_corners(IVec2::ZERO, IVec2::new(0, 1)); // w=0 h=1 /// assert!(r.is_empty()); /// ``` - fn is_empty(_self: Ref) -> bool { - let output: bool = bevy::math::prelude::IRect::is_empty(&_self).into(); + fn is_empty(_self: Ref<::bevy_math::prelude::IRect>) -> bool { + let output: bool = ::bevy_math::prelude::IRect::is_empty(&_self).into(); output } /// Create a new rectangle from two corner points. @@ -1538,8 +1559,8 @@ impl bevy::math::prelude::IRect { /// let r = IRect::new(0, 4, 10, 6); // w=10 h=2 /// let r = IRect::new(2, 3, 5, -1); // w=3 h=4 /// ``` - fn new(x0: i32, y0: i32, x1: i32, y1: i32) -> Val { - let output: Val = bevy::math::prelude::IRect::new( + fn new(x0: i32, y0: i32, x1: i32, y1: i32) -> Val<::bevy_math::prelude::IRect> { + let output: Val<::bevy_math::prelude::IRect> = ::bevy_math::prelude::IRect::new( x0, y0, x1, @@ -1555,8 +1576,10 @@ impl bevy::math::prelude::IRect { /// let r = IRect::new(0, 0, 5, 1); // w=5 h=1 /// assert_eq!(r.size(), IVec2::new(5, 1)); /// ``` - fn size(_self: Ref) -> Val { - let output: Val = bevy::math::prelude::IRect::size( + fn size( + _self: Ref<::bevy_math::prelude::IRect>, + ) -> Val<::bevy_math::prelude::IVec2> { + let output: Val<::bevy_math::prelude::IVec2> = ::bevy_math::prelude::IRect::size( &_self, ) .into(); @@ -1574,10 +1597,10 @@ impl bevy::math::prelude::IRect { /// assert_eq!(r.max, IVec2::new(5, 3)); /// ``` fn union( - _self: Ref, - other: Val, - ) -> Val { - let output: Val = bevy::math::prelude::IRect::union( + _self: Ref<::bevy_math::prelude::IRect>, + other: Val<::bevy_math::prelude::IRect>, + ) -> Val<::bevy_math::prelude::IRect> { + let output: Val<::bevy_math::prelude::IRect> = ::bevy_math::prelude::IRect::union( &_self, other.into_inner(), ) @@ -1596,10 +1619,10 @@ impl bevy::math::prelude::IRect { /// assert_eq!(u.max, IVec2::new(5, 6)); /// ``` fn union_point( - _self: Ref, - other: Val, - ) -> Val { - let output: Val = bevy::math::prelude::IRect::union_point( + _self: Ref<::bevy_math::prelude::IRect>, + other: Val<::bevy_math::prelude::IVec2>, + ) -> Val<::bevy_math::prelude::IRect> { + let output: Val<::bevy_math::prelude::IRect> = ::bevy_math::prelude::IRect::union_point( &_self, other.into_inner(), ) @@ -1613,8 +1636,8 @@ impl bevy::math::prelude::IRect { /// let r = IRect::new(0, 0, 5, 1); // w=5 h=1 /// assert_eq!(r.width(), 5); /// ``` - fn width(_self: Ref) -> i32 { - let output: i32 = bevy::math::prelude::IRect::width(&_self).into(); + fn width(_self: Ref<::bevy_math::prelude::IRect>) -> i32 { + let output: i32 = ::bevy_math::prelude::IRect::width(&_self).into(); output } } @@ -1624,12 +1647,12 @@ impl bevy::math::prelude::IRect { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::prelude::Rect { +impl ::bevy_math::prelude::Rect { /// Returns self as [`IRect`] (i32) fn as_irect( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::prelude::Rect::as_irect( + _self: Ref<::bevy_math::prelude::Rect>, + ) -> Val<::bevy_math::prelude::IRect> { + let output: Val<::bevy_math::prelude::IRect> = ::bevy_math::prelude::Rect::as_irect( &_self, ) .into(); @@ -1637,9 +1660,9 @@ impl bevy::math::prelude::Rect { } /// Returns self as [`URect`] (u32) fn as_urect( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::prelude::Rect::as_urect( + _self: Ref<::bevy_math::prelude::Rect>, + ) -> Val<::bevy_math::prelude::URect> { + let output: Val<::bevy_math::prelude::URect> = ::bevy_math::prelude::Rect::as_urect( &_self, ) .into(); @@ -1652,15 +1675,17 @@ impl bevy::math::prelude::Rect { /// let r = Rect::new(0., 0., 5., 1.); // w=5 h=1 /// assert!(r.center().abs_diff_eq(Vec2::new(2.5, 0.5), 1e-5)); /// ``` - fn center(_self: Ref) -> Val { - let output: Val = bevy::math::prelude::Rect::center( + fn center( + _self: Ref<::bevy_math::prelude::Rect>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::prelude::Rect::center( &_self, ) .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::bevy_math::prelude::Rect>) -> Val<::bevy_math::prelude::Rect> { + let output: Val<::bevy_math::prelude::Rect> = <::bevy_math::prelude::Rect as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -1676,10 +1701,10 @@ impl bevy::math::prelude::Rect { /// assert!(r.contains(r.max)); /// ``` fn contains( - _self: Ref, - point: Val, + _self: Ref<::bevy_math::prelude::Rect>, + point: Val<::bevy_math::prelude::Vec2>, ) -> bool { - let output: bool = bevy::math::prelude::Rect::contains( + let output: bool = ::bevy_math::prelude::Rect::contains( &_self, point.into_inner(), ) @@ -1687,11 +1712,11 @@ impl bevy::math::prelude::Rect { output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::prelude::Rect>, + other: Ref<::bevy_math::prelude::Rect>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -1707,10 +1732,10 @@ impl bevy::math::prelude::Rect { /// assert!(r.max.abs_diff_eq(Vec2::splat(1.), 1e-5)); /// ``` fn from_center_half_size( - origin: Val, - half_size: Val, - ) -> Val { - let output: Val = bevy::math::prelude::Rect::from_center_half_size( + origin: Val<::bevy_math::prelude::Vec2>, + half_size: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::prelude::Rect> { + let output: Val<::bevy_math::prelude::Rect> = ::bevy_math::prelude::Rect::from_center_half_size( origin.into_inner(), half_size.into_inner(), ) @@ -1728,10 +1753,10 @@ impl bevy::math::prelude::Rect { /// assert!(r.max.abs_diff_eq(Vec2::splat(0.5), 1e-5)); /// ``` fn from_center_size( - origin: Val, - size: Val, - ) -> Val { - let output: Val = bevy::math::prelude::Rect::from_center_size( + origin: Val<::bevy_math::prelude::Vec2>, + size: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::prelude::Rect> { + let output: Val<::bevy_math::prelude::Rect> = ::bevy_math::prelude::Rect::from_center_size( origin.into_inner(), size.into_inner(), ) @@ -1750,10 +1775,10 @@ impl bevy::math::prelude::Rect { /// let r = Rect::from_corners(Vec2::ONE, Vec2::ZERO); // w=1 h=1 /// ``` fn from_corners( - p0: Val, - p1: Val, - ) -> Val { - let output: Val = bevy::math::prelude::Rect::from_corners( + p0: Val<::bevy_math::prelude::Vec2>, + p1: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::prelude::Rect> { + let output: Val<::bevy_math::prelude::Rect> = ::bevy_math::prelude::Rect::from_corners( p0.into_inner(), p1.into_inner(), ) @@ -1768,9 +1793,9 @@ impl bevy::math::prelude::Rect { /// assert!(r.half_size().abs_diff_eq(Vec2::new(2.5, 0.5), 1e-5)); /// ``` fn half_size( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::prelude::Rect::half_size( + _self: Ref<::bevy_math::prelude::Rect>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::prelude::Rect::half_size( &_self, ) .into(); @@ -1783,8 +1808,8 @@ impl bevy::math::prelude::Rect { /// let r = Rect::new(0., 0., 5., 1.); // w=5 h=1 /// assert!((r.height() - 1.).abs() <= 1e-5); /// ``` - fn height(_self: Ref) -> f32 { - let output: f32 = bevy::math::prelude::Rect::height(&_self).into(); + fn height(_self: Ref<::bevy_math::prelude::Rect>) -> f32 { + let output: f32 = ::bevy_math::prelude::Rect::height(&_self).into(); output } /// Create a new rectangle by expanding it evenly on all sides. @@ -1804,10 +1829,10 @@ impl bevy::math::prelude::Rect { /// assert!(r2.max.abs_diff_eq(Vec2::new(4., 5.), 1e-5)); /// ``` fn inflate( - _self: Ref, + _self: Ref<::bevy_math::prelude::Rect>, expansion: f32, - ) -> Val { - let output: Val = bevy::math::prelude::Rect::inflate( + ) -> Val<::bevy_math::prelude::Rect> { + let output: Val<::bevy_math::prelude::Rect> = ::bevy_math::prelude::Rect::inflate( &_self, expansion, ) @@ -1828,10 +1853,10 @@ impl bevy::math::prelude::Rect { /// assert!(r.max.abs_diff_eq(Vec2::new(3., 1.), 1e-5)); /// ``` fn intersect( - _self: Ref, - other: Val, - ) -> Val { - let output: Val = bevy::math::prelude::Rect::intersect( + _self: Ref<::bevy_math::prelude::Rect>, + other: Val<::bevy_math::prelude::Rect>, + ) -> Val<::bevy_math::prelude::Rect> { + let output: Val<::bevy_math::prelude::Rect> = ::bevy_math::prelude::Rect::intersect( &_self, other.into_inner(), ) @@ -1845,8 +1870,8 @@ impl bevy::math::prelude::Rect { /// let r = Rect::from_corners(Vec2::ZERO, Vec2::new(0., 1.)); // w=0 h=1 /// assert!(r.is_empty()); /// ``` - fn is_empty(_self: Ref) -> bool { - let output: bool = bevy::math::prelude::Rect::is_empty(&_self).into(); + fn is_empty(_self: Ref<::bevy_math::prelude::Rect>) -> bool { + let output: bool = ::bevy_math::prelude::Rect::is_empty(&_self).into(); output } /// Create a new rectangle from two corner points. @@ -1858,8 +1883,8 @@ impl bevy::math::prelude::Rect { /// let r = Rect::new(0., 4., 10., 6.); // w=10 h=2 /// let r = Rect::new(2., 3., 5., -1.); // w=3 h=4 /// ``` - fn new(x0: f32, y0: f32, x1: f32, y1: f32) -> Val { - let output: Val = bevy::math::prelude::Rect::new( + fn new(x0: f32, y0: f32, x1: f32, y1: f32) -> Val<::bevy_math::prelude::Rect> { + let output: Val<::bevy_math::prelude::Rect> = ::bevy_math::prelude::Rect::new( x0, y0, x1, @@ -1882,10 +1907,10 @@ impl bevy::math::prelude::Rect { /// assert_eq!(n.max.y, 0.6); /// ``` fn normalize( - _self: Ref, - other: Val, - ) -> Val { - let output: Val = bevy::math::prelude::Rect::normalize( + _self: Ref<::bevy_math::prelude::Rect>, + other: Val<::bevy_math::prelude::Rect>, + ) -> Val<::bevy_math::prelude::Rect> { + let output: Val<::bevy_math::prelude::Rect> = ::bevy_math::prelude::Rect::normalize( &_self, other.into_inner(), ) @@ -1899,8 +1924,8 @@ impl bevy::math::prelude::Rect { /// let r = Rect::new(0., 0., 5., 1.); // w=5 h=1 /// assert!(r.size().abs_diff_eq(Vec2::new(5., 1.), 1e-5)); /// ``` - fn size(_self: Ref) -> Val { - let output: Val = bevy::math::prelude::Rect::size( + fn size(_self: Ref<::bevy_math::prelude::Rect>) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::prelude::Rect::size( &_self, ) .into(); @@ -1918,10 +1943,10 @@ impl bevy::math::prelude::Rect { /// assert!(r.max.abs_diff_eq(Vec2::new(5., 3.), 1e-5)); /// ``` fn union( - _self: Ref, - other: Val, - ) -> Val { - let output: Val = bevy::math::prelude::Rect::union( + _self: Ref<::bevy_math::prelude::Rect>, + other: Val<::bevy_math::prelude::Rect>, + ) -> Val<::bevy_math::prelude::Rect> { + let output: Val<::bevy_math::prelude::Rect> = ::bevy_math::prelude::Rect::union( &_self, other.into_inner(), ) @@ -1940,10 +1965,10 @@ impl bevy::math::prelude::Rect { /// assert!(u.max.abs_diff_eq(Vec2::new(5., 6.), 1e-5)); /// ``` fn union_point( - _self: Ref, - other: Val, - ) -> Val { - let output: Val = bevy::math::prelude::Rect::union_point( + _self: Ref<::bevy_math::prelude::Rect>, + other: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::prelude::Rect> { + let output: Val<::bevy_math::prelude::Rect> = ::bevy_math::prelude::Rect::union_point( &_self, other.into_inner(), ) @@ -1957,8 +1982,8 @@ impl bevy::math::prelude::Rect { /// let r = Rect::new(0., 0., 5., 1.); // w=5 h=1 /// assert!((r.width() - 5.).abs() <= 1e-5); /// ``` - fn width(_self: Ref) -> f32 { - let output: f32 = bevy::math::prelude::Rect::width(&_self).into(); + fn width(_self: Ref<::bevy_math::prelude::Rect>) -> f32 { + let output: f32 = ::bevy_math::prelude::Rect::width(&_self).into(); output } } @@ -1968,12 +1993,12 @@ impl bevy::math::prelude::Rect { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::prelude::URect { +impl ::bevy_math::prelude::URect { /// Returns self as [`IRect`] (i32) fn as_irect( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::prelude::URect::as_irect( + _self: Ref<::bevy_math::prelude::URect>, + ) -> Val<::bevy_math::prelude::IRect> { + let output: Val<::bevy_math::prelude::IRect> = ::bevy_math::prelude::URect::as_irect( &_self, ) .into(); @@ -1981,16 +2006,16 @@ impl bevy::math::prelude::URect { } /// Returns self as [`Rect`] (f32) fn as_rect( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::prelude::URect::as_rect( + _self: Ref<::bevy_math::prelude::URect>, + ) -> Val<::bevy_math::prelude::Rect> { + let output: Val<::bevy_math::prelude::Rect> = ::bevy_math::prelude::URect::as_rect( &_self, ) .into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::bevy_math::prelude::URect>) -> () { + let output: () = <::bevy_math::prelude::URect as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -2006,16 +2031,18 @@ impl bevy::math::prelude::URect { /// assert_eq!(r.center(), UVec2::new(2, 1)); /// ``` fn center( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::prelude::URect::center( + _self: Ref<::bevy_math::prelude::URect>, + ) -> Val<::bevy_math::prelude::UVec2> { + let output: Val<::bevy_math::prelude::UVec2> = ::bevy_math::prelude::URect::center( &_self, ) .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone( + _self: Ref<::bevy_math::prelude::URect>, + ) -> Val<::bevy_math::prelude::URect> { + let output: Val<::bevy_math::prelude::URect> = <::bevy_math::prelude::URect as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -2031,10 +2058,10 @@ impl bevy::math::prelude::URect { /// assert!(r.contains(r.max)); /// ``` fn contains( - _self: Ref, - point: Val, + _self: Ref<::bevy_math::prelude::URect>, + point: Val<::bevy_math::prelude::UVec2>, ) -> bool { - let output: bool = bevy::math::prelude::URect::contains( + let output: bool = ::bevy_math::prelude::URect::contains( &_self, point.into_inner(), ) @@ -2042,11 +2069,11 @@ impl bevy::math::prelude::URect { output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::prelude::URect>, + other: Ref<::bevy_math::prelude::URect>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -2062,10 +2089,10 @@ impl bevy::math::prelude::URect { /// assert_eq!(r.max, UVec2::splat(2)); /// ``` fn from_center_half_size( - origin: Val, - half_size: Val, - ) -> Val { - let output: Val = bevy::math::prelude::URect::from_center_half_size( + origin: Val<::bevy_math::prelude::UVec2>, + half_size: Val<::bevy_math::prelude::UVec2>, + ) -> Val<::bevy_math::prelude::URect> { + let output: Val<::bevy_math::prelude::URect> = ::bevy_math::prelude::URect::from_center_half_size( origin.into_inner(), half_size.into_inner(), ) @@ -2085,10 +2112,10 @@ impl bevy::math::prelude::URect { /// assert_eq!(r.max, UVec2::splat(2)); /// ``` fn from_center_size( - origin: Val, - size: Val, - ) -> Val { - let output: Val = bevy::math::prelude::URect::from_center_size( + origin: Val<::bevy_math::prelude::UVec2>, + size: Val<::bevy_math::prelude::UVec2>, + ) -> Val<::bevy_math::prelude::URect> { + let output: Val<::bevy_math::prelude::URect> = ::bevy_math::prelude::URect::from_center_size( origin.into_inner(), size.into_inner(), ) @@ -2107,10 +2134,10 @@ impl bevy::math::prelude::URect { /// let r = URect::from_corners(UVec2::ONE, UVec2::ZERO); // w=1 h=1 /// ``` fn from_corners( - p0: Val, - p1: Val, - ) -> Val { - let output: Val = bevy::math::prelude::URect::from_corners( + p0: Val<::bevy_math::prelude::UVec2>, + p1: Val<::bevy_math::prelude::UVec2>, + ) -> Val<::bevy_math::prelude::URect> { + let output: Val<::bevy_math::prelude::URect> = ::bevy_math::prelude::URect::from_corners( p0.into_inner(), p1.into_inner(), ) @@ -2127,9 +2154,9 @@ impl bevy::math::prelude::URect { /// assert_eq!(r.half_size(), UVec2::new(2, 1)); /// ``` fn half_size( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::prelude::URect::half_size( + _self: Ref<::bevy_math::prelude::URect>, + ) -> Val<::bevy_math::prelude::UVec2> { + let output: Val<::bevy_math::prelude::UVec2> = ::bevy_math::prelude::URect::half_size( &_self, ) .into(); @@ -2142,8 +2169,8 @@ impl bevy::math::prelude::URect { /// let r = URect::new(0, 0, 5, 1); // w=5 h=1 /// assert_eq!(r.height(), 1); /// ``` - fn height(_self: Ref) -> u32 { - let output: u32 = bevy::math::prelude::URect::height(&_self).into(); + fn height(_self: Ref<::bevy_math::prelude::URect>) -> u32 { + let output: u32 = ::bevy_math::prelude::URect::height(&_self).into(); output } /// Create a new rectangle by expanding it evenly on all sides. @@ -2163,10 +2190,10 @@ impl bevy::math::prelude::URect { /// assert_eq!(r2.max, UVec2::splat(7)); /// ``` fn inflate( - _self: Ref, + _self: Ref<::bevy_math::prelude::URect>, expansion: i32, - ) -> Val { - let output: Val = bevy::math::prelude::URect::inflate( + ) -> Val<::bevy_math::prelude::URect> { + let output: Val<::bevy_math::prelude::URect> = ::bevy_math::prelude::URect::inflate( &_self, expansion, ) @@ -2187,10 +2214,10 @@ impl bevy::math::prelude::URect { /// assert_eq!(r.max, UVec2::new(2, 2)); /// ``` fn intersect( - _self: Ref, - other: Val, - ) -> Val { - let output: Val = bevy::math::prelude::URect::intersect( + _self: Ref<::bevy_math::prelude::URect>, + other: Val<::bevy_math::prelude::URect>, + ) -> Val<::bevy_math::prelude::URect> { + let output: Val<::bevy_math::prelude::URect> = ::bevy_math::prelude::URect::intersect( &_self, other.into_inner(), ) @@ -2204,8 +2231,8 @@ impl bevy::math::prelude::URect { /// let r = URect::from_corners(UVec2::ZERO, UVec2::new(0, 1)); // w=0 h=1 /// assert!(r.is_empty()); /// ``` - fn is_empty(_self: Ref) -> bool { - let output: bool = bevy::math::prelude::URect::is_empty(&_self).into(); + fn is_empty(_self: Ref<::bevy_math::prelude::URect>) -> bool { + let output: bool = ::bevy_math::prelude::URect::is_empty(&_self).into(); output } /// Create a new rectangle from two corner points. @@ -2217,8 +2244,8 @@ impl bevy::math::prelude::URect { /// let r = URect::new(0, 4, 10, 6); // w=10 h=2 /// let r = URect::new(2, 4, 5, 0); // w=3 h=4 /// ``` - fn new(x0: u32, y0: u32, x1: u32, y1: u32) -> Val { - let output: Val = bevy::math::prelude::URect::new( + fn new(x0: u32, y0: u32, x1: u32, y1: u32) -> Val<::bevy_math::prelude::URect> { + let output: Val<::bevy_math::prelude::URect> = ::bevy_math::prelude::URect::new( x0, y0, x1, @@ -2234,8 +2261,10 @@ impl bevy::math::prelude::URect { /// let r = URect::new(0, 0, 5, 1); // w=5 h=1 /// assert_eq!(r.size(), UVec2::new(5, 1)); /// ``` - fn size(_self: Ref) -> Val { - let output: Val = bevy::math::prelude::URect::size( + fn size( + _self: Ref<::bevy_math::prelude::URect>, + ) -> Val<::bevy_math::prelude::UVec2> { + let output: Val<::bevy_math::prelude::UVec2> = ::bevy_math::prelude::URect::size( &_self, ) .into(); @@ -2253,10 +2282,10 @@ impl bevy::math::prelude::URect { /// assert_eq!(r.max, UVec2::new(5, 8)); /// ``` fn union( - _self: Ref, - other: Val, - ) -> Val { - let output: Val = bevy::math::prelude::URect::union( + _self: Ref<::bevy_math::prelude::URect>, + other: Val<::bevy_math::prelude::URect>, + ) -> Val<::bevy_math::prelude::URect> { + let output: Val<::bevy_math::prelude::URect> = ::bevy_math::prelude::URect::union( &_self, other.into_inner(), ) @@ -2275,10 +2304,10 @@ impl bevy::math::prelude::URect { /// assert_eq!(u.max, UVec2::new(5, 6)); /// ``` fn union_point( - _self: Ref, - other: Val, - ) -> Val { - let output: Val = bevy::math::prelude::URect::union_point( + _self: Ref<::bevy_math::prelude::URect>, + other: Val<::bevy_math::prelude::UVec2>, + ) -> Val<::bevy_math::prelude::URect> { + let output: Val<::bevy_math::prelude::URect> = ::bevy_math::prelude::URect::union_point( &_self, other.into_inner(), ) @@ -2292,8 +2321,8 @@ impl bevy::math::prelude::URect { /// let r = URect::new(0, 0, 5, 1); // w=5 h=1 /// assert_eq!(r.width(), 5); /// ``` - fn width(_self: Ref) -> u32 { - let output: u32 = bevy::math::prelude::URect::width(&_self).into(); + fn width(_self: Ref<::bevy_math::prelude::URect>) -> u32 { + let output: u32 = ::bevy_math::prelude::URect::width(&_self).into(); output } } @@ -2303,28 +2332,28 @@ impl bevy::math::prelude::URect { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::Affine3 {} +impl ::bevy_math::Affine3 {} #[script_bindings( remote, name = "aabb_2_d_functions", bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::bounding::Aabb2d { +impl ::bevy_math::bounding::Aabb2d { /// Computes the smallest [`BoundingCircle`] containing this [`Aabb2d`]. fn bounding_circle( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::bounding::Aabb2d::bounding_circle( + _self: Ref<::bevy_math::bounding::Aabb2d>, + ) -> Val<::bevy_math::bounding::BoundingCircle> { + let output: Val<::bevy_math::bounding::BoundingCircle> = ::bevy_math::bounding::Aabb2d::bounding_circle( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::bounding::Aabb2d>, + ) -> Val<::bevy_math::bounding::Aabb2d> { + let output: Val<::bevy_math::bounding::Aabb2d> = <::bevy_math::bounding::Aabb2d as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -2334,10 +2363,10 @@ impl bevy::math::bounding::Aabb2d { /// If the point is outside the AABB, the returned point will be on the perimeter of the AABB. /// Otherwise, it will be inside the AABB and returned as is. fn closest_point( - _self: Ref, - point: Val, - ) -> Val { - let output: Val = bevy::math::bounding::Aabb2d::closest_point( + _self: Ref<::bevy_math::bounding::Aabb2d>, + point: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::bounding::Aabb2d::closest_point( &_self, point.into_inner(), ) @@ -2345,21 +2374,21 @@ impl bevy::math::bounding::Aabb2d { output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::bounding::Aabb2d>, + other: Ref<::bevy_math::bounding::Aabb2d>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Constructs an AABB from its center and half-size. fn new( - center: Val, - half_size: Val, - ) -> Val { - let output: Val = bevy::math::bounding::Aabb2d::new( + center: Val<::bevy_math::prelude::Vec2>, + half_size: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::bounding::Aabb2d> { + let output: Val<::bevy_math::bounding::Aabb2d> = ::bevy_math::bounding::Aabb2d::new( center.into_inner(), half_size.into_inner(), ) @@ -2373,21 +2402,21 @@ impl bevy::math::bounding::Aabb2d { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::bounding::BoundingCircle { +impl ::bevy_math::bounding::BoundingCircle { /// Computes the smallest [`Aabb2d`] containing this [`BoundingCircle`]. fn aabb_2d( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::bounding::BoundingCircle::aabb_2d( + _self: Ref<::bevy_math::bounding::BoundingCircle>, + ) -> Val<::bevy_math::bounding::Aabb2d> { + let output: Val<::bevy_math::bounding::Aabb2d> = ::bevy_math::bounding::BoundingCircle::aabb_2d( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::bounding::BoundingCircle>, + ) -> Val<::bevy_math::bounding::BoundingCircle> { + let output: Val<::bevy_math::bounding::BoundingCircle> = <::bevy_math::bounding::BoundingCircle as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -2397,10 +2426,10 @@ impl bevy::math::bounding::BoundingCircle { /// If the point is outside the circle, the returned point will be on the perimeter of the circle. /// Otherwise, it will be inside the circle and returned as is. fn closest_point( - _self: Ref, - point: Val, - ) -> Val { - let output: Val = bevy::math::bounding::BoundingCircle::closest_point( + _self: Ref<::bevy_math::bounding::BoundingCircle>, + point: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::bounding::BoundingCircle::closest_point( &_self, point.into_inner(), ) @@ -2408,21 +2437,21 @@ impl bevy::math::bounding::BoundingCircle { output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::bounding::BoundingCircle>, + other: Ref<::bevy_math::bounding::BoundingCircle>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Constructs a bounding circle from its center and radius. fn new( - center: Val, + center: Val<::bevy_math::prelude::Vec2>, radius: f32, - ) -> Val { - let output: Val = bevy::math::bounding::BoundingCircle::new( + ) -> Val<::bevy_math::bounding::BoundingCircle> { + let output: Val<::bevy_math::bounding::BoundingCircle> = ::bevy_math::bounding::BoundingCircle::new( center.into_inner(), radius, ) @@ -2430,8 +2459,8 @@ impl bevy::math::bounding::BoundingCircle { output } /// Get the radius of the bounding circle - fn radius(_self: Ref) -> f32 { - let output: f32 = bevy::math::bounding::BoundingCircle::radius(&_self).into(); + fn radius(_self: Ref<::bevy_math::bounding::BoundingCircle>) -> f32 { + let output: f32 = ::bevy_math::bounding::BoundingCircle::radius(&_self).into(); output } } @@ -2441,11 +2470,11 @@ impl bevy::math::bounding::BoundingCircle { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::Circle { +impl ::bevy_math::primitives::Circle { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::Circle>, + ) -> Val<::bevy_math::primitives::Circle> { + let output: Val<::bevy_math::primitives::Circle> = <::bevy_math::primitives::Circle as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -2455,10 +2484,10 @@ impl bevy::math::primitives::Circle { /// If the point is outside the circle, the returned point will be on the perimeter of the circle. /// Otherwise, it will be inside the circle and returned as is. fn closest_point( - _self: Ref, - point: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Circle::closest_point( + _self: Ref<::bevy_math::primitives::Circle>, + point: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Circle::closest_point( &_self, point.into_inner(), ) @@ -2466,23 +2495,23 @@ impl bevy::math::primitives::Circle { output } /// Get the diameter of the circle - fn diameter(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Circle::diameter(&_self).into(); + fn diameter(_self: Ref<::bevy_math::primitives::Circle>) -> f32 { + let output: f32 = ::bevy_math::primitives::Circle::diameter(&_self).into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::Circle>, + other: Ref<::bevy_math::primitives::Circle>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Create a new [`Circle`] from a `radius` - fn new(radius: f32) -> Val { - let output: Val = bevy::math::primitives::Circle::new( + fn new(radius: f32) -> Val<::bevy_math::primitives::Circle> { + let output: Val<::bevy_math::primitives::Circle> = ::bevy_math::primitives::Circle::new( radius, ) .into(); @@ -2495,11 +2524,11 @@ impl bevy::math::primitives::Circle { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::Annulus { +impl ::bevy_math::primitives::Annulus { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::Annulus>, + ) -> Val<::bevy_math::primitives::Annulus> { + let output: Val<::bevy_math::primitives::Annulus> = <::bevy_math::primitives::Annulus as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -2510,10 +2539,10 @@ impl bevy::math::primitives::Annulus { /// - If the point is inside of the inner circle (hole) of the annulus, the returned point will be on the inner perimeter. /// - Otherwise, the returned point is overlapping the annulus and returned as is. fn closest_point( - _self: Ref, - point: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Annulus::closest_point( + _self: Ref<::bevy_math::primitives::Annulus>, + point: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Annulus::closest_point( &_self, point.into_inner(), ) @@ -2521,16 +2550,16 @@ impl bevy::math::primitives::Annulus { output } /// Get the diameter of the annulus - fn diameter(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Annulus::diameter(&_self).into(); + fn diameter(_self: Ref<::bevy_math::primitives::Annulus>) -> f32 { + let output: f32 = ::bevy_math::primitives::Annulus::diameter(&_self).into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::Annulus>, + other: Ref<::bevy_math::primitives::Annulus>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -2539,8 +2568,8 @@ impl bevy::math::primitives::Annulus { fn new( inner_radius: f32, outer_radius: f32, - ) -> Val { - let output: Val = bevy::math::primitives::Annulus::new( + ) -> Val<::bevy_math::primitives::Annulus> { + let output: Val<::bevy_math::primitives::Annulus> = ::bevy_math::primitives::Annulus::new( inner_radius, outer_radius, ) @@ -2548,8 +2577,8 @@ impl bevy::math::primitives::Annulus { output } /// Get the thickness of the annulus - fn thickness(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Annulus::thickness(&_self).into(); + fn thickness(_self: Ref<::bevy_math::primitives::Annulus>) -> f32 { + let output: f32 = ::bevy_math::primitives::Annulus::thickness(&_self).into(); output } } @@ -2559,57 +2588,57 @@ impl bevy::math::primitives::Annulus { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::Arc2d { +impl ::bevy_math::primitives::Arc2d { /// Get the angle of the arc - fn angle(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Arc2d::angle(&_self).into(); + fn angle(_self: Ref<::bevy_math::primitives::Arc2d>) -> f32 { + let output: f32 = ::bevy_math::primitives::Arc2d::angle(&_self).into(); output } /// Get the length of the apothem of this arc, that is, /// the distance from the center of the circle to the midpoint of the chord, in the direction of the midpoint of the arc. /// Equivalently, the [`radius`](Self::radius) minus the [`sagitta`](Self::sagitta). /// Note that for a [`major`](Self::is_major) arc, the apothem will be negative. - fn apothem(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Arc2d::apothem(&_self).into(); + fn apothem(_self: Ref<::bevy_math::primitives::Arc2d>) -> f32 { + let output: f32 = ::bevy_math::primitives::Arc2d::apothem(&_self).into(); output } /// Get the distance between the endpoints (the length of the chord) - fn chord_length(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Arc2d::chord_length(&_self).into(); + fn chord_length(_self: Ref<::bevy_math::primitives::Arc2d>) -> f32 { + let output: f32 = ::bevy_math::primitives::Arc2d::chord_length(&_self).into(); output } /// Get the midpoint of the two endpoints (the midpoint of the chord) fn chord_midpoint( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Arc2d::chord_midpoint( + _self: Ref<::bevy_math::primitives::Arc2d>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Arc2d::chord_midpoint( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::Arc2d>, + ) -> Val<::bevy_math::primitives::Arc2d> { + let output: Val<::bevy_math::primitives::Arc2d> = <::bevy_math::primitives::Arc2d as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::Arc2d>, + other: Ref<::bevy_math::primitives::Arc2d>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Create a new [`Arc2d`] from a `radius` and an `angle` in degrees. - fn from_degrees(radius: f32, angle: f32) -> Val { - let output: Val = bevy::math::primitives::Arc2d::from_degrees( + fn from_degrees(radius: f32, angle: f32) -> Val<::bevy_math::primitives::Arc2d> { + let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::from_degrees( radius, angle, ) @@ -2617,8 +2646,8 @@ impl bevy::math::primitives::Arc2d { output } /// Create a new [`Arc2d`] from a `radius` and an `angle` in radians - fn from_radians(radius: f32, angle: f32) -> Val { - let output: Val = bevy::math::primitives::Arc2d::from_radians( + fn from_radians(radius: f32, angle: f32) -> Val<::bevy_math::primitives::Arc2d> { + let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::from_radians( radius, angle, ) @@ -2627,8 +2656,8 @@ impl bevy::math::primitives::Arc2d { } /// Create a new [`Arc2d`] from a `radius` and a `fraction` of a single turn. /// For instance, `0.5` turns is a semicircle. - fn from_turns(radius: f32, fraction: f32) -> Val { - let output: Val = bevy::math::primitives::Arc2d::from_turns( + fn from_turns(radius: f32, fraction: f32) -> Val<::bevy_math::primitives::Arc2d> { + let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::from_turns( radius, fraction, ) @@ -2636,51 +2665,51 @@ impl bevy::math::primitives::Arc2d { output } /// Get half the distance between the endpoints (half the length of the chord) - fn half_chord_length(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Arc2d::half_chord_length(&_self) + fn half_chord_length(_self: Ref<::bevy_math::primitives::Arc2d>) -> f32 { + let output: f32 = ::bevy_math::primitives::Arc2d::half_chord_length(&_self) .into(); output } /// Produces true if the arc is at least half a circle. /// **Note:** This is not the negation of [`is_minor`](Self::is_minor): an exact semicircle is both major and minor. - fn is_major(_self: Ref) -> bool { - let output: bool = bevy::math::primitives::Arc2d::is_major(&_self).into(); + fn is_major(_self: Ref<::bevy_math::primitives::Arc2d>) -> bool { + let output: bool = ::bevy_math::primitives::Arc2d::is_major(&_self).into(); output } /// Produces true if the arc is at most half a circle. /// **Note:** This is not the negation of [`is_major`](Self::is_major): an exact semicircle is both major and minor. - fn is_minor(_self: Ref) -> bool { - let output: bool = bevy::math::primitives::Arc2d::is_minor(&_self).into(); + fn is_minor(_self: Ref<::bevy_math::primitives::Arc2d>) -> bool { + let output: bool = ::bevy_math::primitives::Arc2d::is_minor(&_self).into(); output } /// Get the left-hand end point of the arc fn left_endpoint( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Arc2d::left_endpoint( + _self: Ref<::bevy_math::primitives::Arc2d>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Arc2d::left_endpoint( &_self, ) .into(); output } /// Get the length of the arc - fn length(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Arc2d::length(&_self).into(); + fn length(_self: Ref<::bevy_math::primitives::Arc2d>) -> f32 { + let output: f32 = ::bevy_math::primitives::Arc2d::length(&_self).into(); output } /// Get the midpoint of the arc fn midpoint( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Arc2d::midpoint( + _self: Ref<::bevy_math::primitives::Arc2d>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Arc2d::midpoint( &_self, ) .into(); output } /// Create a new [`Arc2d`] from a `radius` and a `half_angle` - fn new(radius: f32, half_angle: f32) -> Val { - let output: Val = bevy::math::primitives::Arc2d::new( + fn new(radius: f32, half_angle: f32) -> Val<::bevy_math::primitives::Arc2d> { + let output: Val<::bevy_math::primitives::Arc2d> = ::bevy_math::primitives::Arc2d::new( radius, half_angle, ) @@ -2689,9 +2718,9 @@ impl bevy::math::primitives::Arc2d { } /// Get the right-hand end point of the arc fn right_endpoint( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Arc2d::right_endpoint( + _self: Ref<::bevy_math::primitives::Arc2d>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Arc2d::right_endpoint( &_self, ) .into(); @@ -2701,8 +2730,8 @@ impl bevy::math::primitives::Arc2d { /// the length of the line between the midpoints of the arc and its chord. /// Equivalently, the height of the triangle whose base is the chord and whose apex is the midpoint of the arc. /// The sagitta is also the sum of the [`radius`](Self::radius) and the [`apothem`](Self::apothem). - fn sagitta(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Arc2d::sagitta(&_self).into(); + fn sagitta(_self: Ref<::bevy_math::primitives::Arc2d>) -> f32 { + let output: f32 = ::bevy_math::primitives::Arc2d::sagitta(&_self).into(); output } } @@ -2712,29 +2741,29 @@ impl bevy::math::primitives::Arc2d { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::Capsule2d { +impl ::bevy_math::primitives::Capsule2d { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::Capsule2d>, + ) -> Val<::bevy_math::primitives::Capsule2d> { + let output: Val<::bevy_math::primitives::Capsule2d> = <::bevy_math::primitives::Capsule2d as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::Capsule2d>, + other: Ref<::bevy_math::primitives::Capsule2d>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Create a new `Capsule2d` from a radius and length - fn new(radius: f32, length: f32) -> Val { - let output: Val = bevy::math::primitives::Capsule2d::new( + fn new(radius: f32, length: f32) -> Val<::bevy_math::primitives::Capsule2d> { + let output: Val<::bevy_math::primitives::Capsule2d> = ::bevy_math::primitives::Capsule2d::new( radius, length, ) @@ -2743,9 +2772,9 @@ impl bevy::math::primitives::Capsule2d { } /// Get the part connecting the semicircular ends of the capsule as a [`Rectangle`] fn to_inner_rectangle( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Capsule2d::to_inner_rectangle( + _self: Ref<::bevy_math::primitives::Capsule2d>, + ) -> Val<::bevy_math::primitives::Rectangle> { + let output: Val<::bevy_math::primitives::Rectangle> = ::bevy_math::primitives::Capsule2d::to_inner_rectangle( &_self, ) .into(); @@ -2758,57 +2787,58 @@ impl bevy::math::primitives::Capsule2d { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::CircularSector { +impl ::bevy_math::primitives::CircularSector { /// Get the angle of the sector - fn angle(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::CircularSector::angle(&_self).into(); + fn angle(_self: Ref<::bevy_math::primitives::CircularSector>) -> f32 { + let output: f32 = ::bevy_math::primitives::CircularSector::angle(&_self).into(); output } /// Get the length of the apothem of this sector /// See [`Arc2d::apothem`] - fn apothem(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::CircularSector::apothem(&_self).into(); + fn apothem(_self: Ref<::bevy_math::primitives::CircularSector>) -> f32 { + let output: f32 = ::bevy_math::primitives::CircularSector::apothem(&_self) + .into(); output } /// Get the length of the arc defining the sector - fn arc_length(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::CircularSector::arc_length(&_self) + fn arc_length(_self: Ref<::bevy_math::primitives::CircularSector>) -> f32 { + let output: f32 = ::bevy_math::primitives::CircularSector::arc_length(&_self) .into(); output } /// Get the length of the chord defined by the sector /// See [`Arc2d::chord_length`] - fn chord_length(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::CircularSector::chord_length(&_self) + fn chord_length(_self: Ref<::bevy_math::primitives::CircularSector>) -> f32 { + let output: f32 = ::bevy_math::primitives::CircularSector::chord_length(&_self) .into(); output } /// Get the midpoint of the chord defined by the sector /// See [`Arc2d::chord_midpoint`] fn chord_midpoint( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::CircularSector::chord_midpoint( + _self: Ref<::bevy_math::primitives::CircularSector>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::CircularSector::chord_midpoint( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::CircularSector>, + ) -> Val<::bevy_math::primitives::CircularSector> { + let output: Val<::bevy_math::primitives::CircularSector> = <::bevy_math::primitives::CircularSector as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::CircularSector>, + other: Ref<::bevy_math::primitives::CircularSector>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -2817,8 +2847,8 @@ impl bevy::math::primitives::CircularSector { fn from_degrees( radius: f32, angle: f32, - ) -> Val { - let output: Val = bevy::math::primitives::CircularSector::from_degrees( + ) -> Val<::bevy_math::primitives::CircularSector> { + let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::from_degrees( radius, angle, ) @@ -2829,8 +2859,8 @@ impl bevy::math::primitives::CircularSector { fn from_radians( radius: f32, angle: f32, - ) -> Val { - let output: Val = bevy::math::primitives::CircularSector::from_radians( + ) -> Val<::bevy_math::primitives::CircularSector> { + let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::from_radians( radius, angle, ) @@ -2842,8 +2872,8 @@ impl bevy::math::primitives::CircularSector { fn from_turns( radius: f32, fraction: f32, - ) -> Val { - let output: Val = bevy::math::primitives::CircularSector::from_turns( + ) -> Val<::bevy_math::primitives::CircularSector> { + let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::from_turns( radius, fraction, ) @@ -2851,23 +2881,23 @@ impl bevy::math::primitives::CircularSector { output } /// Get half the angle of the sector - fn half_angle(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::CircularSector::half_angle(&_self) + fn half_angle(_self: Ref<::bevy_math::primitives::CircularSector>) -> f32 { + let output: f32 = ::bevy_math::primitives::CircularSector::half_angle(&_self) .into(); output } /// Get half the length of the chord defined by the sector /// See [`Arc2d::half_chord_length`] - fn half_chord_length(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::CircularSector::half_chord_length( + fn half_chord_length(_self: Ref<::bevy_math::primitives::CircularSector>) -> f32 { + let output: f32 = ::bevy_math::primitives::CircularSector::half_chord_length( &_self, ) .into(); output } /// Create a new [`CircularSector`] from a `radius` and an `angle` - fn new(radius: f32, angle: f32) -> Val { - let output: Val = bevy::math::primitives::CircularSector::new( + fn new(radius: f32, angle: f32) -> Val<::bevy_math::primitives::CircularSector> { + let output: Val<::bevy_math::primitives::CircularSector> = ::bevy_math::primitives::CircularSector::new( radius, angle, ) @@ -2875,14 +2905,15 @@ impl bevy::math::primitives::CircularSector { output } /// Get the radius of the sector - fn radius(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::CircularSector::radius(&_self).into(); + fn radius(_self: Ref<::bevy_math::primitives::CircularSector>) -> f32 { + let output: f32 = ::bevy_math::primitives::CircularSector::radius(&_self).into(); output } /// Get the length of the sagitta of this sector /// See [`Arc2d::sagitta`] - fn sagitta(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::CircularSector::sagitta(&_self).into(); + fn sagitta(_self: Ref<::bevy_math::primitives::CircularSector>) -> f32 { + let output: f32 = ::bevy_math::primitives::CircularSector::sagitta(&_self) + .into(); output } } @@ -2892,57 +2923,57 @@ impl bevy::math::primitives::CircularSector { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::CircularSegment { +impl ::bevy_math::primitives::CircularSegment { /// Get the angle of the segment - fn angle(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::CircularSegment::angle(&_self).into(); + fn angle(_self: Ref<::bevy_math::primitives::CircularSegment>) -> f32 { + let output: f32 = ::bevy_math::primitives::CircularSegment::angle(&_self).into(); output } /// Get the length of the apothem of this segment, /// which is the signed distance between the segment and the center of its circle /// See [`Arc2d::apothem`] - fn apothem(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::CircularSegment::apothem(&_self) + fn apothem(_self: Ref<::bevy_math::primitives::CircularSegment>) -> f32 { + let output: f32 = ::bevy_math::primitives::CircularSegment::apothem(&_self) .into(); output } /// Get the length of the arc defining the segment - fn arc_length(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::CircularSegment::arc_length(&_self) + fn arc_length(_self: Ref<::bevy_math::primitives::CircularSegment>) -> f32 { + let output: f32 = ::bevy_math::primitives::CircularSegment::arc_length(&_self) .into(); output } /// Get the length of the segment's base, also known as its chord - fn chord_length(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::CircularSegment::chord_length(&_self) + fn chord_length(_self: Ref<::bevy_math::primitives::CircularSegment>) -> f32 { + let output: f32 = ::bevy_math::primitives::CircularSegment::chord_length(&_self) .into(); output } /// Get the midpoint of the segment's base, also known as its chord fn chord_midpoint( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::CircularSegment::chord_midpoint( + _self: Ref<::bevy_math::primitives::CircularSegment>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::CircularSegment::chord_midpoint( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::CircularSegment>, + ) -> Val<::bevy_math::primitives::CircularSegment> { + let output: Val<::bevy_math::primitives::CircularSegment> = <::bevy_math::primitives::CircularSegment as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::CircularSegment>, + other: Ref<::bevy_math::primitives::CircularSegment>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -2951,8 +2982,8 @@ impl bevy::math::primitives::CircularSegment { fn from_degrees( radius: f32, angle: f32, - ) -> Val { - let output: Val = bevy::math::primitives::CircularSegment::from_degrees( + ) -> Val<::bevy_math::primitives::CircularSegment> { + let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::from_degrees( radius, angle, ) @@ -2963,8 +2994,8 @@ impl bevy::math::primitives::CircularSegment { fn from_radians( radius: f32, angle: f32, - ) -> Val { - let output: Val = bevy::math::primitives::CircularSegment::from_radians( + ) -> Val<::bevy_math::primitives::CircularSegment> { + let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::from_radians( radius, angle, ) @@ -2976,8 +3007,8 @@ impl bevy::math::primitives::CircularSegment { fn from_turns( radius: f32, fraction: f32, - ) -> Val { - let output: Val = bevy::math::primitives::CircularSegment::from_turns( + ) -> Val<::bevy_math::primitives::CircularSegment> { + let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::from_turns( radius, fraction, ) @@ -2985,22 +3016,22 @@ impl bevy::math::primitives::CircularSegment { output } /// Get the half-angle of the segment - fn half_angle(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::CircularSegment::half_angle(&_self) + fn half_angle(_self: Ref<::bevy_math::primitives::CircularSegment>) -> f32 { + let output: f32 = ::bevy_math::primitives::CircularSegment::half_angle(&_self) .into(); output } /// Get half the length of the segment's base, also known as its chord - fn half_chord_length(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::CircularSegment::half_chord_length( + fn half_chord_length(_self: Ref<::bevy_math::primitives::CircularSegment>) -> f32 { + let output: f32 = ::bevy_math::primitives::CircularSegment::half_chord_length( &_self, ) .into(); output } /// Create a new [`CircularSegment`] from a `radius`, and an `angle` - fn new(radius: f32, angle: f32) -> Val { - let output: Val = bevy::math::primitives::CircularSegment::new( + fn new(radius: f32, angle: f32) -> Val<::bevy_math::primitives::CircularSegment> { + let output: Val<::bevy_math::primitives::CircularSegment> = ::bevy_math::primitives::CircularSegment::new( radius, angle, ) @@ -3008,14 +3039,15 @@ impl bevy::math::primitives::CircularSegment { output } /// Get the radius of the segment - fn radius(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::CircularSegment::radius(&_self).into(); + fn radius(_self: Ref<::bevy_math::primitives::CircularSegment>) -> f32 { + let output: f32 = ::bevy_math::primitives::CircularSegment::radius(&_self) + .into(); output } /// Get the length of the sagitta of this segment, also known as its height /// See [`Arc2d::sagitta`] - fn sagitta(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::CircularSegment::sagitta(&_self) + fn sagitta(_self: Ref<::bevy_math::primitives::CircularSegment>) -> f32 { + let output: f32 = ::bevy_math::primitives::CircularSegment::sagitta(&_self) .into(); output } @@ -3026,11 +3058,11 @@ impl bevy::math::primitives::CircularSegment { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::Ellipse { +impl ::bevy_math::primitives::Ellipse { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::Ellipse>, + ) -> Val<::bevy_math::primitives::Ellipse> { + let output: Val<::bevy_math::primitives::Ellipse> = <::bevy_math::primitives::Ellipse as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -3039,32 +3071,32 @@ impl bevy::math::primitives::Ellipse { /// Returns the [eccentricity](https://en.wikipedia.org/wiki/Eccentricity_(mathematics)) of the ellipse. /// It can be thought of as a measure of how "stretched" or elongated the ellipse is. /// The value should be in the range [0, 1), where 0 represents a circle, and 1 represents a parabola. - fn eccentricity(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Ellipse::eccentricity(&_self).into(); + fn eccentricity(_self: Ref<::bevy_math::primitives::Ellipse>) -> f32 { + let output: f32 = ::bevy_math::primitives::Ellipse::eccentricity(&_self).into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::Ellipse>, + other: Ref<::bevy_math::primitives::Ellipse>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Get the focal length of the ellipse. This corresponds to the distance between one of the foci and the center of the ellipse. /// The focal length of an ellipse is related to its eccentricity by `eccentricity = focal_length / semi_major` - fn focal_length(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Ellipse::focal_length(&_self).into(); + fn focal_length(_self: Ref<::bevy_math::primitives::Ellipse>) -> f32 { + let output: f32 = ::bevy_math::primitives::Ellipse::focal_length(&_self).into(); output } /// Create a new `Ellipse` from a given full size. /// `size.x` is the diameter along the X axis, and `size.y` is the diameter along the Y axis. fn from_size( - size: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Ellipse::from_size( + size: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::primitives::Ellipse> { + let output: Val<::bevy_math::primitives::Ellipse> = ::bevy_math::primitives::Ellipse::from_size( size.into_inner(), ) .into(); @@ -3072,8 +3104,8 @@ impl bevy::math::primitives::Ellipse { } /// Create a new `Ellipse` from half of its width and height. /// This corresponds to the two perpendicular radii defining the ellipse. - fn new(half_width: f32, half_height: f32) -> Val { - let output: Val = bevy::math::primitives::Ellipse::new( + fn new(half_width: f32, half_height: f32) -> Val<::bevy_math::primitives::Ellipse> { + let output: Val<::bevy_math::primitives::Ellipse> = ::bevy_math::primitives::Ellipse::new( half_width, half_height, ) @@ -3081,13 +3113,13 @@ impl bevy::math::primitives::Ellipse { output } /// Returns the length of the semi-major axis. This corresponds to the longest radius of the ellipse. - fn semi_major(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Ellipse::semi_major(&_self).into(); + fn semi_major(_self: Ref<::bevy_math::primitives::Ellipse>) -> f32 { + let output: f32 = ::bevy_math::primitives::Ellipse::semi_major(&_self).into(); output } /// Returns the length of the semi-minor axis. This corresponds to the shortest radius of the ellipse. - fn semi_minor(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Ellipse::semi_minor(&_self).into(); + fn semi_minor(_self: Ref<::bevy_math::primitives::Ellipse>) -> f32 { + let output: f32 = ::bevy_math::primitives::Ellipse::semi_minor(&_self).into(); output } } @@ -3097,22 +3129,22 @@ impl bevy::math::primitives::Ellipse { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::Line2d { +impl ::bevy_math::primitives::Line2d { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::Line2d>, + ) -> Val<::bevy_math::primitives::Line2d> { + let output: Val<::bevy_math::primitives::Line2d> = <::bevy_math::primitives::Line2d as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::Line2d>, + other: Ref<::bevy_math::primitives::Line2d>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -3124,22 +3156,22 @@ impl bevy::math::primitives::Line2d { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::Plane2d { +impl ::bevy_math::primitives::Plane2d { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::Plane2d>, + ) -> Val<::bevy_math::primitives::Plane2d> { + let output: Val<::bevy_math::primitives::Plane2d> = <::bevy_math::primitives::Plane2d as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::Plane2d>, + other: Ref<::bevy_math::primitives::Plane2d>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -3148,9 +3180,9 @@ impl bevy::math::primitives::Plane2d { /// # Panics /// Panics if the given `normal` is zero (or very close to zero), or non-finite. fn new( - normal: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Plane2d::new( + normal: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::primitives::Plane2d> { + let output: Val<::bevy_math::primitives::Plane2d> = ::bevy_math::primitives::Plane2d::new( normal.into_inner(), ) .into(); @@ -3163,11 +3195,11 @@ impl bevy::math::primitives::Plane2d { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::Rectangle { +impl ::bevy_math::primitives::Rectangle { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::Rectangle>, + ) -> Val<::bevy_math::primitives::Rectangle> { + let output: Val<::bevy_math::primitives::Rectangle> = <::bevy_math::primitives::Rectangle as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -3177,10 +3209,10 @@ impl bevy::math::primitives::Rectangle { /// If the point is outside the rectangle, the returned point will be on the perimeter of the rectangle. /// Otherwise, it will be inside the rectangle and returned as is. fn closest_point( - _self: Ref, - point: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Rectangle::closest_point( + _self: Ref<::bevy_math::primitives::Rectangle>, + point: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Rectangle::closest_point( &_self, point.into_inner(), ) @@ -3188,21 +3220,21 @@ impl bevy::math::primitives::Rectangle { output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::Rectangle>, + other: Ref<::bevy_math::primitives::Rectangle>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Create a new `Rectangle` from two corner points fn from_corners( - point1: Val, - point2: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Rectangle::from_corners( + point1: Val<::bevy_math::prelude::Vec2>, + point2: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::primitives::Rectangle> { + let output: Val<::bevy_math::primitives::Rectangle> = ::bevy_math::primitives::Rectangle::from_corners( point1.into_inner(), point2.into_inner(), ) @@ -3211,8 +3243,8 @@ impl bevy::math::primitives::Rectangle { } /// Create a `Rectangle` from a single length. /// The resulting `Rectangle` will be the same size in every direction. - fn from_length(length: f32) -> Val { - let output: Val = bevy::math::primitives::Rectangle::from_length( + fn from_length(length: f32) -> Val<::bevy_math::primitives::Rectangle> { + let output: Val<::bevy_math::primitives::Rectangle> = ::bevy_math::primitives::Rectangle::from_length( length, ) .into(); @@ -3220,17 +3252,17 @@ impl bevy::math::primitives::Rectangle { } /// Create a new `Rectangle` from a given full size fn from_size( - size: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Rectangle::from_size( + size: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::primitives::Rectangle> { + let output: Val<::bevy_math::primitives::Rectangle> = ::bevy_math::primitives::Rectangle::from_size( size.into_inner(), ) .into(); output } /// Create a new `Rectangle` from a full width and height - fn new(width: f32, height: f32) -> Val { - let output: Val = bevy::math::primitives::Rectangle::new( + fn new(width: f32, height: f32) -> Val<::bevy_math::primitives::Rectangle> { + let output: Val<::bevy_math::primitives::Rectangle> = ::bevy_math::primitives::Rectangle::new( width, height, ) @@ -3239,9 +3271,9 @@ impl bevy::math::primitives::Rectangle { } /// Get the size of the rectangle fn size( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Rectangle::size( + _self: Ref<::bevy_math::primitives::Rectangle>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Rectangle::size( &_self, ) .into(); @@ -3254,29 +3286,29 @@ impl bevy::math::primitives::Rectangle { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::RegularPolygon { +impl ::bevy_math::primitives::RegularPolygon { /// Get the radius of the circumcircle on which all vertices /// of the regular polygon lie - fn circumradius(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::RegularPolygon::circumradius(&_self) + fn circumradius(_self: Ref<::bevy_math::primitives::RegularPolygon>) -> f32 { + let output: f32 = ::bevy_math::primitives::RegularPolygon::circumradius(&_self) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::RegularPolygon>, + ) -> Val<::bevy_math::primitives::RegularPolygon> { + let output: Val<::bevy_math::primitives::RegularPolygon> = <::bevy_math::primitives::RegularPolygon as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::RegularPolygon>, + other: Ref<::bevy_math::primitives::RegularPolygon>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -3285,9 +3317,9 @@ impl bevy::math::primitives::RegularPolygon { /// This is the angle formed by two adjacent sides with points /// within the angle being in the exterior of the polygon fn external_angle_degrees( - _self: Ref, + _self: Ref<::bevy_math::primitives::RegularPolygon>, ) -> f32 { - let output: f32 = bevy::math::primitives::RegularPolygon::external_angle_degrees( + let output: f32 = ::bevy_math::primitives::RegularPolygon::external_angle_degrees( &_self, ) .into(); @@ -3297,9 +3329,9 @@ impl bevy::math::primitives::RegularPolygon { /// This is the angle formed by two adjacent sides with points /// within the angle being in the exterior of the polygon fn external_angle_radians( - _self: Ref, + _self: Ref<::bevy_math::primitives::RegularPolygon>, ) -> f32 { - let output: f32 = bevy::math::primitives::RegularPolygon::external_angle_radians( + let output: f32 = ::bevy_math::primitives::RegularPolygon::external_angle_radians( &_self, ) .into(); @@ -3308,8 +3340,8 @@ impl bevy::math::primitives::RegularPolygon { /// Get the inradius or apothem of the regular polygon. /// This is the radius of the largest circle that can /// be drawn within the polygon - fn inradius(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::RegularPolygon::inradius(&_self) + fn inradius(_self: Ref<::bevy_math::primitives::RegularPolygon>) -> f32 { + let output: f32 = ::bevy_math::primitives::RegularPolygon::inradius(&_self) .into(); output } @@ -3317,9 +3349,9 @@ impl bevy::math::primitives::RegularPolygon { /// This is the angle formed by two adjacent sides with points /// within the angle being in the interior of the polygon fn internal_angle_degrees( - _self: Ref, + _self: Ref<::bevy_math::primitives::RegularPolygon>, ) -> f32 { - let output: f32 = bevy::math::primitives::RegularPolygon::internal_angle_degrees( + let output: f32 = ::bevy_math::primitives::RegularPolygon::internal_angle_degrees( &_self, ) .into(); @@ -3329,9 +3361,9 @@ impl bevy::math::primitives::RegularPolygon { /// This is the angle formed by two adjacent sides with points /// within the angle being in the interior of the polygon fn internal_angle_radians( - _self: Ref, + _self: Ref<::bevy_math::primitives::RegularPolygon>, ) -> f32 { - let output: f32 = bevy::math::primitives::RegularPolygon::internal_angle_radians( + let output: f32 = ::bevy_math::primitives::RegularPolygon::internal_angle_radians( &_self, ) .into(); @@ -3344,8 +3376,8 @@ impl bevy::math::primitives::RegularPolygon { fn new( circumradius: f32, sides: u32, - ) -> Val { - let output: Val = bevy::math::primitives::RegularPolygon::new( + ) -> Val<::bevy_math::primitives::RegularPolygon> { + let output: Val<::bevy_math::primitives::RegularPolygon> = ::bevy_math::primitives::RegularPolygon::new( circumradius, sides, ) @@ -3353,8 +3385,8 @@ impl bevy::math::primitives::RegularPolygon { output } /// Get the length of one side of the regular polygon - fn side_length(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::RegularPolygon::side_length(&_self) + fn side_length(_self: Ref<::bevy_math::primitives::RegularPolygon>) -> f32 { + let output: f32 = ::bevy_math::primitives::RegularPolygon::side_length(&_self) .into(); output } @@ -3365,17 +3397,17 @@ impl bevy::math::primitives::RegularPolygon { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::Rhombus { +impl ::bevy_math::primitives::Rhombus { /// Get the radius of the circumcircle on which all vertices /// of the rhombus lie - fn circumradius(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Rhombus::circumradius(&_self).into(); + fn circumradius(_self: Ref<::bevy_math::primitives::Rhombus>) -> f32 { + let output: f32 = ::bevy_math::primitives::Rhombus::circumradius(&_self).into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::Rhombus>, + ) -> Val<::bevy_math::primitives::Rhombus> { + let output: Val<::bevy_math::primitives::Rhombus> = <::bevy_math::primitives::Rhombus as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -3385,10 +3417,10 @@ impl bevy::math::primitives::Rhombus { /// If the point is outside the rhombus, the returned point will be on the perimeter of the rhombus. /// Otherwise, it will be inside the rhombus and returned as is. fn closest_point( - _self: Ref, - point: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Rhombus::closest_point( + _self: Ref<::bevy_math::primitives::Rhombus>, + point: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Rhombus::closest_point( &_self, point.into_inner(), ) @@ -3396,26 +3428,26 @@ impl bevy::math::primitives::Rhombus { output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::Rhombus>, + other: Ref<::bevy_math::primitives::Rhombus>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Create a new `Rhombus` from a given inradius with all inner angles equal. - fn from_inradius(inradius: f32) -> Val { - let output: Val = bevy::math::primitives::Rhombus::from_inradius( + fn from_inradius(inradius: f32) -> Val<::bevy_math::primitives::Rhombus> { + let output: Val<::bevy_math::primitives::Rhombus> = ::bevy_math::primitives::Rhombus::from_inradius( inradius, ) .into(); output } /// Create a new `Rhombus` from a side length with all inner angles equal. - fn from_side(side: f32) -> Val { - let output: Val = bevy::math::primitives::Rhombus::from_side( + fn from_side(side: f32) -> Val<::bevy_math::primitives::Rhombus> { + let output: Val<::bevy_math::primitives::Rhombus> = ::bevy_math::primitives::Rhombus::from_side( side, ) .into(); @@ -3423,16 +3455,16 @@ impl bevy::math::primitives::Rhombus { } /// Get the radius of the largest circle that can /// be drawn within the rhombus - fn inradius(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Rhombus::inradius(&_self).into(); + fn inradius(_self: Ref<::bevy_math::primitives::Rhombus>) -> f32 { + let output: f32 = ::bevy_math::primitives::Rhombus::inradius(&_self).into(); output } /// Create a new `Rhombus` from a vertical and horizontal diagonal sizes. fn new( horizontal_diagonal: f32, vertical_diagonal: f32, - ) -> Val { - let output: Val = bevy::math::primitives::Rhombus::new( + ) -> Val<::bevy_math::primitives::Rhombus> { + let output: Val<::bevy_math::primitives::Rhombus> = ::bevy_math::primitives::Rhombus::new( horizontal_diagonal, vertical_diagonal, ) @@ -3440,8 +3472,8 @@ impl bevy::math::primitives::Rhombus { output } /// Get the length of each side of the rhombus - fn side(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Rhombus::side(&_self).into(); + fn side(_self: Ref<::bevy_math::primitives::Rhombus>) -> f32 { + let output: f32 = ::bevy_math::primitives::Rhombus::side(&_self).into(); output } } @@ -3451,12 +3483,12 @@ impl bevy::math::primitives::Rhombus { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::Segment2d { +impl ::bevy_math::primitives::Segment2d { /// Compute the midpoint between the two endpoints of the line segment. fn center( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Segment2d::center( + _self: Ref<::bevy_math::primitives::Segment2d>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Segment2d::center( &_self, ) .into(); @@ -3464,18 +3496,18 @@ impl bevy::math::primitives::Segment2d { } /// Compute the segment with its center at the origin, keeping the same direction and length. fn centered( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Segment2d::centered( + _self: Ref<::bevy_math::primitives::Segment2d>, + ) -> Val<::bevy_math::primitives::Segment2d> { + let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::centered( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::Segment2d>, + ) -> Val<::bevy_math::primitives::Segment2d> { + let output: Val<::bevy_math::primitives::Segment2d> = <::bevy_math::primitives::Segment2d as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -3486,20 +3518,20 @@ impl bevy::math::primitives::Segment2d { /// # Panics /// Panics if a valid direction could not be computed, for example when the endpoints are coincident, NaN, or infinite. fn direction( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Segment2d::direction( + _self: Ref<::bevy_math::primitives::Segment2d>, + ) -> Val<::bevy_math::prelude::Dir2> { + let output: Val<::bevy_math::prelude::Dir2> = ::bevy_math::primitives::Segment2d::direction( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::Segment2d>, + other: Ref<::bevy_math::primitives::Segment2d>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -3507,10 +3539,10 @@ impl bevy::math::primitives::Segment2d { /// Create a new `Segment2d` centered at the origin with the given direction and length. /// The endpoints will be at `-direction * length / 2.0` and `direction * length / 2.0`. fn from_direction_and_length( - direction: Val, + direction: Val<::bevy_math::prelude::Dir2>, length: f32, - ) -> Val { - let output: Val = bevy::math::primitives::Segment2d::from_direction_and_length( + ) -> Val<::bevy_math::primitives::Segment2d> { + let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::from_direction_and_length( direction.into_inner(), length, ) @@ -3521,10 +3553,10 @@ impl bevy::math::primitives::Segment2d { /// going in the direction of the ray for the given `length`. /// The endpoints will be at `ray.origin` and `ray.origin + length * ray.direction`. fn from_ray_and_length( - ray: Val, + ray: Val<::bevy_math::Ray2d>, length: f32, - ) -> Val { - let output: Val = bevy::math::primitives::Segment2d::from_ray_and_length( + ) -> Val<::bevy_math::primitives::Segment2d> { + let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::from_ray_and_length( ray.into_inner(), length, ) @@ -3535,9 +3567,9 @@ impl bevy::math::primitives::Segment2d { /// the direction and length of the line segment. /// The endpoints will be at `-scaled_direction / 2.0` and `scaled_direction / 2.0`. fn from_scaled_direction( - scaled_direction: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Segment2d::from_scaled_direction( + scaled_direction: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::primitives::Segment2d> { + let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::from_scaled_direction( scaled_direction.into_inner(), ) .into(); @@ -3548,31 +3580,31 @@ impl bevy::math::primitives::Segment2d { /// # Panics /// Panics if a valid normal could not be computed, for example when the endpoints are coincident, NaN, or infinite. fn left_normal( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Segment2d::left_normal( + _self: Ref<::bevy_math::primitives::Segment2d>, + ) -> Val<::bevy_math::prelude::Dir2> { + let output: Val<::bevy_math::prelude::Dir2> = ::bevy_math::primitives::Segment2d::left_normal( &_self, ) .into(); output } /// Compute the length of the line segment. - fn length(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Segment2d::length(&_self).into(); + fn length(_self: Ref<::bevy_math::primitives::Segment2d>) -> f32 { + let output: f32 = ::bevy_math::primitives::Segment2d::length(&_self).into(); output } /// Compute the squared length of the line segment. - fn length_squared(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Segment2d::length_squared(&_self) + fn length_squared(_self: Ref<::bevy_math::primitives::Segment2d>) -> f32 { + let output: f32 = ::bevy_math::primitives::Segment2d::length_squared(&_self) .into(); output } /// Create a new `Segment2d` from its endpoints. fn new( - point1: Val, - point2: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Segment2d::new( + point1: Val<::bevy_math::prelude::Vec2>, + point2: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::primitives::Segment2d> { + let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::new( point1.into_inner(), point2.into_inner(), ) @@ -3581,9 +3613,9 @@ impl bevy::math::primitives::Segment2d { } /// Get the position of the first endpoint of the line segment. fn point1( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Segment2d::point1( + _self: Ref<::bevy_math::primitives::Segment2d>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Segment2d::point1( &_self, ) .into(); @@ -3591,9 +3623,9 @@ impl bevy::math::primitives::Segment2d { } /// Get the position of the second endpoint of the line segment. fn point2( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Segment2d::point2( + _self: Ref<::bevy_math::primitives::Segment2d>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Segment2d::point2( &_self, ) .into(); @@ -3601,10 +3633,10 @@ impl bevy::math::primitives::Segment2d { } /// Compute the segment with a new length, keeping the same direction and center. fn resized( - _self: Ref, + _self: Ref<::bevy_math::primitives::Segment2d>, length: f32, - ) -> Val { - let output: Val = bevy::math::primitives::Segment2d::resized( + ) -> Val<::bevy_math::primitives::Segment2d> { + let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::resized( &_self, length, ) @@ -3612,15 +3644,15 @@ impl bevy::math::primitives::Segment2d { output } /// Reverses the direction of the line segment by swapping the endpoints. - fn reverse(mut _self: Mut) -> () { - let output: () = bevy::math::primitives::Segment2d::reverse(&mut _self).into(); + fn reverse(mut _self: Mut<::bevy_math::primitives::Segment2d>) -> () { + let output: () = ::bevy_math::primitives::Segment2d::reverse(&mut _self).into(); output } /// Returns the line segment with its direction reversed by swapping the endpoints. fn reversed( - _self: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Segment2d::reversed( + _self: Val<::bevy_math::primitives::Segment2d>, + ) -> Val<::bevy_math::primitives::Segment2d> { + let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::reversed( _self.into_inner(), ) .into(); @@ -3631,9 +3663,9 @@ impl bevy::math::primitives::Segment2d { /// # Panics /// Panics if a valid normal could not be computed, for example when the endpoints are coincident, NaN, or infinite. fn right_normal( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Segment2d::right_normal( + _self: Ref<::bevy_math::primitives::Segment2d>, + ) -> Val<::bevy_math::prelude::Dir2> { + let output: Val<::bevy_math::prelude::Dir2> = ::bevy_math::primitives::Segment2d::right_normal( &_self, ) .into(); @@ -3641,10 +3673,10 @@ impl bevy::math::primitives::Segment2d { } /// Compute the segment rotated around the origin by the given rotation. fn rotated( - _self: Ref, - rotation: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Segment2d::rotated( + _self: Ref<::bevy_math::primitives::Segment2d>, + rotation: Val<::bevy_math::Rot2>, + ) -> Val<::bevy_math::primitives::Segment2d> { + let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::rotated( &_self, rotation.into_inner(), ) @@ -3653,11 +3685,11 @@ impl bevy::math::primitives::Segment2d { } /// Compute the segment rotated around the given point by the given rotation. fn rotated_around( - _self: Ref, - rotation: Val, - point: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Segment2d::rotated_around( + _self: Ref<::bevy_math::primitives::Segment2d>, + rotation: Val<::bevy_math::Rot2>, + point: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::primitives::Segment2d> { + let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::rotated_around( &_self, rotation.into_inner(), point.into_inner(), @@ -3667,10 +3699,10 @@ impl bevy::math::primitives::Segment2d { } /// Compute the segment rotated around its own center. fn rotated_around_center( - _self: Ref, - rotation: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Segment2d::rotated_around_center( + _self: Ref<::bevy_math::primitives::Segment2d>, + rotation: Val<::bevy_math::Rot2>, + ) -> Val<::bevy_math::primitives::Segment2d> { + let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::rotated_around_center( &_self, rotation.into_inner(), ) @@ -3679,9 +3711,9 @@ impl bevy::math::primitives::Segment2d { } /// Compute the vector from the first endpoint to the second endpoint. fn scaled_direction( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Segment2d::scaled_direction( + _self: Ref<::bevy_math::primitives::Segment2d>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Segment2d::scaled_direction( &_self, ) .into(); @@ -3690,9 +3722,9 @@ impl bevy::math::primitives::Segment2d { /// Compute the non-normalized counterclockwise normal on the left-hand side of the line segment. /// The length of the normal is the distance between the endpoints. fn scaled_left_normal( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Segment2d::scaled_left_normal( + _self: Ref<::bevy_math::primitives::Segment2d>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Segment2d::scaled_left_normal( &_self, ) .into(); @@ -3701,9 +3733,9 @@ impl bevy::math::primitives::Segment2d { /// Compute the non-normalized clockwise normal on the right-hand side of the line segment. /// The length of the normal is the distance between the endpoints. fn scaled_right_normal( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Segment2d::scaled_right_normal( + _self: Ref<::bevy_math::primitives::Segment2d>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::primitives::Segment2d::scaled_right_normal( &_self, ) .into(); @@ -3711,10 +3743,10 @@ impl bevy::math::primitives::Segment2d { } /// Compute the segment translated by the given vector. fn translated( - _self: Ref, - translation: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Segment2d::translated( + _self: Ref<::bevy_math::primitives::Segment2d>, + translation: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::primitives::Segment2d> { + let output: Val<::bevy_math::primitives::Segment2d> = ::bevy_math::primitives::Segment2d::translated( &_self, translation.into_inner(), ) @@ -3728,51 +3760,51 @@ impl bevy::math::primitives::Segment2d { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::Triangle2d { +impl ::bevy_math::primitives::Triangle2d { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::Triangle2d>, + ) -> Val<::bevy_math::primitives::Triangle2d> { + let output: Val<::bevy_math::primitives::Triangle2d> = <::bevy_math::primitives::Triangle2d as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::Triangle2d>, + other: Ref<::bevy_math::primitives::Triangle2d>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Checks if the triangle is acute, meaning all angles are less than 90 degrees - fn is_acute(_self: Ref) -> bool { - let output: bool = bevy::math::primitives::Triangle2d::is_acute(&_self).into(); + fn is_acute(_self: Ref<::bevy_math::primitives::Triangle2d>) -> bool { + let output: bool = ::bevy_math::primitives::Triangle2d::is_acute(&_self).into(); output } /// Checks if the triangle is degenerate, meaning it has zero area. /// A triangle is degenerate if the cross product of the vectors `ab` and `ac` has a length less than `10e-7`. /// This indicates that the three vertices are collinear or nearly collinear. - fn is_degenerate(_self: Ref) -> bool { - let output: bool = bevy::math::primitives::Triangle2d::is_degenerate(&_self) + fn is_degenerate(_self: Ref<::bevy_math::primitives::Triangle2d>) -> bool { + let output: bool = ::bevy_math::primitives::Triangle2d::is_degenerate(&_self) .into(); output } /// Checks if the triangle is obtuse, meaning one angle is greater than 90 degrees - fn is_obtuse(_self: Ref) -> bool { - let output: bool = bevy::math::primitives::Triangle2d::is_obtuse(&_self).into(); + fn is_obtuse(_self: Ref<::bevy_math::primitives::Triangle2d>) -> bool { + let output: bool = ::bevy_math::primitives::Triangle2d::is_obtuse(&_self).into(); output } /// Create a new `Triangle2d` from points `a`, `b`, and `c` fn new( - a: Val, - b: Val, - c: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Triangle2d::new( + a: Val<::bevy_math::prelude::Vec2>, + b: Val<::bevy_math::prelude::Vec2>, + c: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::primitives::Triangle2d> { + let output: Val<::bevy_math::primitives::Triangle2d> = ::bevy_math::primitives::Triangle2d::new( a.into_inner(), b.into_inner(), c.into_inner(), @@ -3782,15 +3814,15 @@ impl bevy::math::primitives::Triangle2d { } /// Reverse the [`WindingOrder`] of the triangle /// by swapping the first and last vertices. - fn reverse(mut _self: Mut) -> () { - let output: () = bevy::math::primitives::Triangle2d::reverse(&mut _self).into(); + fn reverse(mut _self: Mut<::bevy_math::primitives::Triangle2d>) -> () { + let output: () = ::bevy_math::primitives::Triangle2d::reverse(&mut _self).into(); output } /// This triangle but reversed. fn reversed( - _self: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Triangle2d::reversed( + _self: Val<::bevy_math::primitives::Triangle2d>, + ) -> Val<::bevy_math::primitives::Triangle2d> { + let output: Val<::bevy_math::primitives::Triangle2d> = ::bevy_math::primitives::Triangle2d::reversed( _self.into_inner(), ) .into(); @@ -3803,32 +3835,32 @@ impl bevy::math::primitives::Triangle2d { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::bounding::Aabb3d { +impl ::bevy_math::bounding::Aabb3d { /// Computes the smallest [`BoundingSphere`] containing this [`Aabb3d`]. fn bounding_sphere( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::bounding::Aabb3d::bounding_sphere( + _self: Ref<::bevy_math::bounding::Aabb3d>, + ) -> Val<::bevy_math::bounding::BoundingSphere> { + let output: Val<::bevy_math::bounding::BoundingSphere> = ::bevy_math::bounding::Aabb3d::bounding_sphere( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::bounding::Aabb3d>, + ) -> Val<::bevy_math::bounding::Aabb3d> { + let output: Val<::bevy_math::bounding::Aabb3d> = <::bevy_math::bounding::Aabb3d as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::bounding::Aabb3d>, + other: Ref<::bevy_math::bounding::Aabb3d>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -3840,39 +3872,39 @@ impl bevy::math::bounding::Aabb3d { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::bounding::BoundingSphere { +impl ::bevy_math::bounding::BoundingSphere { /// Computes the smallest [`Aabb3d`] containing this [`BoundingSphere`]. fn aabb_3d( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::bounding::BoundingSphere::aabb_3d( + _self: Ref<::bevy_math::bounding::BoundingSphere>, + ) -> Val<::bevy_math::bounding::Aabb3d> { + let output: Val<::bevy_math::bounding::Aabb3d> = ::bevy_math::bounding::BoundingSphere::aabb_3d( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::bounding::BoundingSphere>, + ) -> Val<::bevy_math::bounding::BoundingSphere> { + let output: Val<::bevy_math::bounding::BoundingSphere> = <::bevy_math::bounding::BoundingSphere as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::bounding::BoundingSphere>, + other: Ref<::bevy_math::bounding::BoundingSphere>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Get the radius of the bounding sphere - fn radius(_self: Ref) -> f32 { - let output: f32 = bevy::math::bounding::BoundingSphere::radius(&_self).into(); + fn radius(_self: Ref<::bevy_math::bounding::BoundingSphere>) -> f32 { + let output: f32 = ::bevy_math::bounding::BoundingSphere::radius(&_self).into(); output } } @@ -3882,11 +3914,11 @@ impl bevy::math::bounding::BoundingSphere { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::Sphere { +impl ::bevy_math::primitives::Sphere { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::Sphere>, + ) -> Val<::bevy_math::primitives::Sphere> { + let output: Val<::bevy_math::primitives::Sphere> = <::bevy_math::primitives::Sphere as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -3896,10 +3928,10 @@ impl bevy::math::primitives::Sphere { /// If the point is outside the sphere, the returned point will be on the surface of the sphere. /// Otherwise, it will be inside the sphere and returned as is. fn closest_point( - _self: Ref, - point: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Sphere::closest_point( + _self: Ref<::bevy_math::primitives::Sphere>, + point: Val<::bevy_math::prelude::Vec3>, + ) -> Val<::bevy_math::prelude::Vec3> { + let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::primitives::Sphere::closest_point( &_self, point.into_inner(), ) @@ -3907,23 +3939,23 @@ impl bevy::math::primitives::Sphere { output } /// Get the diameter of the sphere - fn diameter(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Sphere::diameter(&_self).into(); + fn diameter(_self: Ref<::bevy_math::primitives::Sphere>) -> f32 { + let output: f32 = ::bevy_math::primitives::Sphere::diameter(&_self).into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::Sphere>, + other: Ref<::bevy_math::primitives::Sphere>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Create a new [`Sphere`] from a `radius` - fn new(radius: f32) -> Val { - let output: Val = bevy::math::primitives::Sphere::new( + fn new(radius: f32) -> Val<::bevy_math::primitives::Sphere> { + let output: Val<::bevy_math::primitives::Sphere> = ::bevy_math::primitives::Sphere::new( radius, ) .into(); @@ -3936,11 +3968,11 @@ impl bevy::math::primitives::Sphere { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::Cuboid { +impl ::bevy_math::primitives::Cuboid { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::Cuboid>, + ) -> Val<::bevy_math::primitives::Cuboid> { + let output: Val<::bevy_math::primitives::Cuboid> = <::bevy_math::primitives::Cuboid as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -3950,10 +3982,10 @@ impl bevy::math::primitives::Cuboid { /// If the point is outside the cuboid, the returned point will be on the surface of the cuboid. /// Otherwise, it will be inside the cuboid and returned as is. fn closest_point( - _self: Ref, - point: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Cuboid::closest_point( + _self: Ref<::bevy_math::primitives::Cuboid>, + point: Val<::bevy_math::prelude::Vec3>, + ) -> Val<::bevy_math::prelude::Vec3> { + let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::primitives::Cuboid::closest_point( &_self, point.into_inner(), ) @@ -3961,21 +3993,21 @@ impl bevy::math::primitives::Cuboid { output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::Cuboid>, + other: Ref<::bevy_math::primitives::Cuboid>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Create a new `Cuboid` from two corner points fn from_corners( - point1: Val, - point2: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Cuboid::from_corners( + point1: Val<::bevy_math::prelude::Vec3>, + point2: Val<::bevy_math::prelude::Vec3>, + ) -> Val<::bevy_math::primitives::Cuboid> { + let output: Val<::bevy_math::primitives::Cuboid> = ::bevy_math::primitives::Cuboid::from_corners( point1.into_inner(), point2.into_inner(), ) @@ -3984,8 +4016,8 @@ impl bevy::math::primitives::Cuboid { } /// Create a `Cuboid` from a single length. /// The resulting `Cuboid` will be the same size in every direction. - fn from_length(length: f32) -> Val { - let output: Val = bevy::math::primitives::Cuboid::from_length( + fn from_length(length: f32) -> Val<::bevy_math::primitives::Cuboid> { + let output: Val<::bevy_math::primitives::Cuboid> = ::bevy_math::primitives::Cuboid::from_length( length, ) .into(); @@ -3993,9 +4025,9 @@ impl bevy::math::primitives::Cuboid { } /// Create a new `Cuboid` from a given full size fn from_size( - size: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Cuboid::from_size( + size: Val<::bevy_math::prelude::Vec3>, + ) -> Val<::bevy_math::primitives::Cuboid> { + let output: Val<::bevy_math::primitives::Cuboid> = ::bevy_math::primitives::Cuboid::from_size( size.into_inner(), ) .into(); @@ -4006,8 +4038,8 @@ impl bevy::math::primitives::Cuboid { x_length: f32, y_length: f32, z_length: f32, - ) -> Val { - let output: Val = bevy::math::primitives::Cuboid::new( + ) -> Val<::bevy_math::primitives::Cuboid> { + let output: Val<::bevy_math::primitives::Cuboid> = ::bevy_math::primitives::Cuboid::new( x_length, y_length, z_length, @@ -4017,9 +4049,9 @@ impl bevy::math::primitives::Cuboid { } /// Get the size of the cuboid fn size( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Cuboid::size( + _self: Ref<::bevy_math::primitives::Cuboid>, + ) -> Val<::bevy_math::prelude::Vec3> { + let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::primitives::Cuboid::size( &_self, ) .into(); @@ -4032,50 +4064,50 @@ impl bevy::math::primitives::Cuboid { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::Cylinder { +impl ::bevy_math::primitives::Cylinder { /// Get the base of the cylinder as a [`Circle`] fn base( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Cylinder::base( + _self: Ref<::bevy_math::primitives::Cylinder>, + ) -> Val<::bevy_math::primitives::Circle> { + let output: Val<::bevy_math::primitives::Circle> = ::bevy_math::primitives::Cylinder::base( &_self, ) .into(); output } /// Get the surface area of one base of the cylinder - fn base_area(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Cylinder::base_area(&_self).into(); + fn base_area(_self: Ref<::bevy_math::primitives::Cylinder>) -> f32 { + let output: f32 = ::bevy_math::primitives::Cylinder::base_area(&_self).into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::Cylinder>, + ) -> Val<::bevy_math::primitives::Cylinder> { + let output: Val<::bevy_math::primitives::Cylinder> = <::bevy_math::primitives::Cylinder as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::Cylinder>, + other: Ref<::bevy_math::primitives::Cylinder>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Get the surface area of the side of the cylinder, /// also known as the lateral area - fn lateral_area(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Cylinder::lateral_area(&_self).into(); + fn lateral_area(_self: Ref<::bevy_math::primitives::Cylinder>) -> f32 { + let output: f32 = ::bevy_math::primitives::Cylinder::lateral_area(&_self).into(); output } /// Create a new `Cylinder` from a radius and full height - fn new(radius: f32, height: f32) -> Val { - let output: Val = bevy::math::primitives::Cylinder::new( + fn new(radius: f32, height: f32) -> Val<::bevy_math::primitives::Cylinder> { + let output: Val<::bevy_math::primitives::Cylinder> = ::bevy_math::primitives::Cylinder::new( radius, height, ) @@ -4089,29 +4121,29 @@ impl bevy::math::primitives::Cylinder { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::Capsule3d { +impl ::bevy_math::primitives::Capsule3d { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::Capsule3d>, + ) -> Val<::bevy_math::primitives::Capsule3d> { + let output: Val<::bevy_math::primitives::Capsule3d> = <::bevy_math::primitives::Capsule3d as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::Capsule3d>, + other: Ref<::bevy_math::primitives::Capsule3d>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Create a new `Capsule3d` from a radius and length - fn new(radius: f32, length: f32) -> Val { - let output: Val = bevy::math::primitives::Capsule3d::new( + fn new(radius: f32, length: f32) -> Val<::bevy_math::primitives::Capsule3d> { + let output: Val<::bevy_math::primitives::Capsule3d> = ::bevy_math::primitives::Capsule3d::new( radius, length, ) @@ -4121,9 +4153,9 @@ impl bevy::math::primitives::Capsule3d { /// Get the part connecting the hemispherical ends /// of the capsule as a [`Cylinder`] fn to_cylinder( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Capsule3d::to_cylinder( + _self: Ref<::bevy_math::primitives::Capsule3d>, + ) -> Val<::bevy_math::primitives::Cylinder> { + let output: Val<::bevy_math::primitives::Cylinder> = ::bevy_math::primitives::Capsule3d::to_cylinder( &_self, ) .into(); @@ -4136,50 +4168,50 @@ impl bevy::math::primitives::Capsule3d { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::Cone { +impl ::bevy_math::primitives::Cone { /// Get the base of the cone as a [`Circle`] fn base( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Cone::base( + _self: Ref<::bevy_math::primitives::Cone>, + ) -> Val<::bevy_math::primitives::Circle> { + let output: Val<::bevy_math::primitives::Circle> = ::bevy_math::primitives::Cone::base( &_self, ) .into(); output } /// Get the surface area of the base of the cone - fn base_area(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Cone::base_area(&_self).into(); + fn base_area(_self: Ref<::bevy_math::primitives::Cone>) -> f32 { + let output: f32 = ::bevy_math::primitives::Cone::base_area(&_self).into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::Cone>, + ) -> Val<::bevy_math::primitives::Cone> { + let output: Val<::bevy_math::primitives::Cone> = <::bevy_math::primitives::Cone as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::Cone>, + other: Ref<::bevy_math::primitives::Cone>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Get the surface area of the side of the cone, /// also known as the lateral area - fn lateral_area(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Cone::lateral_area(&_self).into(); + fn lateral_area(_self: Ref<::bevy_math::primitives::Cone>) -> f32 { + let output: f32 = ::bevy_math::primitives::Cone::lateral_area(&_self).into(); output } /// Create a new [`Cone`] from a radius and height. - fn new(radius: f32, height: f32) -> Val { - let output: Val = bevy::math::primitives::Cone::new( + fn new(radius: f32, height: f32) -> Val<::bevy_math::primitives::Cone> { + let output: Val<::bevy_math::primitives::Cone> = ::bevy_math::primitives::Cone::new( radius, height, ) @@ -4188,8 +4220,8 @@ impl bevy::math::primitives::Cone { } /// Get the slant height of the cone, the length of the line segment /// connecting a point on the base to the apex - fn slant_height(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Cone::slant_height(&_self).into(); + fn slant_height(_self: Ref<::bevy_math::primitives::Cone>) -> f32 { + let output: f32 = ::bevy_math::primitives::Cone::slant_height(&_self).into(); output } } @@ -4199,22 +4231,22 @@ impl bevy::math::primitives::Cone { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::ConicalFrustum { +impl ::bevy_math::primitives::ConicalFrustum { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::ConicalFrustum>, + ) -> Val<::bevy_math::primitives::ConicalFrustum> { + let output: Val<::bevy_math::primitives::ConicalFrustum> = <::bevy_math::primitives::ConicalFrustum as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::ConicalFrustum>, + other: Ref<::bevy_math::primitives::ConicalFrustum>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -4226,22 +4258,22 @@ impl bevy::math::primitives::ConicalFrustum { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::InfinitePlane3d { +impl ::bevy_math::primitives::InfinitePlane3d { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::InfinitePlane3d>, + ) -> Val<::bevy_math::primitives::InfinitePlane3d> { + let output: Val<::bevy_math::primitives::InfinitePlane3d> = <::bevy_math::primitives::InfinitePlane3d as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::InfinitePlane3d>, + other: Ref<::bevy_math::primitives::InfinitePlane3d>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -4265,10 +4297,10 @@ impl bevy::math::primitives::InfinitePlane3d { /// [congruence]: https://en.wikipedia.org/wiki/Congruence_(geometry) /// [`isometries_xy`]: `InfinitePlane3d::isometries_xy` fn isometry_from_xy( - _self: Ref, - origin: Val, - ) -> Val { - let output: Val = bevy::math::primitives::InfinitePlane3d::isometry_from_xy( + _self: Ref<::bevy_math::primitives::InfinitePlane3d>, + origin: Val<::bevy_math::prelude::Vec3>, + ) -> Val<::bevy_math::Isometry3d> { + let output: Val<::bevy_math::Isometry3d> = ::bevy_math::primitives::InfinitePlane3d::isometry_from_xy( &_self, origin.into_inner(), ) @@ -4294,10 +4326,10 @@ impl bevy::math::primitives::InfinitePlane3d { /// [congruence]: https://en.wikipedia.org/wiki/Congruence_(geometry) /// [`isometries_xy`]: `InfinitePlane3d::isometries_xy` fn isometry_into_xy( - _self: Ref, - origin: Val, - ) -> Val { - let output: Val = bevy::math::primitives::InfinitePlane3d::isometry_into_xy( + _self: Ref<::bevy_math::primitives::InfinitePlane3d>, + origin: Val<::bevy_math::prelude::Vec3>, + ) -> Val<::bevy_math::Isometry3d> { + let output: Val<::bevy_math::Isometry3d> = ::bevy_math::primitives::InfinitePlane3d::isometry_into_xy( &_self, origin.into_inner(), ) @@ -4311,22 +4343,22 @@ impl bevy::math::primitives::InfinitePlane3d { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::Line3d { +impl ::bevy_math::primitives::Line3d { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::Line3d>, + ) -> Val<::bevy_math::primitives::Line3d> { + let output: Val<::bevy_math::primitives::Line3d> = <::bevy_math::primitives::Line3d as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::Line3d>, + other: Ref<::bevy_math::primitives::Line3d>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -4338,12 +4370,12 @@ impl bevy::math::primitives::Line3d { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::Segment3d { +impl ::bevy_math::primitives::Segment3d { /// Compute the midpoint between the two endpoints of the line segment. fn center( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Segment3d::center( + _self: Ref<::bevy_math::primitives::Segment3d>, + ) -> Val<::bevy_math::prelude::Vec3> { + let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::primitives::Segment3d::center( &_self, ) .into(); @@ -4351,18 +4383,18 @@ impl bevy::math::primitives::Segment3d { } /// Compute the segment with its center at the origin, keeping the same direction and length. fn centered( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Segment3d::centered( + _self: Ref<::bevy_math::primitives::Segment3d>, + ) -> Val<::bevy_math::primitives::Segment3d> { + let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::centered( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::Segment3d>, + ) -> Val<::bevy_math::primitives::Segment3d> { + let output: Val<::bevy_math::primitives::Segment3d> = <::bevy_math::primitives::Segment3d as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -4373,20 +4405,20 @@ impl bevy::math::primitives::Segment3d { /// # Panics /// Panics if a valid direction could not be computed, for example when the endpoints are coincident, NaN, or infinite. fn direction( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Segment3d::direction( + _self: Ref<::bevy_math::primitives::Segment3d>, + ) -> Val<::bevy_math::prelude::Dir3> { + let output: Val<::bevy_math::prelude::Dir3> = ::bevy_math::primitives::Segment3d::direction( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::Segment3d>, + other: Ref<::bevy_math::primitives::Segment3d>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -4394,10 +4426,10 @@ impl bevy::math::primitives::Segment3d { /// Create a new `Segment3d` centered at the origin with the given direction and length. /// The endpoints will be at `-direction * length / 2.0` and `direction * length / 2.0`. fn from_direction_and_length( - direction: Val, + direction: Val<::bevy_math::prelude::Dir3>, length: f32, - ) -> Val { - let output: Val = bevy::math::primitives::Segment3d::from_direction_and_length( + ) -> Val<::bevy_math::primitives::Segment3d> { + let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::from_direction_and_length( direction.into_inner(), length, ) @@ -4408,10 +4440,10 @@ impl bevy::math::primitives::Segment3d { /// going in the direction of the ray for the given `length`. /// The endpoints will be at `ray.origin` and `ray.origin + length * ray.direction`. fn from_ray_and_length( - ray: Val, + ray: Val<::bevy_math::Ray3d>, length: f32, - ) -> Val { - let output: Val = bevy::math::primitives::Segment3d::from_ray_and_length( + ) -> Val<::bevy_math::primitives::Segment3d> { + let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::from_ray_and_length( ray.into_inner(), length, ) @@ -4422,31 +4454,31 @@ impl bevy::math::primitives::Segment3d { /// the direction and length of the line segment. /// The endpoints will be at `-scaled_direction / 2.0` and `scaled_direction / 2.0`. fn from_scaled_direction( - scaled_direction: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Segment3d::from_scaled_direction( + scaled_direction: Val<::bevy_math::prelude::Vec3>, + ) -> Val<::bevy_math::primitives::Segment3d> { + let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::from_scaled_direction( scaled_direction.into_inner(), ) .into(); output } /// Compute the length of the line segment. - fn length(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Segment3d::length(&_self).into(); + fn length(_self: Ref<::bevy_math::primitives::Segment3d>) -> f32 { + let output: f32 = ::bevy_math::primitives::Segment3d::length(&_self).into(); output } /// Compute the squared length of the line segment. - fn length_squared(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Segment3d::length_squared(&_self) + fn length_squared(_self: Ref<::bevy_math::primitives::Segment3d>) -> f32 { + let output: f32 = ::bevy_math::primitives::Segment3d::length_squared(&_self) .into(); output } /// Create a new `Segment3d` from its endpoints. fn new( - point1: Val, - point2: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Segment3d::new( + point1: Val<::bevy_math::prelude::Vec3>, + point2: Val<::bevy_math::prelude::Vec3>, + ) -> Val<::bevy_math::primitives::Segment3d> { + let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::new( point1.into_inner(), point2.into_inner(), ) @@ -4455,9 +4487,9 @@ impl bevy::math::primitives::Segment3d { } /// Get the position of the first endpoint of the line segment. fn point1( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Segment3d::point1( + _self: Ref<::bevy_math::primitives::Segment3d>, + ) -> Val<::bevy_math::prelude::Vec3> { + let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::primitives::Segment3d::point1( &_self, ) .into(); @@ -4465,9 +4497,9 @@ impl bevy::math::primitives::Segment3d { } /// Get the position of the second endpoint of the line segment. fn point2( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Segment3d::point2( + _self: Ref<::bevy_math::primitives::Segment3d>, + ) -> Val<::bevy_math::prelude::Vec3> { + let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::primitives::Segment3d::point2( &_self, ) .into(); @@ -4475,10 +4507,10 @@ impl bevy::math::primitives::Segment3d { } /// Compute the segment with a new length, keeping the same direction and center. fn resized( - _self: Ref, + _self: Ref<::bevy_math::primitives::Segment3d>, length: f32, - ) -> Val { - let output: Val = bevy::math::primitives::Segment3d::resized( + ) -> Val<::bevy_math::primitives::Segment3d> { + let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::resized( &_self, length, ) @@ -4486,15 +4518,15 @@ impl bevy::math::primitives::Segment3d { output } /// Reverses the direction of the line segment by swapping the endpoints. - fn reverse(mut _self: Mut) -> () { - let output: () = bevy::math::primitives::Segment3d::reverse(&mut _self).into(); + fn reverse(mut _self: Mut<::bevy_math::primitives::Segment3d>) -> () { + let output: () = ::bevy_math::primitives::Segment3d::reverse(&mut _self).into(); output } /// Returns the line segment with its direction reversed by swapping the endpoints. fn reversed( - _self: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Segment3d::reversed( + _self: Val<::bevy_math::primitives::Segment3d>, + ) -> Val<::bevy_math::primitives::Segment3d> { + let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::reversed( _self.into_inner(), ) .into(); @@ -4502,10 +4534,10 @@ impl bevy::math::primitives::Segment3d { } /// Compute the segment rotated around the origin by the given rotation. fn rotated( - _self: Ref, - rotation: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Segment3d::rotated( + _self: Ref<::bevy_math::primitives::Segment3d>, + rotation: Val<::bevy_math::prelude::Quat>, + ) -> Val<::bevy_math::primitives::Segment3d> { + let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::rotated( &_self, rotation.into_inner(), ) @@ -4514,11 +4546,11 @@ impl bevy::math::primitives::Segment3d { } /// Compute the segment rotated around the given point by the given rotation. fn rotated_around( - _self: Ref, - rotation: Val, - point: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Segment3d::rotated_around( + _self: Ref<::bevy_math::primitives::Segment3d>, + rotation: Val<::bevy_math::prelude::Quat>, + point: Val<::bevy_math::prelude::Vec3>, + ) -> Val<::bevy_math::primitives::Segment3d> { + let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::rotated_around( &_self, rotation.into_inner(), point.into_inner(), @@ -4528,10 +4560,10 @@ impl bevy::math::primitives::Segment3d { } /// Compute the segment rotated around its own center. fn rotated_around_center( - _self: Ref, - rotation: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Segment3d::rotated_around_center( + _self: Ref<::bevy_math::primitives::Segment3d>, + rotation: Val<::bevy_math::prelude::Quat>, + ) -> Val<::bevy_math::primitives::Segment3d> { + let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::rotated_around_center( &_self, rotation.into_inner(), ) @@ -4540,9 +4572,9 @@ impl bevy::math::primitives::Segment3d { } /// Compute the vector from the first endpoint to the second endpoint. fn scaled_direction( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Segment3d::scaled_direction( + _self: Ref<::bevy_math::primitives::Segment3d>, + ) -> Val<::bevy_math::prelude::Vec3> { + let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::primitives::Segment3d::scaled_direction( &_self, ) .into(); @@ -4550,10 +4582,10 @@ impl bevy::math::primitives::Segment3d { } /// Compute the segment translated by the given vector. fn translated( - _self: Ref, - translation: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Segment3d::translated( + _self: Ref<::bevy_math::primitives::Segment3d>, + translation: Val<::bevy_math::prelude::Vec3>, + ) -> Val<::bevy_math::primitives::Segment3d> { + let output: Val<::bevy_math::primitives::Segment3d> = ::bevy_math::primitives::Segment3d::translated( &_self, translation.into_inner(), ) @@ -4567,22 +4599,22 @@ impl bevy::math::primitives::Segment3d { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::Torus { +impl ::bevy_math::primitives::Torus { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::Torus>, + ) -> Val<::bevy_math::primitives::Torus> { + let output: Val<::bevy_math::primitives::Torus> = <::bevy_math::primitives::Torus as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::Torus>, + other: Ref<::bevy_math::primitives::Torus>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -4590,15 +4622,15 @@ impl bevy::math::primitives::Torus { /// Get the inner radius of the torus. /// For a ring torus, this corresponds to the radius of the hole, /// or `major_radius - minor_radius` - fn inner_radius(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Torus::inner_radius(&_self).into(); + fn inner_radius(_self: Ref<::bevy_math::primitives::Torus>) -> f32 { + let output: f32 = ::bevy_math::primitives::Torus::inner_radius(&_self).into(); output } /// Create a new `Torus` from an inner and outer radius. /// The inner radius is the radius of the hole, and the outer radius /// is the radius of the entire object - fn new(inner_radius: f32, outer_radius: f32) -> Val { - let output: Val = bevy::math::primitives::Torus::new( + fn new(inner_radius: f32, outer_radius: f32) -> Val<::bevy_math::primitives::Torus> { + let output: Val<::bevy_math::primitives::Torus> = ::bevy_math::primitives::Torus::new( inner_radius, outer_radius, ) @@ -4608,8 +4640,8 @@ impl bevy::math::primitives::Torus { /// Get the outer radius of the torus. /// This corresponds to the overall radius of the entire object, /// or `major_radius + minor_radius` - fn outer_radius(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Torus::outer_radius(&_self).into(); + fn outer_radius(_self: Ref<::bevy_math::primitives::Torus>) -> f32 { + let output: f32 = ::bevy_math::primitives::Torus::outer_radius(&_self).into(); output } } @@ -4619,14 +4651,14 @@ impl bevy::math::primitives::Torus { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::Triangle3d { +impl ::bevy_math::primitives::Triangle3d { /// Get the centroid of the triangle. /// This function finds the geometric center of the triangle by averaging the vertices: /// `centroid = (a + b + c) / 3`. fn centroid( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Triangle3d::centroid( + _self: Ref<::bevy_math::primitives::Triangle3d>, + ) -> Val<::bevy_math::prelude::Vec3> { + let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::primitives::Triangle3d::centroid( &_self, ) .into(); @@ -4634,58 +4666,58 @@ impl bevy::math::primitives::Triangle3d { } /// Get the circumcenter of the triangle. fn circumcenter( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Triangle3d::circumcenter( + _self: Ref<::bevy_math::primitives::Triangle3d>, + ) -> Val<::bevy_math::prelude::Vec3> { + let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::primitives::Triangle3d::circumcenter( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::Triangle3d>, + ) -> Val<::bevy_math::primitives::Triangle3d> { + let output: Val<::bevy_math::primitives::Triangle3d> = <::bevy_math::primitives::Triangle3d as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::Triangle3d>, + other: Ref<::bevy_math::primitives::Triangle3d>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Checks if the triangle is acute, meaning all angles are less than 90 degrees - fn is_acute(_self: Ref) -> bool { - let output: bool = bevy::math::primitives::Triangle3d::is_acute(&_self).into(); + fn is_acute(_self: Ref<::bevy_math::primitives::Triangle3d>) -> bool { + let output: bool = ::bevy_math::primitives::Triangle3d::is_acute(&_self).into(); output } /// Checks if the triangle is degenerate, meaning it has zero area. /// A triangle is degenerate if the cross product of the vectors `ab` and `ac` has a length less than `10e-7`. /// This indicates that the three vertices are collinear or nearly collinear. - fn is_degenerate(_self: Ref) -> bool { - let output: bool = bevy::math::primitives::Triangle3d::is_degenerate(&_self) + fn is_degenerate(_self: Ref<::bevy_math::primitives::Triangle3d>) -> bool { + let output: bool = ::bevy_math::primitives::Triangle3d::is_degenerate(&_self) .into(); output } /// Checks if the triangle is obtuse, meaning one angle is greater than 90 degrees - fn is_obtuse(_self: Ref) -> bool { - let output: bool = bevy::math::primitives::Triangle3d::is_obtuse(&_self).into(); + fn is_obtuse(_self: Ref<::bevy_math::primitives::Triangle3d>) -> bool { + let output: bool = ::bevy_math::primitives::Triangle3d::is_obtuse(&_self).into(); output } /// Create a new [`Triangle3d`] from points `a`, `b`, and `c`. fn new( - a: Val, - b: Val, - c: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Triangle3d::new( + a: Val<::bevy_math::prelude::Vec3>, + b: Val<::bevy_math::prelude::Vec3>, + c: Val<::bevy_math::prelude::Vec3>, + ) -> Val<::bevy_math::primitives::Triangle3d> { + let output: Val<::bevy_math::primitives::Triangle3d> = ::bevy_math::primitives::Triangle3d::new( a.into_inner(), b.into_inner(), c.into_inner(), @@ -4694,15 +4726,15 @@ impl bevy::math::primitives::Triangle3d { output } /// Reverse the triangle by swapping the first and last vertices. - fn reverse(mut _self: Mut) -> () { - let output: () = bevy::math::primitives::Triangle3d::reverse(&mut _self).into(); + fn reverse(mut _self: Mut<::bevy_math::primitives::Triangle3d>) -> () { + let output: () = ::bevy_math::primitives::Triangle3d::reverse(&mut _self).into(); output } /// This triangle but reversed. fn reversed( - _self: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Triangle3d::reversed( + _self: Val<::bevy_math::primitives::Triangle3d>, + ) -> Val<::bevy_math::primitives::Triangle3d> { + let output: Val<::bevy_math::primitives::Triangle3d> = ::bevy_math::primitives::Triangle3d::reversed( _self.into_inner(), ) .into(); @@ -4715,13 +4747,13 @@ impl bevy::math::primitives::Triangle3d { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::bounding::RayCast2d { +impl ::bevy_math::bounding::RayCast2d { /// Get the distance of an intersection with an [`Aabb2d`], if any. fn aabb_intersection_at( - _self: Ref, - aabb: Ref, + _self: Ref<::bevy_math::bounding::RayCast2d>, + aabb: Ref<::bevy_math::bounding::Aabb2d>, ) -> ::core::option::Option { - let output: ::core::option::Option = bevy::math::bounding::RayCast2d::aabb_intersection_at( + let output: ::core::option::Option = ::bevy_math::bounding::RayCast2d::aabb_intersection_at( &_self, &aabb, ) @@ -4730,10 +4762,10 @@ impl bevy::math::bounding::RayCast2d { } /// Get the distance of an intersection with a [`BoundingCircle`], if any. fn circle_intersection_at( - _self: Ref, - circle: Ref, + _self: Ref<::bevy_math::bounding::RayCast2d>, + circle: Ref<::bevy_math::bounding::BoundingCircle>, ) -> ::core::option::Option { - let output: ::core::option::Option = bevy::math::bounding::RayCast2d::circle_intersection_at( + let output: ::core::option::Option = ::bevy_math::bounding::RayCast2d::circle_intersection_at( &_self, &circle, ) @@ -4741,9 +4773,9 @@ impl bevy::math::bounding::RayCast2d { output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::bounding::RayCast2d>, + ) -> Val<::bevy_math::bounding::RayCast2d> { + let output: Val<::bevy_math::bounding::RayCast2d> = <::bevy_math::bounding::RayCast2d as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -4751,9 +4783,9 @@ impl bevy::math::bounding::RayCast2d { } /// Get the cached multiplicative inverse of the direction of the ray. fn direction_recip( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::bounding::RayCast2d::direction_recip( + _self: Ref<::bevy_math::bounding::RayCast2d>, + ) -> Val<::bevy_math::prelude::Vec2> { + let output: Val<::bevy_math::prelude::Vec2> = ::bevy_math::bounding::RayCast2d::direction_recip( &_self, ) .into(); @@ -4761,10 +4793,10 @@ impl bevy::math::bounding::RayCast2d { } /// Construct a [`RayCast2d`] from a [`Ray2d`] and max distance. fn from_ray( - ray: Val, + ray: Val<::bevy_math::Ray2d>, max: f32, - ) -> Val { - let output: Val = bevy::math::bounding::RayCast2d::from_ray( + ) -> Val<::bevy_math::bounding::RayCast2d> { + let output: Val<::bevy_math::bounding::RayCast2d> = ::bevy_math::bounding::RayCast2d::from_ray( ray.into_inner(), max, ) @@ -4773,11 +4805,11 @@ impl bevy::math::bounding::RayCast2d { } /// Construct a [`RayCast2d`] from an origin, [`Dir2`], and max distance. fn new( - origin: Val, - direction: Val, + origin: Val<::bevy_math::prelude::Vec2>, + direction: Val<::bevy_math::prelude::Dir2>, max: f32, - ) -> Val { - let output: Val = bevy::math::bounding::RayCast2d::new( + ) -> Val<::bevy_math::bounding::RayCast2d> { + let output: Val<::bevy_math::bounding::RayCast2d> = ::bevy_math::bounding::RayCast2d::new( origin.into_inner(), direction.into_inner(), max, @@ -4792,13 +4824,13 @@ impl bevy::math::bounding::RayCast2d { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::bounding::AabbCast2d { +impl ::bevy_math::bounding::AabbCast2d { /// Get the distance at which the [`Aabb2d`]s collide, if at all. fn aabb_collision_at( - _self: Ref, - aabb: Val, + _self: Ref<::bevy_math::bounding::AabbCast2d>, + aabb: Val<::bevy_math::bounding::Aabb2d>, ) -> ::core::option::Option { - let output: ::core::option::Option = bevy::math::bounding::AabbCast2d::aabb_collision_at( + let output: ::core::option::Option = ::bevy_math::bounding::AabbCast2d::aabb_collision_at( &_self, aabb.into_inner(), ) @@ -4806,9 +4838,9 @@ impl bevy::math::bounding::AabbCast2d { output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::bounding::AabbCast2d>, + ) -> Val<::bevy_math::bounding::AabbCast2d> { + let output: Val<::bevy_math::bounding::AabbCast2d> = <::bevy_math::bounding::AabbCast2d as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -4816,11 +4848,11 @@ impl bevy::math::bounding::AabbCast2d { } /// Construct an [`AabbCast2d`] from an [`Aabb2d`], [`Ray2d`], and max distance. fn from_ray( - aabb: Val, - ray: Val, + aabb: Val<::bevy_math::bounding::Aabb2d>, + ray: Val<::bevy_math::Ray2d>, max: f32, - ) -> Val { - let output: Val = bevy::math::bounding::AabbCast2d::from_ray( + ) -> Val<::bevy_math::bounding::AabbCast2d> { + let output: Val<::bevy_math::bounding::AabbCast2d> = ::bevy_math::bounding::AabbCast2d::from_ray( aabb.into_inner(), ray.into_inner(), max, @@ -4830,12 +4862,12 @@ impl bevy::math::bounding::AabbCast2d { } /// Construct an [`AabbCast2d`] from an [`Aabb2d`], origin, [`Dir2`], and max distance. fn new( - aabb: Val, - origin: Val, - direction: Val, + aabb: Val<::bevy_math::bounding::Aabb2d>, + origin: Val<::bevy_math::prelude::Vec2>, + direction: Val<::bevy_math::prelude::Dir2>, max: f32, - ) -> Val { - let output: Val = bevy::math::bounding::AabbCast2d::new( + ) -> Val<::bevy_math::bounding::AabbCast2d> { + let output: Val<::bevy_math::bounding::AabbCast2d> = ::bevy_math::bounding::AabbCast2d::new( aabb.into_inner(), origin.into_inner(), direction.into_inner(), @@ -4851,13 +4883,13 @@ impl bevy::math::bounding::AabbCast2d { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::bounding::BoundingCircleCast { +impl ::bevy_math::bounding::BoundingCircleCast { /// Get the distance at which the [`BoundingCircle`]s collide, if at all. fn circle_collision_at( - _self: Ref, - circle: Val, + _self: Ref<::bevy_math::bounding::BoundingCircleCast>, + circle: Val<::bevy_math::bounding::BoundingCircle>, ) -> ::core::option::Option { - let output: ::core::option::Option = bevy::math::bounding::BoundingCircleCast::circle_collision_at( + let output: ::core::option::Option = ::bevy_math::bounding::BoundingCircleCast::circle_collision_at( &_self, circle.into_inner(), ) @@ -4865,9 +4897,9 @@ impl bevy::math::bounding::BoundingCircleCast { output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::bounding::BoundingCircleCast>, + ) -> Val<::bevy_math::bounding::BoundingCircleCast> { + let output: Val<::bevy_math::bounding::BoundingCircleCast> = <::bevy_math::bounding::BoundingCircleCast as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -4875,11 +4907,11 @@ impl bevy::math::bounding::BoundingCircleCast { } /// Construct a [`BoundingCircleCast`] from a [`BoundingCircle`], [`Ray2d`], and max distance. fn from_ray( - circle: Val, - ray: Val, + circle: Val<::bevy_math::bounding::BoundingCircle>, + ray: Val<::bevy_math::Ray2d>, max: f32, - ) -> Val { - let output: Val = bevy::math::bounding::BoundingCircleCast::from_ray( + ) -> Val<::bevy_math::bounding::BoundingCircleCast> { + let output: Val<::bevy_math::bounding::BoundingCircleCast> = ::bevy_math::bounding::BoundingCircleCast::from_ray( circle.into_inner(), ray.into_inner(), max, @@ -4889,12 +4921,12 @@ impl bevy::math::bounding::BoundingCircleCast { } /// Construct a [`BoundingCircleCast`] from a [`BoundingCircle`], origin, [`Dir2`], and max distance. fn new( - circle: Val, - origin: Val, - direction: Val, + circle: Val<::bevy_math::bounding::BoundingCircle>, + origin: Val<::bevy_math::prelude::Vec2>, + direction: Val<::bevy_math::prelude::Dir2>, max: f32, - ) -> Val { - let output: Val = bevy::math::bounding::BoundingCircleCast::new( + ) -> Val<::bevy_math::bounding::BoundingCircleCast> { + let output: Val<::bevy_math::bounding::BoundingCircleCast> = ::bevy_math::bounding::BoundingCircleCast::new( circle.into_inner(), origin.into_inner(), direction.into_inner(), @@ -4910,13 +4942,13 @@ impl bevy::math::bounding::BoundingCircleCast { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::bounding::RayCast3d { +impl ::bevy_math::bounding::RayCast3d { /// Get the distance of an intersection with an [`Aabb3d`], if any. fn aabb_intersection_at( - _self: Ref, - aabb: Ref, + _self: Ref<::bevy_math::bounding::RayCast3d>, + aabb: Ref<::bevy_math::bounding::Aabb3d>, ) -> ::core::option::Option { - let output: ::core::option::Option = bevy::math::bounding::RayCast3d::aabb_intersection_at( + let output: ::core::option::Option = ::bevy_math::bounding::RayCast3d::aabb_intersection_at( &_self, &aabb, ) @@ -4924,9 +4956,9 @@ impl bevy::math::bounding::RayCast3d { output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::bounding::RayCast3d>, + ) -> Val<::bevy_math::bounding::RayCast3d> { + let output: Val<::bevy_math::bounding::RayCast3d> = <::bevy_math::bounding::RayCast3d as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -4934,9 +4966,9 @@ impl bevy::math::bounding::RayCast3d { } /// Get the cached multiplicative inverse of the direction of the ray. fn direction_recip( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::bounding::RayCast3d::direction_recip( + _self: Ref<::bevy_math::bounding::RayCast3d>, + ) -> Val<::bevy_math::prelude::Vec3A> { + let output: Val<::bevy_math::prelude::Vec3A> = ::bevy_math::bounding::RayCast3d::direction_recip( &_self, ) .into(); @@ -4944,10 +4976,10 @@ impl bevy::math::bounding::RayCast3d { } /// Construct a [`RayCast3d`] from a [`Ray3d`] and max distance. fn from_ray( - ray: Val, + ray: Val<::bevy_math::Ray3d>, max: f32, - ) -> Val { - let output: Val = bevy::math::bounding::RayCast3d::from_ray( + ) -> Val<::bevy_math::bounding::RayCast3d> { + let output: Val<::bevy_math::bounding::RayCast3d> = ::bevy_math::bounding::RayCast3d::from_ray( ray.into_inner(), max, ) @@ -4956,10 +4988,10 @@ impl bevy::math::bounding::RayCast3d { } /// Get the distance of an intersection with a [`BoundingSphere`], if any. fn sphere_intersection_at( - _self: Ref, - sphere: Ref, + _self: Ref<::bevy_math::bounding::RayCast3d>, + sphere: Ref<::bevy_math::bounding::BoundingSphere>, ) -> ::core::option::Option { - let output: ::core::option::Option = bevy::math::bounding::RayCast3d::sphere_intersection_at( + let output: ::core::option::Option = ::bevy_math::bounding::RayCast3d::sphere_intersection_at( &_self, &sphere, ) @@ -4973,13 +5005,13 @@ impl bevy::math::bounding::RayCast3d { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::bounding::AabbCast3d { +impl ::bevy_math::bounding::AabbCast3d { /// Get the distance at which the [`Aabb3d`]s collide, if at all. fn aabb_collision_at( - _self: Ref, - aabb: Val, + _self: Ref<::bevy_math::bounding::AabbCast3d>, + aabb: Val<::bevy_math::bounding::Aabb3d>, ) -> ::core::option::Option { - let output: ::core::option::Option = bevy::math::bounding::AabbCast3d::aabb_collision_at( + let output: ::core::option::Option = ::bevy_math::bounding::AabbCast3d::aabb_collision_at( &_self, aabb.into_inner(), ) @@ -4987,9 +5019,9 @@ impl bevy::math::bounding::AabbCast3d { output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::bounding::AabbCast3d>, + ) -> Val<::bevy_math::bounding::AabbCast3d> { + let output: Val<::bevy_math::bounding::AabbCast3d> = <::bevy_math::bounding::AabbCast3d as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -4997,11 +5029,11 @@ impl bevy::math::bounding::AabbCast3d { } /// Construct an [`AabbCast3d`] from an [`Aabb3d`], [`Ray3d`], and max distance. fn from_ray( - aabb: Val, - ray: Val, + aabb: Val<::bevy_math::bounding::Aabb3d>, + ray: Val<::bevy_math::Ray3d>, max: f32, - ) -> Val { - let output: Val = bevy::math::bounding::AabbCast3d::from_ray( + ) -> Val<::bevy_math::bounding::AabbCast3d> { + let output: Val<::bevy_math::bounding::AabbCast3d> = ::bevy_math::bounding::AabbCast3d::from_ray( aabb.into_inner(), ray.into_inner(), max, @@ -5016,11 +5048,11 @@ impl bevy::math::bounding::AabbCast3d { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::bounding::BoundingSphereCast { +impl ::bevy_math::bounding::BoundingSphereCast { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::bounding::BoundingSphereCast>, + ) -> Val<::bevy_math::bounding::BoundingSphereCast> { + let output: Val<::bevy_math::bounding::BoundingSphereCast> = <::bevy_math::bounding::BoundingSphereCast as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -5028,11 +5060,11 @@ impl bevy::math::bounding::BoundingSphereCast { } /// Construct a [`BoundingSphereCast`] from a [`BoundingSphere`], [`Ray3d`], and max distance. fn from_ray( - sphere: Val, - ray: Val, + sphere: Val<::bevy_math::bounding::BoundingSphere>, + ray: Val<::bevy_math::Ray3d>, max: f32, - ) -> Val { - let output: Val = bevy::math::bounding::BoundingSphereCast::from_ray( + ) -> Val<::bevy_math::bounding::BoundingSphereCast> { + let output: Val<::bevy_math::bounding::BoundingSphereCast> = ::bevy_math::bounding::BoundingSphereCast::from_ray( sphere.into_inner(), ray.into_inner(), max, @@ -5042,10 +5074,10 @@ impl bevy::math::bounding::BoundingSphereCast { } /// Get the distance at which the [`BoundingSphere`]s collide, if at all. fn sphere_collision_at( - _self: Ref, - sphere: Val, + _self: Ref<::bevy_math::bounding::BoundingSphereCast>, + sphere: Val<::bevy_math::bounding::BoundingSphere>, ) -> ::core::option::Option { - let output: ::core::option::Option = bevy::math::bounding::BoundingSphereCast::sphere_collision_at( + let output: ::core::option::Option = ::bevy_math::bounding::BoundingSphereCast::sphere_collision_at( &_self, sphere.into_inner(), ) @@ -5059,10 +5091,10 @@ impl bevy::math::bounding::BoundingSphereCast { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::curve::interval::Interval { +impl ::bevy_math::curve::interval::Interval { /// Clamp the given `value` to lie within this interval. - fn clamp(_self: Val, value: f32) -> f32 { - let output: f32 = bevy::math::curve::interval::Interval::clamp( + fn clamp(_self: Val<::bevy_math::curve::interval::Interval>, value: f32) -> f32 { + let output: f32 = ::bevy_math::curve::interval::Interval::clamp( _self.into_inner(), value, ) @@ -5070,17 +5102,17 @@ impl bevy::math::curve::interval::Interval { output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::curve::interval::Interval>, + ) -> Val<::bevy_math::curve::interval::Interval> { + let output: Val<::bevy_math::curve::interval::Interval> = <::bevy_math::curve::interval::Interval as ::core::clone::Clone>::clone( &_self, ) .into(); output } /// Returns `true` if `item` is contained in this interval. - fn contains(_self: Val, item: f32) -> bool { - let output: bool = bevy::math::curve::interval::Interval::contains( + fn contains(_self: Val<::bevy_math::curve::interval::Interval>, item: f32) -> bool { + let output: bool = ::bevy_math::curve::interval::Interval::contains( _self.into_inner(), item, ) @@ -5090,10 +5122,10 @@ impl bevy::math::curve::interval::Interval { /// Returns `true` if the other interval is contained in this interval. /// This is non-strict: each interval will contain itself. fn contains_interval( - _self: Val, - other: Val, + _self: Val<::bevy_math::curve::interval::Interval>, + other: Val<::bevy_math::curve::interval::Interval>, ) -> bool { - let output: bool = bevy::math::curve::interval::Interval::contains_interval( + let output: bool = ::bevy_math::curve::interval::Interval::contains_interval( _self.into_inner(), other.into_inner(), ) @@ -5101,32 +5133,32 @@ impl bevy::math::curve::interval::Interval { output } /// Get the end of this interval. - fn end(_self: Val) -> f32 { - let output: f32 = bevy::math::curve::interval::Interval::end(_self.into_inner()) + fn end(_self: Val<::bevy_math::curve::interval::Interval>) -> f32 { + let output: f32 = ::bevy_math::curve::interval::Interval::end(_self.into_inner()) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::curve::interval::Interval>, + other: Ref<::bevy_math::curve::interval::Interval>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Returns `true` if this interval has a finite end. - fn has_finite_end(_self: Val) -> bool { - let output: bool = bevy::math::curve::interval::Interval::has_finite_end( + fn has_finite_end(_self: Val<::bevy_math::curve::interval::Interval>) -> bool { + let output: bool = ::bevy_math::curve::interval::Interval::has_finite_end( _self.into_inner(), ) .into(); output } /// Returns `true` if this interval has a finite start. - fn has_finite_start(_self: Val) -> bool { - let output: bool = bevy::math::curve::interval::Interval::has_finite_start( + fn has_finite_start(_self: Val<::bevy_math::curve::interval::Interval>) -> bool { + let output: bool = ::bevy_math::curve::interval::Interval::has_finite_start( _self.into_inner(), ) .into(); @@ -5134,24 +5166,24 @@ impl bevy::math::curve::interval::Interval { } /// Returns `true` if this interval is bounded — that is, if both its start and end are finite. /// Equivalently, an interval is bounded if its length is finite. - fn is_bounded(_self: Val) -> bool { - let output: bool = bevy::math::curve::interval::Interval::is_bounded( + fn is_bounded(_self: Val<::bevy_math::curve::interval::Interval>) -> bool { + let output: bool = ::bevy_math::curve::interval::Interval::is_bounded( _self.into_inner(), ) .into(); output } /// Get the length of this interval. Note that the result may be infinite (`f32::INFINITY`). - fn length(_self: Val) -> f32 { - let output: f32 = bevy::math::curve::interval::Interval::length( + fn length(_self: Val<::bevy_math::curve::interval::Interval>) -> f32 { + let output: f32 = ::bevy_math::curve::interval::Interval::length( _self.into_inner(), ) .into(); output } /// Get the start of this interval. - fn start(_self: Val) -> f32 { - let output: f32 = bevy::math::curve::interval::Interval::start( + fn start(_self: Val<::bevy_math::curve::interval::Interval>) -> f32 { + let output: f32 = ::bevy_math::curve::interval::Interval::start( _self.into_inner(), ) .into(); @@ -5164,51 +5196,51 @@ impl bevy::math::curve::interval::Interval { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::FloatOrd { - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( +impl ::bevy_math::FloatOrd { + fn clone(_self: Ref<::bevy_math::FloatOrd>) -> Val<::bevy_math::FloatOrd> { + let output: Val<::bevy_math::FloatOrd> = <::bevy_math::FloatOrd as ::core::clone::Clone>::clone( &_self, ) .into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::bevy_math::FloatOrd>) -> bool { + let output: bool = <::bevy_math::FloatOrd as ::core::cmp::PartialEq< + ::bevy_math::FloatOrd, >>::eq(&_self, &other) .into(); output } - fn ge(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::bevy_math::FloatOrd>) -> bool { + let output: bool = <::bevy_math::FloatOrd as ::core::cmp::PartialOrd< + ::bevy_math::FloatOrd, >>::ge(&_self, &other) .into(); output } - fn gt(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::bevy_math::FloatOrd>) -> bool { + let output: bool = <::bevy_math::FloatOrd as ::core::cmp::PartialOrd< + ::bevy_math::FloatOrd, >>::gt(&_self, &other) .into(); output } - fn le(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::bevy_math::FloatOrd>) -> bool { + let output: bool = <::bevy_math::FloatOrd as ::core::cmp::PartialOrd< + ::bevy_math::FloatOrd, >>::le(&_self, &other) .into(); output } - fn lt(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::bevy_math::FloatOrd>) -> bool { + let output: bool = <::bevy_math::FloatOrd as ::core::cmp::PartialOrd< + ::bevy_math::FloatOrd, >>::lt(&_self, &other) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::bevy_math::FloatOrd>) -> Val<::bevy_math::FloatOrd> { + let output: Val<::bevy_math::FloatOrd> = <::bevy_math::FloatOrd as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -5221,22 +5253,22 @@ impl bevy::math::FloatOrd { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::Plane3d { +impl ::bevy_math::primitives::Plane3d { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::Plane3d>, + ) -> Val<::bevy_math::primitives::Plane3d> { + let output: Val<::bevy_math::primitives::Plane3d> = <::bevy_math::primitives::Plane3d as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::Plane3d>, + other: Ref<::bevy_math::primitives::Plane3d>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -5245,10 +5277,10 @@ impl bevy::math::primitives::Plane3d { /// # Panics /// Panics if the given `normal` is zero (or very close to zero), or non-finite. fn new( - normal: Val, - half_size: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Plane3d::new( + normal: Val<::bevy_math::prelude::Vec3>, + half_size: Val<::bevy_math::prelude::Vec2>, + ) -> Val<::bevy_math::primitives::Plane3d> { + let output: Val<::bevy_math::primitives::Plane3d> = ::bevy_math::primitives::Plane3d::new( normal.into_inner(), half_size.into_inner(), ) @@ -5262,46 +5294,46 @@ impl bevy::math::primitives::Plane3d { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::primitives::Tetrahedron { +impl ::bevy_math::primitives::Tetrahedron { /// Get the centroid of the tetrahedron. /// This function finds the geometric center of the tetrahedron /// by averaging the vertices: `centroid = (a + b + c + d) / 4`. fn centroid( - _self: Ref, - ) -> Val { - let output: Val = bevy::math::primitives::Tetrahedron::centroid( + _self: Ref<::bevy_math::primitives::Tetrahedron>, + ) -> Val<::bevy_math::prelude::Vec3> { + let output: Val<::bevy_math::prelude::Vec3> = ::bevy_math::primitives::Tetrahedron::centroid( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::primitives::Tetrahedron>, + ) -> Val<::bevy_math::primitives::Tetrahedron> { + let output: Val<::bevy_math::primitives::Tetrahedron> = <::bevy_math::primitives::Tetrahedron as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::primitives::Tetrahedron>, + other: Ref<::bevy_math::primitives::Tetrahedron>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Create a new [`Tetrahedron`] from points `a`, `b`, `c` and `d`. fn new( - a: Val, - b: Val, - c: Val, - d: Val, - ) -> Val { - let output: Val = bevy::math::primitives::Tetrahedron::new( + a: Val<::bevy_math::prelude::Vec3>, + b: Val<::bevy_math::prelude::Vec3>, + c: Val<::bevy_math::prelude::Vec3>, + d: Val<::bevy_math::prelude::Vec3>, + ) -> Val<::bevy_math::primitives::Tetrahedron> { + let output: Val<::bevy_math::primitives::Tetrahedron> = ::bevy_math::primitives::Tetrahedron::new( a.into_inner(), b.into_inner(), c.into_inner(), @@ -5314,8 +5346,8 @@ impl bevy::math::primitives::Tetrahedron { /// If it's negative, the normal vector of the face defined by /// the first three points using the right-hand rule points /// away from the fourth vertex. - fn signed_volume(_self: Ref) -> f32 { - let output: f32 = bevy::math::primitives::Tetrahedron::signed_volume(&_self) + fn signed_volume(_self: Ref<::bevy_math::primitives::Tetrahedron>) -> f32 { + let output: f32 = ::bevy_math::primitives::Tetrahedron::signed_volume(&_self) .into(); output } @@ -5326,22 +5358,22 @@ impl bevy::math::primitives::Tetrahedron { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::curve::easing::EaseFunction { +impl ::bevy_math::curve::easing::EaseFunction { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::curve::easing::EaseFunction>, + ) -> Val<::bevy_math::curve::easing::EaseFunction> { + let output: Val<::bevy_math::curve::easing::EaseFunction> = <::bevy_math::curve::easing::EaseFunction as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::curve::easing::EaseFunction>, + other: Ref<::bevy_math::curve::easing::EaseFunction>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -5353,29 +5385,31 @@ impl bevy::math::curve::easing::EaseFunction { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::curve::easing::JumpAt { - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( +impl ::bevy_math::curve::easing::JumpAt { + fn assert_receiver_is_total_eq( + _self: Ref<::bevy_math::curve::easing::JumpAt>, + ) -> () { + let output: () = <::bevy_math::curve::easing::JumpAt as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_math::curve::easing::JumpAt>, + ) -> Val<::bevy_math::curve::easing::JumpAt> { + let output: Val<::bevy_math::curve::easing::JumpAt> = <::bevy_math::curve::easing::JumpAt as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_math::curve::easing::JumpAt>, + other: Ref<::bevy_math::curve::easing::JumpAt>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_reflect.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_reflect.rs index 5db17464fc..bbdd1da621 100644 --- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_reflect.rs +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_reflect.rs @@ -522,7 +522,7 @@ impl ::core::time::Duration { output } fn clone(_self: Ref<::core::time::Duration>) -> Val<::core::time::Duration> { - let output: Val<::core::time::Duration> = <::core::time::Duration as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone( + let output: Val<::core::time::Duration> = <::core::time::Duration as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -979,7 +979,7 @@ impl ::std::time::Instant { output } fn clone(_self: Ref<::std::time::Instant>) -> Val<::std::time::Instant> { - let output: Val<::std::time::Instant> = <::std::time::Instant as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone( + let output: Val<::std::time::Instant> = <::std::time::Instant as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -1116,7 +1116,7 @@ impl ::core::ops::RangeFull { output } fn clone(_self: Ref<::core::ops::RangeFull>) -> Val<::core::ops::RangeFull> { - let output: Val<::core::ops::RangeFull> = <::core::ops::RangeFull as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone( + let output: Val<::core::ops::RangeFull> = <::core::ops::RangeFull as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -1148,7 +1148,7 @@ impl ::core::any::TypeId { output } fn clone(_self: Ref<::core::any::TypeId>) -> Val<::core::any::TypeId> { - let output: Val<::core::any::TypeId> = <::core::any::TypeId as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone( + let output: Val<::core::any::TypeId> = <::core::any::TypeId as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -1168,7 +1168,7 @@ impl ::core::any::TypeId { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::Quat { +impl ::glam::Quat { /// Returns true if the absolute difference of all elements between `self` and `rhs` /// is less than or equal to `max_abs_diff`. /// This can be used to compare if two quaternions contain similar elements. It works @@ -1177,11 +1177,11 @@ impl bevy::math::Quat { /// For more see /// [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/). fn abs_diff_eq( - _self: Val, - rhs: Val, + _self: Val<::glam::Quat>, + rhs: Val<::glam::Quat>, max_abs_diff: f32, ) -> bool { - let output: bool = bevy::math::Quat::abs_diff_eq( + let output: bool = ::glam::Quat::abs_diff_eq( _self.into_inner(), rhs.into_inner(), max_abs_diff, @@ -1193,12 +1193,9 @@ impl bevy::math::Quat { /// The sum is not guaranteed to be normalized. /// Note that addition is not the same as combining the rotations represented by the /// two quaternions! That corresponds to multiplication. - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Quat>) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Add< + ::glam::Quat, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output @@ -1208,23 +1205,21 @@ impl bevy::math::Quat { /// Both quaternions must be normalized. /// # Panics /// Will panic if `self` or `rhs` are not normalized when `glam_assert` is enabled. - fn angle_between(_self: Val, rhs: Val) -> f32 { - let output: f32 = bevy::math::Quat::angle_between( + fn angle_between(_self: Val<::glam::Quat>, rhs: Val<::glam::Quat>) -> f32 { + let output: f32 = ::glam::Quat::angle_between( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn as_dquat(_self: Val) -> Val { - let output: Val = bevy::math::Quat::as_dquat( - _self.into_inner(), - ) + fn as_dquat(_self: Val<::glam::Quat>) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = ::glam::Quat::as_dquat(_self.into_inner()) .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::Quat>) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = <::glam::Quat as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -1232,17 +1227,15 @@ impl bevy::math::Quat { } /// Returns the quaternion conjugate of `self`. For a unit quaternion the /// conjugate is also the inverse. - fn conjugate(_self: Val) -> Val { - let output: Val = bevy::math::Quat::conjugate( - _self.into_inner(), - ) + fn conjugate(_self: Val<::glam::Quat>) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::Quat::conjugate(_self.into_inner()) .into(); output } /// Divides a quaternion by a scalar value. /// The quotient is not guaranteed to be normalized. - fn div(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -1250,14 +1243,13 @@ impl bevy::math::Quat { } /// Computes the dot product of `self` and `rhs`. The dot product is /// equal to the cosine of the angle between two quaternion rotations. - fn dot(_self: Val, rhs: Val) -> f32 { - let output: f32 = bevy::math::Quat::dot(_self.into_inner(), rhs.into_inner()) - .into(); + fn dot(_self: Val<::glam::Quat>, rhs: Val<::glam::Quat>) -> f32 { + let output: f32 = ::glam::Quat::dot(_self.into_inner(), rhs.into_inner()).into(); output } - fn eq(_self: Ref, rhs: Ref) -> bool { - let output: bool = , rhs: Ref<::glam::Quat>) -> bool { + let output: bool = <::glam::Quat as ::core::cmp::PartialEq< + ::glam::Quat, >>::eq(&_self, &rhs) .into(); output @@ -1268,27 +1260,24 @@ impl bevy::math::Quat { /// # Panics /// Will panic if any input affine matrix column is not normalized when `glam_assert` is /// enabled. - fn from_affine3(a: Ref) -> Val { - let output: Val = bevy::math::Quat::from_affine3(&a).into(); + fn from_affine3(a: Ref<::glam::Affine3A>) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::Quat::from_affine3(&a).into(); output } /// Creates a rotation quaternion from an array. /// # Preconditions /// This function does not check if the input is normalized, it is up to the user to /// provide normalized input or to normalized the resulting quaternion. - fn from_array(a: [f32; 4]) -> Val { - let output: Val = bevy::math::Quat::from_array(a).into(); + fn from_array(a: [f32; 4]) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::Quat::from_array(a).into(); output } /// Create a quaternion for a normalized rotation `axis` and `angle` (in radians). /// The axis must be a unit vector. /// # Panics /// Will panic if `axis` is not normalized when `glam_assert` is enabled. - fn from_axis_angle( - axis: Val, - angle: f32, - ) -> Val { - let output: Val = bevy::math::Quat::from_axis_angle( + fn from_axis_angle(axis: Val<::glam::Vec3>, angle: f32) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::Quat::from_axis_angle( axis.into_inner(), angle, ) @@ -1297,12 +1286,12 @@ impl bevy::math::Quat { } /// Creates a quaternion from the given Euler rotation sequence and the angles (in radians). fn from_euler( - euler: Val, + euler: Val<::glam::EulerRot>, a: f32, b: f32, c: f32, - ) -> Val { - let output: Val = bevy::math::Quat::from_euler( + ) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::Quat::from_euler( euler.into_inner(), a, b, @@ -1316,8 +1305,8 @@ impl bevy::math::Quat { /// the resulting quaternion will be ill-defined. /// # Panics /// Will panic if any input matrix column is not normalized when `glam_assert` is enabled. - fn from_mat3(mat: Ref) -> Val { - let output: Val = bevy::math::Quat::from_mat3(&mat).into(); + fn from_mat3(mat: Ref<::glam::Mat3>) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::Quat::from_mat3(&mat).into(); output } /// Creates a quaternion from a 3x3 SIMD aligned rotation matrix. @@ -1325,8 +1314,8 @@ impl bevy::math::Quat { /// the resulting quaternion will be ill-defined. /// # Panics /// Will panic if any input matrix column is not normalized when `glam_assert` is enabled. - fn from_mat3a(mat: Ref) -> Val { - let output: Val = bevy::math::Quat::from_mat3a(&mat).into(); + fn from_mat3a(mat: Ref<::glam::Mat3A>) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::Quat::from_mat3a(&mat).into(); output } /// Creates a quaternion from the upper 3x3 rotation matrix inside a homogeneous 4x4 matrix. @@ -1335,8 +1324,8 @@ impl bevy::math::Quat { /// # Panics /// Will panic if any column of the upper 3x3 rotation matrix is not normalized when /// `glam_assert` is enabled. - fn from_mat4(mat: Ref) -> Val { - let output: Val = bevy::math::Quat::from_mat4(&mat).into(); + fn from_mat4(mat: Ref<::glam::Mat4>) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::Quat::from_mat4(&mat).into(); output } /// Gets the minimal rotation for transforming `from` to `to`. The rotation is in the @@ -1348,10 +1337,10 @@ impl bevy::math::Quat { /// # Panics /// Will panic if `from` or `to` are not normalized when `glam_assert` is enabled. fn from_rotation_arc( - from: Val, - to: Val, - ) -> Val { - let output: Val = bevy::math::Quat::from_rotation_arc( + from: Val<::glam::Vec3>, + to: Val<::glam::Vec3>, + ) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::Quat::from_rotation_arc( from.into_inner(), to.into_inner(), ) @@ -1367,10 +1356,10 @@ impl bevy::math::Quat { /// # Panics /// Will panic if `from` or `to` are not normalized when `glam_assert` is enabled. fn from_rotation_arc_2d( - from: Val, - to: Val, - ) -> Val { - let output: Val = bevy::math::Quat::from_rotation_arc_2d( + from: Val<::glam::Vec2>, + to: Val<::glam::Vec2>, + ) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::Quat::from_rotation_arc_2d( from.into_inner(), to.into_inner(), ) @@ -1386,10 +1375,10 @@ impl bevy::math::Quat { /// # Panics /// Will panic if `from` or `to` are not normalized when `glam_assert` is enabled. fn from_rotation_arc_colinear( - from: Val, - to: Val, - ) -> Val { - let output: Val = bevy::math::Quat::from_rotation_arc_colinear( + from: Val<::glam::Vec3>, + to: Val<::glam::Vec3>, + ) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::Quat::from_rotation_arc_colinear( from.into_inner(), to.into_inner(), ) @@ -1397,29 +1386,24 @@ impl bevy::math::Quat { output } /// Creates a quaternion from the `angle` (in radians) around the x axis. - fn from_rotation_x(angle: f32) -> Val { - let output: Val = bevy::math::Quat::from_rotation_x(angle) - .into(); + fn from_rotation_x(angle: f32) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::Quat::from_rotation_x(angle).into(); output } /// Creates a quaternion from the `angle` (in radians) around the y axis. - fn from_rotation_y(angle: f32) -> Val { - let output: Val = bevy::math::Quat::from_rotation_y(angle) - .into(); + fn from_rotation_y(angle: f32) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::Quat::from_rotation_y(angle).into(); output } /// Creates a quaternion from the `angle` (in radians) around the z axis. - fn from_rotation_z(angle: f32) -> Val { - let output: Val = bevy::math::Quat::from_rotation_z(angle) - .into(); + fn from_rotation_z(angle: f32) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::Quat::from_rotation_z(angle).into(); output } /// Create a quaternion that rotates `v.length()` radians around `v.normalize()`. /// `from_scaled_axis(Vec3::ZERO)` results in the identity quaternion. - fn from_scaled_axis(v: Val) -> Val { - let output: Val = bevy::math::Quat::from_scaled_axis( - v.into_inner(), - ) + fn from_scaled_axis(v: Val<::glam::Vec3>) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::Quat::from_scaled_axis(v.into_inner()) .into(); output } @@ -1427,9 +1411,8 @@ impl bevy::math::Quat { /// # Preconditions /// This function does not check if the input is normalized, it is up to the user to /// provide normalized input or to normalized the resulting quaternion. - fn from_vec4(v: Val) -> Val { - let output: Val = bevy::math::Quat::from_vec4(v.into_inner()) - .into(); + fn from_vec4(v: Val<::glam::Vec4>) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::Quat::from_vec4(v.into_inner()).into(); output } /// Creates a new rotation quaternion. @@ -1439,9 +1422,8 @@ impl bevy::math::Quat { /// # Preconditions /// This function does not check if the input is normalized, it is up to the user to /// provide normalized input or to normalized the resulting quaternion. - fn from_xyzw(x: f32, y: f32, z: f32, w: f32) -> Val { - let output: Val = bevy::math::Quat::from_xyzw(x, y, z, w) - .into(); + fn from_xyzw(x: f32, y: f32, z: f32, w: f32) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::Quat::from_xyzw(x, y, z, w).into(); output } /// Returns the inverse of a normalized quaternion. @@ -1450,48 +1432,47 @@ impl bevy::math::Quat { /// before returning the conjugate. /// # Panics /// Will panic if `self` is not normalized when `glam_assert` is enabled. - fn inverse(_self: Val) -> Val { - let output: Val = bevy::math::Quat::inverse(_self.into_inner()) - .into(); + fn inverse(_self: Val<::glam::Quat>) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::Quat::inverse(_self.into_inner()).into(); output } /// Returns `true` if, and only if, all elements are finite. /// If any element is either `NaN`, positive or negative infinity, this will return `false`. - fn is_finite(_self: Val) -> bool { - let output: bool = bevy::math::Quat::is_finite(_self.into_inner()).into(); + fn is_finite(_self: Val<::glam::Quat>) -> bool { + let output: bool = ::glam::Quat::is_finite(_self.into_inner()).into(); output } /// Returns `true` if any elements are `NAN`. - fn is_nan(_self: Val) -> bool { - let output: bool = bevy::math::Quat::is_nan(_self.into_inner()).into(); + fn is_nan(_self: Val<::glam::Quat>) -> bool { + let output: bool = ::glam::Quat::is_nan(_self.into_inner()).into(); output } - fn is_near_identity(_self: Val) -> bool { - let output: bool = bevy::math::Quat::is_near_identity(_self.into_inner()).into(); + fn is_near_identity(_self: Val<::glam::Quat>) -> bool { + let output: bool = ::glam::Quat::is_near_identity(_self.into_inner()).into(); output } /// Returns whether `self` of length `1.0` or not. /// Uses a precision threshold of `1e-6`. - fn is_normalized(_self: Val) -> bool { - let output: bool = bevy::math::Quat::is_normalized(_self.into_inner()).into(); + fn is_normalized(_self: Val<::glam::Quat>) -> bool { + let output: bool = ::glam::Quat::is_normalized(_self.into_inner()).into(); output } /// Computes the length of `self`. - fn length(_self: Val) -> f32 { - let output: f32 = bevy::math::Quat::length(_self.into_inner()).into(); + fn length(_self: Val<::glam::Quat>) -> f32 { + let output: f32 = ::glam::Quat::length(_self.into_inner()).into(); output } /// Computes `1.0 / length()`. /// For valid results, `self` must _not_ be of length zero. - fn length_recip(_self: Val) -> f32 { - let output: f32 = bevy::math::Quat::length_recip(_self.into_inner()).into(); + fn length_recip(_self: Val<::glam::Quat>) -> f32 { + let output: f32 = ::glam::Quat::length_recip(_self.into_inner()).into(); output } /// Computes the squared length of `self`. /// This is generally faster than `length()` as it avoids a square /// root operation. - fn length_squared(_self: Val) -> f32 { - let output: f32 = bevy::math::Quat::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::Quat>) -> f32 { + let output: f32 = ::glam::Quat::length_squared(_self.into_inner()).into(); output } /// Performs a linear interpolation between `self` and `rhs` based on @@ -1501,11 +1482,11 @@ impl bevy::math::Quat { /// # Panics /// Will panic if `self` or `end` are not normalized when `glam_assert` is enabled. fn lerp( - _self: Val, - end: Val, + _self: Val<::glam::Quat>, + end: Val<::glam::Quat>, s: f32, - ) -> Val { - let output: Val = bevy::math::Quat::lerp( + ) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::Quat::lerp( _self.into_inner(), end.into_inner(), s, @@ -1519,12 +1500,9 @@ impl bevy::math::Quat { /// normalized. /// # Panics /// Will panic if `self` or `rhs` are not normalized when `glam_assert` is enabled. - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Quat>) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Mul< + ::glam::Quat, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output @@ -1532,30 +1510,24 @@ impl bevy::math::Quat { /// Multiplies a quaternion and a 3D vector, returning the rotated vector. /// # Panics /// Will panic if `self` is not normalized when `glam_assert` is enabled. - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = <::glam::Quat as ::core::ops::Mul< + ::glam::Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = <::glam::Quat as ::core::ops::Mul< + ::glam::Vec3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } /// Multiplies a quaternion by a scalar value. /// The product is not guaranteed to be normalized. - fn mul(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -1566,11 +1538,8 @@ impl bevy::math::Quat { /// Note that due to floating point rounding the result may not be perfectly normalized. /// # Panics /// Will panic if `self` or `rhs` are not normalized when `glam_assert` is enabled. - fn mul_quat( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Quat::mul_quat( + fn mul_quat(_self: Val<::glam::Quat>, rhs: Val<::glam::Quat>) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::Quat::mul_quat( _self.into_inner(), rhs.into_inner(), ) @@ -1580,11 +1549,8 @@ impl bevy::math::Quat { /// Multiplies a quaternion and a 3D vector, returning the rotated vector. /// # Panics /// Will panic if `self` is not normalized when `glam_assert` is enabled. - fn mul_vec3( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Quat::mul_vec3( + fn mul_vec3(_self: Val<::glam::Quat>, rhs: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Quat::mul_vec3( _self.into_inner(), rhs.into_inner(), ) @@ -1593,18 +1559,18 @@ impl bevy::math::Quat { } /// Multiplies a quaternion and a 3D vector, returning the rotated vector. fn mul_vec3a( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Quat::mul_vec3a( + _self: Val<::glam::Quat>, + rhs: Val<::glam::Vec3A>, + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Quat::mul_vec3a( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::Quat>) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -1614,10 +1580,8 @@ impl bevy::math::Quat { /// For valid results, `self` must _not_ be of length zero. /// Panics /// Will panic if `self` is zero length when `glam_assert` is enabled. - fn normalize(_self: Val) -> Val { - let output: Val = bevy::math::Quat::normalize( - _self.into_inner(), - ) + fn normalize(_self: Val<::glam::Quat>) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::Quat::normalize(_self.into_inner()) .into(); output } @@ -1629,11 +1593,11 @@ impl bevy::math::Quat { /// # Panics /// Will panic if `self` or `rhs` are not normalized when `glam_assert` is enabled. fn rotate_towards( - _self: Ref, - rhs: Val, + _self: Ref<::glam::Quat>, + rhs: Val<::glam::Quat>, max_angle: f32, - ) -> Val { - let output: Val = bevy::math::Quat::rotate_towards( + ) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::Quat::rotate_towards( &_self, rhs.into_inner(), max_angle, @@ -1648,11 +1612,11 @@ impl bevy::math::Quat { /// # Panics /// Will panic if `self` or `end` are not normalized when `glam_assert` is enabled. fn slerp( - _self: Val, - end: Val, + _self: Val<::glam::Quat>, + end: Val<::glam::Quat>, s: f32, - ) -> Val { - let output: Val = bevy::math::Quat::slerp( + ) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::Quat::slerp( _self.into_inner(), end.into_inner(), s, @@ -1662,27 +1626,24 @@ impl bevy::math::Quat { } /// Subtracts the `rhs` quaternion from `self`. /// The difference is not guaranteed to be normalized. - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Quat>) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = <::glam::Quat as ::core::ops::Sub< + ::glam::Quat, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } /// `[x, y, z, w]` - fn to_array(_self: Ref) -> [f32; 4] { - let output: [f32; 4] = bevy::math::Quat::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::Quat>) -> [f32; 4] { + let output: [f32; 4] = ::glam::Quat::to_array(&_self).into(); output } /// Returns the rotation angles for the given euler rotation sequence. fn to_euler( - _self: Val, - order: Val, + _self: Val<::glam::Quat>, + order: Val<::glam::EulerRot>, ) -> (f32, f32, f32) { - let output: (f32, f32, f32) = bevy::math::Quat::to_euler( + let output: (f32, f32, f32) = ::glam::Quat::to_euler( _self.into_inner(), order.into_inner(), ) @@ -1690,17 +1651,14 @@ impl bevy::math::Quat { output } /// Returns the rotation axis scaled by the rotation in radians. - fn to_scaled_axis(_self: Val) -> Val { - let output: Val = bevy::math::Quat::to_scaled_axis( - _self.into_inner(), - ) + fn to_scaled_axis(_self: Val<::glam::Quat>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Quat::to_scaled_axis(_self.into_inner()) .into(); output } /// Returns the vector part of the quaternion. - fn xyz(_self: Val) -> Val { - let output: Val = bevy::math::Quat::xyz(_self.into_inner()) - .into(); + fn xyz(_self: Val<::glam::Quat>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Quat::xyz(_self.into_inner()).into(); output } } @@ -1710,11 +1668,10 @@ impl bevy::math::Quat { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::Vec3 { +impl ::glam::Vec3 { /// Returns a vector containing the absolute value of each element of `self`. - fn abs(_self: Val) -> Val { - let output: Val = bevy::math::Vec3::abs(_self.into_inner()) - .into(); + fn abs(_self: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::abs(_self.into_inner()).into(); output } /// Returns true if the absolute difference of all elements between `self` and `rhs` is @@ -1725,11 +1682,11 @@ impl bevy::math::Vec3 { /// For more see /// [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/). fn abs_diff_eq( - _self: Val, - rhs: Val, + _self: Val<::glam::Vec3>, + rhs: Val<::glam::Vec3>, max_abs_diff: f32, ) -> bool { - let output: bool = bevy::math::Vec3::abs_diff_eq( + let output: bool = ::glam::Vec3::abs_diff_eq( _self.into_inner(), rhs.into_inner(), max_abs_diff, @@ -1737,28 +1694,22 @@ impl bevy::math::Vec3 { .into(); output } - fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Add< + &::glam::Vec3, >>::add(_self.into_inner(), &rhs) .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Add< + ::glam::Vec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Add< f32, >>::add(_self.into_inner(), rhs) .into(); @@ -1766,8 +1717,8 @@ impl bevy::math::Vec3 { } /// Returns the angle (in radians) between two vectors in the range `[0, +π]`. /// The inputs do not need to be unit vectors however they must be non-zero. - fn angle_between(_self: Val, rhs: Val) -> f32 { - let output: f32 = bevy::math::Vec3::angle_between( + fn angle_between(_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>) -> f32 { + let output: f32 = ::glam::Vec3::angle_between( _self.into_inner(), rhs.into_inner(), ) @@ -1778,10 +1729,8 @@ impl bevy::math::Vec3 { /// The input vector must be finite and non-zero. /// The output vector is not necessarily unit length. For that use /// [`Self::any_orthonormal_vector()`] instead. - fn any_orthogonal_vector(_self: Ref) -> Val { - let output: Val = bevy::math::Vec3::any_orthogonal_vector( - &_self, - ) + fn any_orthogonal_vector(_self: Ref<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::any_orthogonal_vector(&_self) .into(); output } @@ -1789,67 +1738,60 @@ impl bevy::math::Vec3 { /// The input vector must be unit length. /// # Panics /// Will panic if `self` is not normalized when `glam_assert` is enabled. - fn any_orthonormal_vector(_self: Ref) -> Val { - let output: Val = bevy::math::Vec3::any_orthonormal_vector( - &_self, - ) + fn any_orthonormal_vector(_self: Ref<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::any_orthonormal_vector(&_self) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec3(_self: Ref) -> Val { - let output: Val = bevy::math::Vec3::as_dvec3(&_self).into(); + fn as_dvec3(_self: Ref<::glam::Vec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::Vec3::as_dvec3(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec3(_self: Ref) -> Val { - let output: Val = bevy::math::Vec3::as_i16vec3(&_self) - .into(); + fn as_i16vec3(_self: Ref<::glam::Vec3>) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::Vec3::as_i16vec3(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec3(_self: Ref) -> Val { - let output: Val = bevy::math::Vec3::as_i64vec3(&_self) - .into(); + fn as_i64vec3(_self: Ref<::glam::Vec3>) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::Vec3::as_i64vec3(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec3(_self: Ref) -> Val { - let output: Val = bevy::math::Vec3::as_i8vec3(&_self).into(); + fn as_i8vec3(_self: Ref<::glam::Vec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::Vec3::as_i8vec3(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec3(_self: Ref) -> Val { - let output: Val = bevy::math::Vec3::as_ivec3(&_self).into(); + fn as_ivec3(_self: Ref<::glam::Vec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::Vec3::as_ivec3(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec3(_self: Ref) -> Val { - let output: Val = bevy::math::Vec3::as_u16vec3(&_self) - .into(); + fn as_u16vec3(_self: Ref<::glam::Vec3>) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::Vec3::as_u16vec3(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec3(_self: Ref) -> Val { - let output: Val = bevy::math::Vec3::as_u64vec3(&_self) - .into(); + fn as_u64vec3(_self: Ref<::glam::Vec3>) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::Vec3::as_u64vec3(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec3(_self: Ref) -> Val { - let output: Val = bevy::math::Vec3::as_u8vec3(&_self).into(); + fn as_u8vec3(_self: Ref<::glam::Vec3>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::Vec3::as_u8vec3(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec3(_self: Ref) -> Val { - let output: Val = bevy::math::Vec3::as_uvec3(&_self).into(); + fn as_uvec3(_self: Ref<::glam::Vec3>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::Vec3::as_uvec3(&_self).into(); output } /// Returns a vector containing the smallest integer greater than or equal to a number for /// each element of `self`. - fn ceil(_self: Val) -> Val { - let output: Val = bevy::math::Vec3::ceil(_self.into_inner()) - .into(); + fn ceil(_self: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::ceil(_self.into_inner()).into(); output } /// Component-wise clamping of values, similar to [`f32::clamp`]. @@ -1857,11 +1799,11 @@ impl bevy::math::Vec3 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::Vec3::clamp( + _self: Val<::glam::Vec3>, + min: Val<::glam::Vec3>, + max: Val<::glam::Vec3>, + ) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -1872,12 +1814,8 @@ impl bevy::math::Vec3 { /// Returns a vector with a length no less than `min` and no more than `max`. /// # Panics /// Will panic if `min` is greater than `max`, or if either `min` or `max` is negative, when `glam_assert` is enabled. - fn clamp_length( - _self: Val, - min: f32, - max: f32, - ) -> Val { - let output: Val = bevy::math::Vec3::clamp_length( + fn clamp_length(_self: Val<::glam::Vec3>, min: f32, max: f32) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::clamp_length( _self.into_inner(), min, max, @@ -1888,11 +1826,8 @@ impl bevy::math::Vec3 { /// Returns a vector with a length no more than `max`. /// # Panics /// Will panic if `max` is negative when `glam_assert` is enabled. - fn clamp_length_max( - _self: Val, - max: f32, - ) -> Val { - let output: Val = bevy::math::Vec3::clamp_length_max( + fn clamp_length_max(_self: Val<::glam::Vec3>, max: f32) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::clamp_length_max( _self.into_inner(), max, ) @@ -1902,19 +1837,16 @@ impl bevy::math::Vec3 { /// Returns a vector with a length no less than `min`. /// # Panics /// Will panic if `min` is negative when `glam_assert` is enabled. - fn clamp_length_min( - _self: Val, - min: f32, - ) -> Val { - let output: Val = bevy::math::Vec3::clamp_length_min( + fn clamp_length_min(_self: Val<::glam::Vec3>, min: f32) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::clamp_length_min( _self.into_inner(), min, ) .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -1924,11 +1856,8 @@ impl bevy::math::Vec3 { /// `self` and `rhs`. /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. - fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3::cmpeq( + fn cmpeq(_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::Vec3::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -1939,11 +1868,8 @@ impl bevy::math::Vec3 { /// `self` and `rhs`. /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. - fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3::cmpge( + fn cmpge(_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::Vec3::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -1954,11 +1880,8 @@ impl bevy::math::Vec3 { /// `self` and `rhs`. /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. - fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3::cmpgt( + fn cmpgt(_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::Vec3::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -1969,11 +1892,8 @@ impl bevy::math::Vec3 { /// `self` and `rhs`. /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. - fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3::cmple( + fn cmple(_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::Vec3::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -1984,11 +1904,8 @@ impl bevy::math::Vec3 { /// `self` and `rhs`. /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. - fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3::cmplt( + fn cmplt(_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::Vec3::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -1999,11 +1916,8 @@ impl bevy::math::Vec3 { /// `self` and `rhs`. /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. - fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3::cmpne( + fn cmpne(_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::Vec3::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -2011,11 +1925,8 @@ impl bevy::math::Vec3 { output } /// Returns a vector with signs of `rhs` and the magnitudes of `self`. - fn copysign( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3::copysign( + fn copysign(_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::copysign( _self.into_inner(), rhs.into_inner(), ) @@ -2023,11 +1934,8 @@ impl bevy::math::Vec3 { output } /// Computes the cross product of `self` and `rhs`. - fn cross( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3::cross( + fn cross(_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::cross( _self.into_inner(), rhs.into_inner(), ) @@ -2035,48 +1943,36 @@ impl bevy::math::Vec3 { output } /// Computes the Euclidean distance between two points in space. - fn distance(_self: Val, rhs: Val) -> f32 { - let output: f32 = bevy::math::Vec3::distance( - _self.into_inner(), - rhs.into_inner(), - ) + fn distance(_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>) -> f32 { + let output: f32 = ::glam::Vec3::distance(_self.into_inner(), rhs.into_inner()) .into(); output } /// Compute the squared euclidean distance between two points in space. - fn distance_squared( - _self: Val, - rhs: Val, - ) -> f32 { - let output: f32 = bevy::math::Vec3::distance_squared( + fn distance_squared(_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>) -> f32 { + let output: f32 = ::glam::Vec3::distance_squared( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Div< + &::glam::Vec3, >>::div(_self.into_inner(), &rhs) .into(); output } - fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Div< + ::glam::Vec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -2084,10 +1980,10 @@ impl bevy::math::Vec3 { } /// Returns the element-wise quotient of [Euclidean division] of `self` by `rhs`. fn div_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3::div_euclid( + _self: Val<::glam::Vec3>, + rhs: Val<::glam::Vec3>, + ) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -2095,17 +1991,16 @@ impl bevy::math::Vec3 { output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> f32 { - let output: f32 = bevy::math::Vec3::dot(_self.into_inner(), rhs.into_inner()) - .into(); + fn dot(_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>) -> f32 { + let output: f32 = ::glam::Vec3::dot(_self.into_inner(), rhs.into_inner()).into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3::dot_into_vec( + _self: Val<::glam::Vec3>, + rhs: Val<::glam::Vec3>, + ) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -2114,129 +2009,116 @@ impl bevy::math::Vec3 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec3::element_product(_self.into_inner()).into(); + fn element_product(_self: Val<::glam::Vec3>) -> f32 { + let output: f32 = ::glam::Vec3::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec3::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::Vec3>) -> f32 { + let output: f32 = ::glam::Vec3::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::Vec3>) -> bool { + let output: bool = <::glam::Vec3 as ::core::cmp::PartialEq< + ::glam::Vec3, >>::eq(&_self, &other) .into(); output } /// Returns a vector containing `e^self` (the exponential function) for each element of /// `self`. - fn exp(_self: Val) -> Val { - let output: Val = bevy::math::Vec3::exp(_self.into_inner()) - .into(); + fn exp(_self: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::exp(_self.into_inner()).into(); output } /// Creates a 4D vector from `self` and the given `w` value. - fn extend(_self: Val, w: f32) -> Val { - let output: Val = bevy::math::Vec3::extend( - _self.into_inner(), - w, - ) + fn extend(_self: Val<::glam::Vec3>, w: f32) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec3::extend(_self.into_inner(), w) .into(); output } /// Returns a vector containing the largest integer less than or equal to a number for each /// element of `self`. - fn floor(_self: Val) -> Val { - let output: Val = bevy::math::Vec3::floor(_self.into_inner()) - .into(); + fn floor(_self: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::floor(_self.into_inner()).into(); output } /// Returns a vector containing the fractional part of the vector as `self - self.trunc()`. /// Note that this differs from the GLSL implementation of `fract` which returns /// `self - self.floor()`. /// Note that this is fast but not precise for large numbers. - fn fract(_self: Val) -> Val { - let output: Val = bevy::math::Vec3::fract(_self.into_inner()) - .into(); + fn fract(_self: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::fract(_self.into_inner()).into(); output } /// Returns a vector containing the fractional part of the vector as `self - self.floor()`. /// Note that this differs from the Rust implementation of `fract` which returns /// `self - self.trunc()`. /// Note that this is fast but not precise for large numbers. - fn fract_gl(_self: Val) -> Val { - let output: Val = bevy::math::Vec3::fract_gl( - _self.into_inner(), - ) + fn fract_gl(_self: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::fract_gl(_self.into_inner()) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [f32; 3]) -> Val { - let output: Val = bevy::math::Vec3::from_array(a).into(); + fn from_array(a: [f32; 3]) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::from_array(a).into(); output } /// Returns `true` if, and only if, all elements are finite. If any element is either /// `NaN`, positive or negative infinity, this will return `false`. - fn is_finite(_self: Val) -> bool { - let output: bool = bevy::math::Vec3::is_finite(_self.into_inner()).into(); + fn is_finite(_self: Val<::glam::Vec3>) -> bool { + let output: bool = ::glam::Vec3::is_finite(_self.into_inner()).into(); output } /// Performs `is_finite` on each element of self, returning a vector mask of the results. /// In other words, this computes `[x.is_finite(), y.is_finite(), ...]`. - fn is_finite_mask(_self: Val) -> Val { - let output: Val = bevy::math::Vec3::is_finite_mask( - _self.into_inner(), - ) + fn is_finite_mask(_self: Val<::glam::Vec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::Vec3::is_finite_mask(_self.into_inner()) .into(); output } /// Returns `true` if any elements are `NaN`. - fn is_nan(_self: Val) -> bool { - let output: bool = bevy::math::Vec3::is_nan(_self.into_inner()).into(); + fn is_nan(_self: Val<::glam::Vec3>) -> bool { + let output: bool = ::glam::Vec3::is_nan(_self.into_inner()).into(); output } /// Performs `is_nan` on each element of self, returning a vector mask of the results. /// In other words, this computes `[x.is_nan(), y.is_nan(), ...]`. - fn is_nan_mask(_self: Val) -> Val { - let output: Val = bevy::math::Vec3::is_nan_mask( - _self.into_inner(), - ) + fn is_nan_mask(_self: Val<::glam::Vec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::Vec3::is_nan_mask(_self.into_inner()) .into(); output } /// Returns a bitmask with the lowest 3 bits set to the sign bits from the elements of `self`. /// A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn is_negative_bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::Vec3::is_negative_bitmask(_self.into_inner()) - .into(); + fn is_negative_bitmask(_self: Val<::glam::Vec3>) -> u32 { + let output: u32 = ::glam::Vec3::is_negative_bitmask(_self.into_inner()).into(); output } /// Returns whether `self` is length `1.0` or not. /// Uses a precision threshold of approximately `1e-4`. - fn is_normalized(_self: Val) -> bool { - let output: bool = bevy::math::Vec3::is_normalized(_self.into_inner()).into(); + fn is_normalized(_self: Val<::glam::Vec3>) -> bool { + let output: bool = ::glam::Vec3::is_normalized(_self.into_inner()).into(); output } /// Computes the length of `self`. - fn length(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec3::length(_self.into_inner()).into(); + fn length(_self: Val<::glam::Vec3>) -> f32 { + let output: f32 = ::glam::Vec3::length(_self.into_inner()).into(); output } /// Computes `1.0 / length()`. /// For valid results, `self` must _not_ be of length zero. - fn length_recip(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec3::length_recip(_self.into_inner()).into(); + fn length_recip(_self: Val<::glam::Vec3>) -> f32 { + let output: f32 = ::glam::Vec3::length_recip(_self.into_inner()).into(); output } /// Computes the squared length of `self`. /// This is faster than `length()` as it avoids a square root operation. - fn length_squared(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec3::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::Vec3>) -> f32 { + let output: f32 = ::glam::Vec3::length_squared(_self.into_inner()).into(); output } /// Performs a linear interpolation between `self` and `rhs` based on the value `s`. @@ -2244,11 +2126,11 @@ impl bevy::math::Vec3 { /// will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly /// extrapolated. fn lerp( - _self: Val, - rhs: Val, + _self: Val<::glam::Vec3>, + rhs: Val<::glam::Vec3>, s: f32, - ) -> Val { - let output: Val = bevy::math::Vec3::lerp( + ) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::lerp( _self.into_inner(), rhs.into_inner(), s, @@ -2258,11 +2140,8 @@ impl bevy::math::Vec3 { } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. - fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3::max( + fn max(_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::max( _self.into_inner(), rhs.into_inner(), ) @@ -2271,19 +2150,16 @@ impl bevy::math::Vec3 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec3::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::Vec3>) -> f32 { + let output: f32 = ::glam::Vec3::max_element(_self.into_inner()).into(); output } /// Calculates the midpoint between `self` and `rhs`. /// The midpoint is the average of, or halfway point between, two vectors. /// `a.midpoint(b)` should yield the same result as `a.lerp(b, 0.5)` /// while being slightly cheaper to compute. - fn midpoint( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3::midpoint( + fn midpoint(_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::midpoint( _self.into_inner(), rhs.into_inner(), ) @@ -2292,11 +2168,8 @@ impl bevy::math::Vec3 { } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. - fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3::min( + fn min(_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::min( _self.into_inner(), rhs.into_inner(), ) @@ -2305,19 +2178,19 @@ impl bevy::math::Vec3 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec3::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::Vec3>) -> f32 { + let output: f32 = ::glam::Vec3::min_element(_self.into_inner()).into(); output } /// Moves towards `rhs` based on the value `d`. /// When `d` is `0.0`, the result will be equal to `self`. When `d` is equal to /// `self.distance(rhs)`, the result will be equal to `rhs`. Will not go past `rhs`. fn move_towards( - _self: Ref, - rhs: Val, + _self: Ref<::glam::Vec3>, + rhs: Val<::glam::Vec3>, d: f32, - ) -> Val { - let output: Val = bevy::math::Vec3::move_towards( + ) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::move_towards( &_self, rhs.into_inner(), d, @@ -2325,28 +2198,22 @@ impl bevy::math::Vec3 { .into(); output } - fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Mul< + &::glam::Vec3, >>::mul(_self.into_inner(), &rhs) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Mul< + ::glam::Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -2359,11 +2226,11 @@ impl bevy::math::Vec3 { /// and will be heavily dependant on designing algorithms with specific target hardware in /// mind. fn mul_add( - _self: Val, - a: Val, - b: Val, - ) -> Val { - let output: Val = bevy::math::Vec3::mul_add( + _self: Val<::glam::Vec3>, + a: Val<::glam::Vec3>, + b: Val<::glam::Vec3>, + ) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::mul_add( _self.into_inner(), a.into_inner(), b.into_inner(), @@ -2371,16 +2238,16 @@ impl bevy::math::Vec3 { .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); output } /// Creates a new vector. - fn new(x: f32, y: f32, z: f32) -> Val { - let output: Val = bevy::math::Vec3::new(x, y, z).into(); + fn new(x: f32, y: f32, z: f32) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::new(x, y, z).into(); output } /// Returns `self` normalized to length 1.0. @@ -2388,10 +2255,8 @@ impl bevy::math::Vec3 { /// See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`]. /// Panics /// Will panic if the resulting normalized vector is not finite when `glam_assert` is enabled. - fn normalize(_self: Val) -> Val { - let output: Val = bevy::math::Vec3::normalize( - _self.into_inner(), - ) + fn normalize(_self: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::normalize(_self.into_inner()) .into(); output } @@ -2401,10 +2266,10 @@ impl bevy::math::Vec3 { /// the result of this operation will be the fallback value. /// See also [`Self::try_normalize()`]. fn normalize_or( - _self: Val, - fallback: Val, - ) -> Val { - let output: Val = bevy::math::Vec3::normalize_or( + _self: Val<::glam::Vec3>, + fallback: Val<::glam::Vec3>, + ) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::normalize_or( _self.into_inner(), fallback.into_inner(), ) @@ -2415,17 +2280,16 @@ impl bevy::math::Vec3 { /// In particular, if the input is zero (or very close to zero), or non-finite, /// the result of this operation will be zero. /// See also [`Self::try_normalize()`]. - fn normalize_or_zero(_self: Val) -> Val { - let output: Val = bevy::math::Vec3::normalize_or_zero( + fn normalize_or_zero(_self: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::normalize_or_zero( _self.into_inner(), ) .into(); output } /// Returns a vector containing each element of `self` raised to the power of `n`. - fn powf(_self: Val, n: f32) -> Val { - let output: Val = bevy::math::Vec3::powf(_self.into_inner(), n) - .into(); + fn powf(_self: Val<::glam::Vec3>, n: f32) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::powf(_self.into_inner(), n).into(); output } /// Returns the vector projection of `self` onto `rhs`. @@ -2433,10 +2297,10 @@ impl bevy::math::Vec3 { /// # Panics /// Will panic if `rhs` is zero length when `glam_assert` is enabled. fn project_onto( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3::project_onto( + _self: Val<::glam::Vec3>, + rhs: Val<::glam::Vec3>, + ) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::project_onto( _self.into_inner(), rhs.into_inner(), ) @@ -2448,10 +2312,10 @@ impl bevy::math::Vec3 { /// # Panics /// Will panic if `rhs` is not normalized when `glam_assert` is enabled. fn project_onto_normalized( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3::project_onto_normalized( + _self: Val<::glam::Vec3>, + rhs: Val<::glam::Vec3>, + ) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::project_onto_normalized( _self.into_inner(), rhs.into_inner(), ) @@ -2459,9 +2323,8 @@ impl bevy::math::Vec3 { output } /// Returns a vector containing the reciprocal `1.0/n` of each element of `self`. - fn recip(_self: Val) -> Val { - let output: Val = bevy::math::Vec3::recip(_self.into_inner()) - .into(); + fn recip(_self: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::recip(_self.into_inner()).into(); output } /// Returns the reflection vector for a given incident vector `self` and surface normal @@ -2470,10 +2333,10 @@ impl bevy::math::Vec3 { /// # Panics /// Will panic if `normal` is not normalized when `glam_assert` is enabled. fn reflect( - _self: Val, - normal: Val, - ) -> Val { - let output: Val = bevy::math::Vec3::reflect( + _self: Val<::glam::Vec3>, + normal: Val<::glam::Vec3>, + ) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::reflect( _self.into_inner(), normal.into_inner(), ) @@ -2487,11 +2350,11 @@ impl bevy::math::Vec3 { /// # Panics /// Will panic if `self` or `normal` is not normalized when `glam_assert` is enabled. fn refract( - _self: Val, - normal: Val, + _self: Val<::glam::Vec3>, + normal: Val<::glam::Vec3>, eta: f32, - ) -> Val { - let output: Val = bevy::math::Vec3::refract( + ) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::refract( _self.into_inner(), normal.into_inner(), eta, @@ -2506,10 +2369,10 @@ impl bevy::math::Vec3 { /// # Panics /// Will panic if `rhs` has a length of zero when `glam_assert` is enabled. fn reject_from( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3::reject_from( + _self: Val<::glam::Vec3>, + rhs: Val<::glam::Vec3>, + ) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::reject_from( _self.into_inner(), rhs.into_inner(), ) @@ -2523,38 +2386,32 @@ impl bevy::math::Vec3 { /// # Panics /// Will panic if `rhs` is not normalized when `glam_assert` is enabled. fn reject_from_normalized( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3::reject_from_normalized( + _self: Val<::glam::Vec3>, + rhs: Val<::glam::Vec3>, + ) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::reject_from_normalized( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Rem< + &::glam::Vec3, >>::rem(_self.into_inner(), &rhs) .into(); output } - fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Rem< + ::glam::Vec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Rem< f32, >>::rem(_self.into_inner(), rhs) .into(); @@ -2563,10 +2420,10 @@ impl bevy::math::Vec3 { /// Returns the element-wise remainder of [Euclidean division] of `self` by `rhs`. /// [Euclidean division]: f32::rem_euclid fn rem_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3::rem_euclid( + _self: Val<::glam::Vec3>, + rhs: Val<::glam::Vec3>, + ) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::rem_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -2575,9 +2432,8 @@ impl bevy::math::Vec3 { } /// Returns a vector containing the nearest integer to a number for each element of `self`. /// Round half-way cases away from 0.0. - fn round(_self: Val) -> Val { - let output: Val = bevy::math::Vec3::round(_self.into_inner()) - .into(); + fn round(_self: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::round(_self.into_inner()).into(); output } /// Creates a vector from the elements in `if_true` and `if_false`, selecting which to use @@ -2585,11 +2441,11 @@ impl bevy::math::Vec3 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::Vec3::select( + mask: Val<::glam::BVec3>, + if_true: Val<::glam::Vec3>, + if_false: Val<::glam::Vec3>, + ) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -2601,88 +2457,69 @@ impl bevy::math::Vec3 { /// - `1.0` if the number is positive, `+0.0` or `INFINITY` /// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY` /// - `NAN` if the number is `NAN` - fn signum(_self: Val) -> Val { - let output: Val = bevy::math::Vec3::signum(_self.into_inner()) - .into(); + fn signum(_self: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::signum(_self.into_inner()).into(); output } /// Creates a vector with all elements set to `v`. - fn splat(v: f32) -> Val { - let output: Val = bevy::math::Vec3::splat(v).into(); + fn splat(v: f32) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::splat(v).into(); output } - fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Sub< + &::glam::Vec3, >>::sub(_self.into_inner(), &rhs) .into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Sub< + ::glam::Vec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = <::glam::Vec3 as ::core::ops::Sub< f32, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y, z]` - fn to_array(_self: Ref) -> [f32; 3] { - let output: [f32; 3] = bevy::math::Vec3::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::Vec3>) -> [f32; 3] { + let output: [f32; 3] = ::glam::Vec3::to_array(&_self).into(); output } /// Returns a vector containing the integer part each element of `self`. This means numbers are /// always truncated towards zero. - fn trunc(_self: Val) -> Val { - let output: Val = bevy::math::Vec3::trunc(_self.into_inner()) - .into(); + fn trunc(_self: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::trunc(_self.into_inner()).into(); output } /// Creates a 2D vector from the `x` and `y` elements of `self`, discarding `z`. /// Truncation may also be performed by using [`self.xy()`][crate::swizzles::Vec3Swizzles::xy()]. - fn truncate(_self: Val) -> Val { - let output: Val = bevy::math::Vec3::truncate( - _self.into_inner(), - ) + fn truncate(_self: Val<::glam::Vec3>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec3::truncate(_self.into_inner()) .into(); output } /// Creates a 3D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: f32) -> Val { - let output: Val = bevy::math::Vec3::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::Vec3>, x: f32) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::with_x(_self.into_inner(), x) .into(); output } /// Creates a 3D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: f32) -> Val { - let output: Val = bevy::math::Vec3::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::Vec3>, y: f32) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::with_y(_self.into_inner(), y) .into(); output } /// Creates a 3D vector from `self` with the given value of `z`. - fn with_z(_self: Val, z: f32) -> Val { - let output: Val = bevy::math::Vec3::with_z( - _self.into_inner(), - z, - ) + fn with_z(_self: Val<::glam::Vec3>, z: f32) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec3::with_z(_self.into_inner(), z) .into(); output } @@ -2702,7 +2539,7 @@ impl ::core::net::SocketAddr { output } fn clone(_self: Ref<::core::net::SocketAddr>) -> Val<::core::net::SocketAddr> { - let output: Val<::core::net::SocketAddr> = <::core::net::SocketAddr as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone( + let output: Val<::core::net::SocketAddr> = <::core::net::SocketAddr as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -2778,93 +2615,80 @@ impl ::core::net::SocketAddr { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::IVec2 { +impl ::glam::IVec2 { /// Returns a vector containing the absolute value of each element of `self`. - fn abs(_self: Val) -> Val { - let output: Val = bevy::math::IVec2::abs(_self.into_inner()) - .into(); + fn abs(_self: Val<::glam::IVec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::abs(_self.into_inner()).into(); output } - fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::IVec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Add< + &::glam::IVec2, >>::add(_self.into_inner(), &rhs) .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::IVec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Add< + ::glam::IVec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: i32) -> Val { - let output: Val = , rhs: i32) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Add< i32, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec2(_self: Ref) -> Val { - let output: Val = bevy::math::IVec2::as_dvec2(&_self).into(); + fn as_dvec2(_self: Ref<::glam::IVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::IVec2::as_dvec2(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec2(_self: Ref) -> Val { - let output: Val = bevy::math::IVec2::as_i16vec2(&_self) - .into(); + fn as_i16vec2(_self: Ref<::glam::IVec2>) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::IVec2::as_i16vec2(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec2(_self: Ref) -> Val { - let output: Val = bevy::math::IVec2::as_i64vec2(&_self) - .into(); + fn as_i64vec2(_self: Ref<::glam::IVec2>) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::IVec2::as_i64vec2(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec2(_self: Ref) -> Val { - let output: Val = bevy::math::IVec2::as_i8vec2(&_self) - .into(); + fn as_i8vec2(_self: Ref<::glam::IVec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::IVec2::as_i8vec2(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec2(_self: Ref) -> Val { - let output: Val = bevy::math::IVec2::as_u16vec2(&_self) - .into(); + fn as_u16vec2(_self: Ref<::glam::IVec2>) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::IVec2::as_u16vec2(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec2(_self: Ref) -> Val { - let output: Val = bevy::math::IVec2::as_u64vec2(&_self) - .into(); + fn as_u64vec2(_self: Ref<::glam::IVec2>) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::IVec2::as_u64vec2(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec2(_self: Ref) -> Val { - let output: Val = bevy::math::IVec2::as_u8vec2(&_self) - .into(); + fn as_u8vec2(_self: Ref<::glam::IVec2>) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::IVec2::as_u8vec2(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec2(_self: Ref) -> Val { - let output: Val = bevy::math::IVec2::as_uvec2(&_self).into(); + fn as_uvec2(_self: Ref<::glam::IVec2>) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::IVec2::as_uvec2(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec2(_self: Ref) -> Val { - let output: Val = bevy::math::IVec2::as_vec2(&_self).into(); + fn as_vec2(_self: Ref<::glam::IVec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::IVec2::as_vec2(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::IVec2>) -> () { + let output: () = <::glam::IVec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -2875,11 +2699,11 @@ impl bevy::math::IVec2 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::clamp( + _self: Val<::glam::IVec2>, + min: Val<::glam::IVec2>, + max: Val<::glam::IVec2>, + ) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -2887,8 +2711,8 @@ impl bevy::math::IVec2 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::IVec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -2898,11 +2722,8 @@ impl bevy::math::IVec2 { /// `self` and `rhs`. /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. - fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::cmpeq( + fn cmpeq(_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::IVec2::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -2913,11 +2734,8 @@ impl bevy::math::IVec2 { /// `self` and `rhs`. /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. - fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::cmpge( + fn cmpge(_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::IVec2::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -2928,11 +2746,8 @@ impl bevy::math::IVec2 { /// `self` and `rhs`. /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. - fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::cmpgt( + fn cmpgt(_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::IVec2::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -2943,11 +2758,8 @@ impl bevy::math::IVec2 { /// `self` and `rhs`. /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. - fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::cmple( + fn cmple(_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::IVec2::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -2958,11 +2770,8 @@ impl bevy::math::IVec2 { /// `self` and `rhs`. /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. - fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::cmplt( + fn cmplt(_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::IVec2::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -2973,11 +2782,8 @@ impl bevy::math::IVec2 { /// `self` and `rhs`. /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. - fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::cmpne( + fn cmpne(_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::IVec2::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -2985,39 +2791,30 @@ impl bevy::math::IVec2 { output } /// Compute the squared euclidean distance between two points in space. - fn distance_squared( - _self: Val, - rhs: Val, - ) -> i32 { - let output: i32 = bevy::math::IVec2::distance_squared( + fn distance_squared(_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>) -> i32 { + let output: i32 = ::glam::IVec2::distance_squared( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::IVec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Div< + &::glam::IVec2, >>::div(_self.into_inner(), &rhs) .into(); output } - fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::IVec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Div< + ::glam::IVec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: i32) -> Val { - let output: Val = , rhs: i32) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Div< i32, >>::div(_self.into_inner(), rhs) .into(); @@ -3027,10 +2824,10 @@ impl bevy::math::IVec2 { /// # Panics /// This function will panic if any `rhs` element is 0 or the division results in overflow. fn div_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::div_euclid( + _self: Val<::glam::IVec2>, + rhs: Val<::glam::IVec2>, + ) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -3038,17 +2835,17 @@ impl bevy::math::IVec2 { output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> i32 { - let output: i32 = bevy::math::IVec2::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>) -> i32 { + let output: i32 = ::glam::IVec2::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::dot_into_vec( + _self: Val<::glam::IVec2>, + rhs: Val<::glam::IVec2>, + ) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -3057,57 +2854,50 @@ impl bevy::math::IVec2 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> i32 { - let output: i32 = bevy::math::IVec2::element_product(_self.into_inner()).into(); + fn element_product(_self: Val<::glam::IVec2>) -> i32 { + let output: i32 = ::glam::IVec2::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> i32 { - let output: i32 = bevy::math::IVec2::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::IVec2>) -> i32 { + let output: i32 = ::glam::IVec2::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::IVec2>) -> bool { + let output: bool = <::glam::IVec2 as ::core::cmp::PartialEq< + ::glam::IVec2, >>::eq(&_self, &other) .into(); output } /// Creates a 3D vector from `self` and the given `z` value. - fn extend(_self: Val, z: i32) -> Val { - let output: Val = bevy::math::IVec2::extend( - _self.into_inner(), - z, - ) + fn extend(_self: Val<::glam::IVec2>, z: i32) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec2::extend(_self.into_inner(), z) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [i32; 2]) -> Val { - let output: Val = bevy::math::IVec2::from_array(a).into(); + fn from_array(a: [i32; 2]) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::from_array(a).into(); output } /// Returns a bitmask with the lowest 2 bits set to the sign bits from the elements of `self`. /// A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn is_negative_bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::IVec2::is_negative_bitmask(_self.into_inner()) - .into(); + fn is_negative_bitmask(_self: Val<::glam::IVec2>) -> u32 { + let output: u32 = ::glam::IVec2::is_negative_bitmask(_self.into_inner()).into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> i32 { - let output: i32 = bevy::math::IVec2::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::IVec2>) -> i32 { + let output: i32 = ::glam::IVec2::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. - fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::max( + fn max(_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::max( _self.into_inner(), rhs.into_inner(), ) @@ -3116,17 +2906,14 @@ impl bevy::math::IVec2 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> i32 { - let output: i32 = bevy::math::IVec2::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::IVec2>) -> i32 { + let output: i32 = ::glam::IVec2::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. - fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::min( + fn min(_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::min( _self.into_inner(), rhs.into_inner(), ) @@ -3135,87 +2922,71 @@ impl bevy::math::IVec2 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> i32 { - let output: i32 = bevy::math::IVec2::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::IVec2>) -> i32 { + let output: i32 = ::glam::IVec2::min_element(_self.into_inner()).into(); output } - fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::IVec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Mul< + &::glam::IVec2, >>::mul(_self.into_inner(), &rhs) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::IVec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Mul< + ::glam::IVec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: i32) -> Val { - let output: Val = , rhs: i32) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Mul< i32, >>::mul(_self.into_inner(), rhs) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::IVec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); output } /// Creates a new vector. - fn new(x: i32, y: i32) -> Val { - let output: Val = bevy::math::IVec2::new(x, y).into(); + fn new(x: i32, y: i32) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::new(x, y).into(); output } /// Returns a vector that is equal to `self` rotated by 90 degrees. - fn perp(_self: Val) -> Val { - let output: Val = bevy::math::IVec2::perp(_self.into_inner()) - .into(); + fn perp(_self: Val<::glam::IVec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::perp(_self.into_inner()).into(); output } /// The perpendicular dot product of `self` and `rhs`. /// Also known as the wedge product, 2D cross product, and determinant. - fn perp_dot(_self: Val, rhs: Val) -> i32 { - let output: i32 = bevy::math::IVec2::perp_dot( - _self.into_inner(), - rhs.into_inner(), - ) + fn perp_dot(_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>) -> i32 { + let output: i32 = ::glam::IVec2::perp_dot(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::IVec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Rem< + &::glam::IVec2, >>::rem(_self.into_inner(), &rhs) .into(); output } - fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::IVec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Rem< + ::glam::IVec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: i32) -> Val { - let output: Val = , rhs: i32) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Rem< i32, >>::rem(_self.into_inner(), rhs) .into(); @@ -3226,10 +2997,10 @@ impl bevy::math::IVec2 { /// This function will panic if any `rhs` element is 0 or the division results in overflow. /// [Euclidean division]: i32::rem_euclid fn rem_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::rem_euclid( + _self: Val<::glam::IVec2>, + rhs: Val<::glam::IVec2>, + ) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::rem_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -3239,11 +3010,8 @@ impl bevy::math::IVec2 { /// Returns `rhs` rotated by the angle of `self`. If `self` is normalized, /// then this just rotation. This is what you usually want. Otherwise, /// it will be like a rotation with a multiplication by `self`'s length. - fn rotate( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::rotate( + fn rotate(_self: Val<::glam::IVec2>, rhs: Val<::glam::IVec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::rotate( _self.into_inner(), rhs.into_inner(), ) @@ -3253,10 +3021,10 @@ impl bevy::math::IVec2 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::saturating_add( + _self: Val<::glam::IVec2>, + rhs: Val<::glam::IVec2>, + ) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -3265,10 +3033,10 @@ impl bevy::math::IVec2 { } /// In other words this computes `[self.x.saturating_add_unsigned(rhs.x), self.y.saturating_add_unsigned(rhs.y), ..]`. fn saturating_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::saturating_add_unsigned( + _self: Val<::glam::IVec2>, + rhs: Val<::glam::UVec2>, + ) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::saturating_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -3278,10 +3046,10 @@ impl bevy::math::IVec2 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::saturating_div( + _self: Val<::glam::IVec2>, + rhs: Val<::glam::IVec2>, + ) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -3291,10 +3059,10 @@ impl bevy::math::IVec2 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::saturating_mul( + _self: Val<::glam::IVec2>, + rhs: Val<::glam::IVec2>, + ) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -3304,10 +3072,10 @@ impl bevy::math::IVec2 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::saturating_sub( + _self: Val<::glam::IVec2>, + rhs: Val<::glam::IVec2>, + ) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -3317,10 +3085,10 @@ impl bevy::math::IVec2 { /// Returns a vector containing the saturating subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.saturating_sub_unsigned(rhs.x), self.y.saturating_sub_unsigned(rhs.y), ..]`. fn saturating_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::saturating_sub_unsigned( + _self: Val<::glam::IVec2>, + rhs: Val<::glam::UVec2>, + ) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::saturating_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -3332,11 +3100,11 @@ impl bevy::math::IVec2 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::select( + mask: Val<::glam::BVec2>, + if_true: Val<::glam::IVec2>, + if_false: Val<::glam::IVec2>, + ) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -3348,75 +3116,61 @@ impl bevy::math::IVec2 { /// - `0` if the number is zero /// - `1` if the number is positive /// - `-1` if the number is negative - fn signum(_self: Val) -> Val { - let output: Val = bevy::math::IVec2::signum( - _self.into_inner(), - ) + fn signum(_self: Val<::glam::IVec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::signum(_self.into_inner()) .into(); output } /// Creates a vector with all elements set to `v`. - fn splat(v: i32) -> Val { - let output: Val = bevy::math::IVec2::splat(v).into(); + fn splat(v: i32) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::splat(v).into(); output } - fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::IVec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Sub< + &::glam::IVec2, >>::sub(_self.into_inner(), &rhs) .into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::IVec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Sub< + ::glam::IVec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: i32) -> Val { - let output: Val = , rhs: i32) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = <::glam::IVec2 as ::core::ops::Sub< i32, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y]` - fn to_array(_self: Ref) -> [i32; 2] { - let output: [i32; 2] = bevy::math::IVec2::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::IVec2>) -> [i32; 2] { + let output: [i32; 2] = ::glam::IVec2::to_array(&_self).into(); output } /// Creates a 2D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: i32) -> Val { - let output: Val = bevy::math::IVec2::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::IVec2>, x: i32) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::with_x(_self.into_inner(), x) .into(); output } /// Creates a 2D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: i32) -> Val { - let output: Val = bevy::math::IVec2::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::IVec2>, y: i32) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::with_y(_self.into_inner(), y) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::wrapping_add( + _self: Val<::glam::IVec2>, + rhs: Val<::glam::IVec2>, + ) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -3426,10 +3180,10 @@ impl bevy::math::IVec2 { /// Returns a vector containing the wrapping addition of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_add_unsigned(rhs.x), self.y.wrapping_add_unsigned(rhs.y), ..]`. fn wrapping_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::wrapping_add_unsigned( + _self: Val<::glam::IVec2>, + rhs: Val<::glam::UVec2>, + ) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::wrapping_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -3439,10 +3193,10 @@ impl bevy::math::IVec2 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::wrapping_div( + _self: Val<::glam::IVec2>, + rhs: Val<::glam::IVec2>, + ) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -3452,10 +3206,10 @@ impl bevy::math::IVec2 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::wrapping_mul( + _self: Val<::glam::IVec2>, + rhs: Val<::glam::IVec2>, + ) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -3465,10 +3219,10 @@ impl bevy::math::IVec2 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::wrapping_sub( + _self: Val<::glam::IVec2>, + rhs: Val<::glam::IVec2>, + ) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -3478,10 +3232,10 @@ impl bevy::math::IVec2 { /// Returns a vector containing the wrapping subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_sub_unsigned(rhs.x), self.y.wrapping_sub_unsigned(rhs.y), ..]`. fn wrapping_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec2::wrapping_sub_unsigned( + _self: Val<::glam::IVec2>, + rhs: Val<::glam::UVec2>, + ) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec2::wrapping_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -3495,98 +3249,85 @@ impl bevy::math::IVec2 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::IVec3 { +impl ::glam::IVec3 { /// Returns a vector containing the absolute value of each element of `self`. - fn abs(_self: Val) -> Val { - let output: Val = bevy::math::IVec3::abs(_self.into_inner()) - .into(); + fn abs(_self: Val<::glam::IVec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::abs(_self.into_inner()).into(); output } - fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::IVec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Add< + &::glam::IVec3, >>::add(_self.into_inner(), &rhs) .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::IVec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Add< + ::glam::IVec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: i32) -> Val { - let output: Val = , rhs: i32) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Add< i32, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec3(_self: Ref) -> Val { - let output: Val = bevy::math::IVec3::as_dvec3(&_self).into(); + fn as_dvec3(_self: Ref<::glam::IVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::IVec3::as_dvec3(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec3(_self: Ref) -> Val { - let output: Val = bevy::math::IVec3::as_i16vec3(&_self) - .into(); + fn as_i16vec3(_self: Ref<::glam::IVec3>) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::IVec3::as_i16vec3(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec3(_self: Ref) -> Val { - let output: Val = bevy::math::IVec3::as_i64vec3(&_self) - .into(); + fn as_i64vec3(_self: Ref<::glam::IVec3>) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::IVec3::as_i64vec3(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec3(_self: Ref) -> Val { - let output: Val = bevy::math::IVec3::as_i8vec3(&_self) - .into(); + fn as_i8vec3(_self: Ref<::glam::IVec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::IVec3::as_i8vec3(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec3(_self: Ref) -> Val { - let output: Val = bevy::math::IVec3::as_u16vec3(&_self) - .into(); + fn as_u16vec3(_self: Ref<::glam::IVec3>) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::IVec3::as_u16vec3(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec3(_self: Ref) -> Val { - let output: Val = bevy::math::IVec3::as_u64vec3(&_self) - .into(); + fn as_u64vec3(_self: Ref<::glam::IVec3>) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::IVec3::as_u64vec3(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec3(_self: Ref) -> Val { - let output: Val = bevy::math::IVec3::as_u8vec3(&_self) - .into(); + fn as_u8vec3(_self: Ref<::glam::IVec3>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::IVec3::as_u8vec3(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec3(_self: Ref) -> Val { - let output: Val = bevy::math::IVec3::as_uvec3(&_self).into(); + fn as_uvec3(_self: Ref<::glam::IVec3>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::IVec3::as_uvec3(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec3(_self: Ref) -> Val { - let output: Val = bevy::math::IVec3::as_vec3(&_self).into(); + fn as_vec3(_self: Ref<::glam::IVec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::IVec3::as_vec3(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec3a(_self: Ref) -> Val { - let output: Val = bevy::math::IVec3::as_vec3a(&_self).into(); + fn as_vec3a(_self: Ref<::glam::IVec3>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::IVec3::as_vec3a(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::IVec3>) -> () { + let output: () = <::glam::IVec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -3597,11 +3338,11 @@ impl bevy::math::IVec3 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::clamp( + _self: Val<::glam::IVec3>, + min: Val<::glam::IVec3>, + max: Val<::glam::IVec3>, + ) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -3609,8 +3350,8 @@ impl bevy::math::IVec3 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::IVec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -3620,11 +3361,8 @@ impl bevy::math::IVec3 { /// `self` and `rhs`. /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. - fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::cmpeq( + fn cmpeq(_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::IVec3::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -3635,11 +3373,8 @@ impl bevy::math::IVec3 { /// `self` and `rhs`. /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. - fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::cmpge( + fn cmpge(_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::IVec3::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -3650,11 +3385,8 @@ impl bevy::math::IVec3 { /// `self` and `rhs`. /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. - fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::cmpgt( + fn cmpgt(_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::IVec3::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -3665,11 +3397,8 @@ impl bevy::math::IVec3 { /// `self` and `rhs`. /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. - fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::cmple( + fn cmple(_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::IVec3::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -3680,11 +3409,8 @@ impl bevy::math::IVec3 { /// `self` and `rhs`. /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. - fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::cmplt( + fn cmplt(_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::IVec3::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -3695,11 +3421,8 @@ impl bevy::math::IVec3 { /// `self` and `rhs`. /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. - fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::cmpne( + fn cmpne(_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::IVec3::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -3707,11 +3430,8 @@ impl bevy::math::IVec3 { output } /// Computes the cross product of `self` and `rhs`. - fn cross( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::cross( + fn cross(_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::cross( _self.into_inner(), rhs.into_inner(), ) @@ -3719,39 +3439,30 @@ impl bevy::math::IVec3 { output } /// Compute the squared euclidean distance between two points in space. - fn distance_squared( - _self: Val, - rhs: Val, - ) -> i32 { - let output: i32 = bevy::math::IVec3::distance_squared( + fn distance_squared(_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>) -> i32 { + let output: i32 = ::glam::IVec3::distance_squared( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::IVec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Div< + &::glam::IVec3, >>::div(_self.into_inner(), &rhs) .into(); output } - fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::IVec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Div< + ::glam::IVec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: i32) -> Val { - let output: Val = , rhs: i32) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Div< i32, >>::div(_self.into_inner(), rhs) .into(); @@ -3761,10 +3472,10 @@ impl bevy::math::IVec3 { /// # Panics /// This function will panic if any `rhs` element is 0 or the division results in overflow. fn div_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::div_euclid( + _self: Val<::glam::IVec3>, + rhs: Val<::glam::IVec3>, + ) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -3772,17 +3483,17 @@ impl bevy::math::IVec3 { output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> i32 { - let output: i32 = bevy::math::IVec3::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>) -> i32 { + let output: i32 = ::glam::IVec3::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::dot_into_vec( + _self: Val<::glam::IVec3>, + rhs: Val<::glam::IVec3>, + ) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -3791,57 +3502,50 @@ impl bevy::math::IVec3 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> i32 { - let output: i32 = bevy::math::IVec3::element_product(_self.into_inner()).into(); + fn element_product(_self: Val<::glam::IVec3>) -> i32 { + let output: i32 = ::glam::IVec3::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> i32 { - let output: i32 = bevy::math::IVec3::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::IVec3>) -> i32 { + let output: i32 = ::glam::IVec3::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::IVec3>) -> bool { + let output: bool = <::glam::IVec3 as ::core::cmp::PartialEq< + ::glam::IVec3, >>::eq(&_self, &other) .into(); output } /// Creates a 4D vector from `self` and the given `w` value. - fn extend(_self: Val, w: i32) -> Val { - let output: Val = bevy::math::IVec3::extend( - _self.into_inner(), - w, - ) + fn extend(_self: Val<::glam::IVec3>, w: i32) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec3::extend(_self.into_inner(), w) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [i32; 3]) -> Val { - let output: Val = bevy::math::IVec3::from_array(a).into(); + fn from_array(a: [i32; 3]) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::from_array(a).into(); output } /// Returns a bitmask with the lowest 3 bits set to the sign bits from the elements of `self`. /// A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn is_negative_bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::IVec3::is_negative_bitmask(_self.into_inner()) - .into(); + fn is_negative_bitmask(_self: Val<::glam::IVec3>) -> u32 { + let output: u32 = ::glam::IVec3::is_negative_bitmask(_self.into_inner()).into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> i32 { - let output: i32 = bevy::math::IVec3::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::IVec3>) -> i32 { + let output: i32 = ::glam::IVec3::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. - fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::max( + fn max(_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::max( _self.into_inner(), rhs.into_inner(), ) @@ -3850,17 +3554,14 @@ impl bevy::math::IVec3 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> i32 { - let output: i32 = bevy::math::IVec3::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::IVec3>) -> i32 { + let output: i32 = ::glam::IVec3::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. - fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::min( + fn min(_self: Val<::glam::IVec3>, rhs: Val<::glam::IVec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::min( _self.into_inner(), rhs.into_inner(), ) @@ -3869,71 +3570,59 @@ impl bevy::math::IVec3 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> i32 { - let output: i32 = bevy::math::IVec3::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::IVec3>) -> i32 { + let output: i32 = ::glam::IVec3::min_element(_self.into_inner()).into(); output } - fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::IVec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Mul< + &::glam::IVec3, >>::mul(_self.into_inner(), &rhs) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::IVec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Mul< + ::glam::IVec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: i32) -> Val { - let output: Val = , rhs: i32) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Mul< i32, >>::mul(_self.into_inner(), rhs) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::IVec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); output } /// Creates a new vector. - fn new(x: i32, y: i32, z: i32) -> Val { - let output: Val = bevy::math::IVec3::new(x, y, z).into(); + fn new(x: i32, y: i32, z: i32) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::new(x, y, z).into(); output } - fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::IVec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Rem< + &::glam::IVec3, >>::rem(_self.into_inner(), &rhs) .into(); output } - fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::IVec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Rem< + ::glam::IVec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: i32) -> Val { - let output: Val = , rhs: i32) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Rem< i32, >>::rem(_self.into_inner(), rhs) .into(); @@ -3944,10 +3633,10 @@ impl bevy::math::IVec3 { /// This function will panic if any `rhs` element is 0 or the division results in overflow. /// [Euclidean division]: i32::rem_euclid fn rem_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::rem_euclid( + _self: Val<::glam::IVec3>, + rhs: Val<::glam::IVec3>, + ) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::rem_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -3957,10 +3646,10 @@ impl bevy::math::IVec3 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::saturating_add( + _self: Val<::glam::IVec3>, + rhs: Val<::glam::IVec3>, + ) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -3969,10 +3658,10 @@ impl bevy::math::IVec3 { } /// In other words this computes `[self.x.saturating_add_unsigned(rhs.x), self.y.saturating_add_unsigned(rhs.y), ..]`. fn saturating_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::saturating_add_unsigned( + _self: Val<::glam::IVec3>, + rhs: Val<::glam::UVec3>, + ) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::saturating_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -3982,10 +3671,10 @@ impl bevy::math::IVec3 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::saturating_div( + _self: Val<::glam::IVec3>, + rhs: Val<::glam::IVec3>, + ) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -3995,10 +3684,10 @@ impl bevy::math::IVec3 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::saturating_mul( + _self: Val<::glam::IVec3>, + rhs: Val<::glam::IVec3>, + ) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -4008,10 +3697,10 @@ impl bevy::math::IVec3 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::saturating_sub( + _self: Val<::glam::IVec3>, + rhs: Val<::glam::IVec3>, + ) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -4021,10 +3710,10 @@ impl bevy::math::IVec3 { /// Returns a vector containing the saturating subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.saturating_sub_unsigned(rhs.x), self.y.saturating_sub_unsigned(rhs.y), ..]`. fn saturating_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::saturating_sub_unsigned( + _self: Val<::glam::IVec3>, + rhs: Val<::glam::UVec3>, + ) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::saturating_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -4036,11 +3725,11 @@ impl bevy::math::IVec3 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::select( + mask: Val<::glam::BVec3>, + if_true: Val<::glam::IVec3>, + if_false: Val<::glam::IVec3>, + ) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -4052,93 +3741,74 @@ impl bevy::math::IVec3 { /// - `0` if the number is zero /// - `1` if the number is positive /// - `-1` if the number is negative - fn signum(_self: Val) -> Val { - let output: Val = bevy::math::IVec3::signum( - _self.into_inner(), - ) + fn signum(_self: Val<::glam::IVec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::signum(_self.into_inner()) .into(); output } /// Creates a vector with all elements set to `v`. - fn splat(v: i32) -> Val { - let output: Val = bevy::math::IVec3::splat(v).into(); + fn splat(v: i32) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::splat(v).into(); output } - fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::IVec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Sub< + &::glam::IVec3, >>::sub(_self.into_inner(), &rhs) .into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::IVec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Sub< + ::glam::IVec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: i32) -> Val { - let output: Val = , rhs: i32) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = <::glam::IVec3 as ::core::ops::Sub< i32, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y, z]` - fn to_array(_self: Ref) -> [i32; 3] { - let output: [i32; 3] = bevy::math::IVec3::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::IVec3>) -> [i32; 3] { + let output: [i32; 3] = ::glam::IVec3::to_array(&_self).into(); output } /// Creates a 2D vector from the `x` and `y` elements of `self`, discarding `z`. /// Truncation may also be performed by using [`self.xy()`][crate::swizzles::Vec3Swizzles::xy()]. - fn truncate(_self: Val) -> Val { - let output: Val = bevy::math::IVec3::truncate( - _self.into_inner(), - ) + fn truncate(_self: Val<::glam::IVec3>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::IVec3::truncate(_self.into_inner()) .into(); output } /// Creates a 3D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: i32) -> Val { - let output: Val = bevy::math::IVec3::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::IVec3>, x: i32) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::with_x(_self.into_inner(), x) .into(); output } /// Creates a 3D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: i32) -> Val { - let output: Val = bevy::math::IVec3::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::IVec3>, y: i32) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::with_y(_self.into_inner(), y) .into(); output } /// Creates a 3D vector from `self` with the given value of `z`. - fn with_z(_self: Val, z: i32) -> Val { - let output: Val = bevy::math::IVec3::with_z( - _self.into_inner(), - z, - ) + fn with_z(_self: Val<::glam::IVec3>, z: i32) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::with_z(_self.into_inner(), z) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::wrapping_add( + _self: Val<::glam::IVec3>, + rhs: Val<::glam::IVec3>, + ) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -4148,10 +3818,10 @@ impl bevy::math::IVec3 { /// Returns a vector containing the wrapping addition of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_add_unsigned(rhs.x), self.y.wrapping_add_unsigned(rhs.y), ..]`. fn wrapping_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::wrapping_add_unsigned( + _self: Val<::glam::IVec3>, + rhs: Val<::glam::UVec3>, + ) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::wrapping_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -4161,10 +3831,10 @@ impl bevy::math::IVec3 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::wrapping_div( + _self: Val<::glam::IVec3>, + rhs: Val<::glam::IVec3>, + ) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -4174,10 +3844,10 @@ impl bevy::math::IVec3 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::wrapping_mul( + _self: Val<::glam::IVec3>, + rhs: Val<::glam::IVec3>, + ) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -4187,10 +3857,10 @@ impl bevy::math::IVec3 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::wrapping_sub( + _self: Val<::glam::IVec3>, + rhs: Val<::glam::IVec3>, + ) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -4200,10 +3870,10 @@ impl bevy::math::IVec3 { /// Returns a vector containing the wrapping subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_sub_unsigned(rhs.x), self.y.wrapping_sub_unsigned(rhs.y), ..]`. fn wrapping_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec3::wrapping_sub_unsigned( + _self: Val<::glam::IVec3>, + rhs: Val<::glam::UVec3>, + ) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec3::wrapping_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -4217,93 +3887,80 @@ impl bevy::math::IVec3 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::IVec4 { +impl ::glam::IVec4 { /// Returns a vector containing the absolute value of each element of `self`. - fn abs(_self: Val) -> Val { - let output: Val = bevy::math::IVec4::abs(_self.into_inner()) - .into(); + fn abs(_self: Val<::glam::IVec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::abs(_self.into_inner()).into(); output } - fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::IVec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Add< + &::glam::IVec4, >>::add(_self.into_inner(), &rhs) .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::IVec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Add< + ::glam::IVec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: i32) -> Val { - let output: Val = , rhs: i32) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Add< i32, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec4(_self: Ref) -> Val { - let output: Val = bevy::math::IVec4::as_dvec4(&_self).into(); + fn as_dvec4(_self: Ref<::glam::IVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::IVec4::as_dvec4(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec4(_self: Ref) -> Val { - let output: Val = bevy::math::IVec4::as_i16vec4(&_self) - .into(); + fn as_i16vec4(_self: Ref<::glam::IVec4>) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::IVec4::as_i16vec4(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec4(_self: Ref) -> Val { - let output: Val = bevy::math::IVec4::as_i64vec4(&_self) - .into(); + fn as_i64vec4(_self: Ref<::glam::IVec4>) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::IVec4::as_i64vec4(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec4(_self: Ref) -> Val { - let output: Val = bevy::math::IVec4::as_i8vec4(&_self) - .into(); + fn as_i8vec4(_self: Ref<::glam::IVec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::IVec4::as_i8vec4(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec4(_self: Ref) -> Val { - let output: Val = bevy::math::IVec4::as_u16vec4(&_self) - .into(); + fn as_u16vec4(_self: Ref<::glam::IVec4>) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::IVec4::as_u16vec4(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec4(_self: Ref) -> Val { - let output: Val = bevy::math::IVec4::as_u64vec4(&_self) - .into(); + fn as_u64vec4(_self: Ref<::glam::IVec4>) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::IVec4::as_u64vec4(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec4(_self: Ref) -> Val { - let output: Val = bevy::math::IVec4::as_u8vec4(&_self) - .into(); + fn as_u8vec4(_self: Ref<::glam::IVec4>) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::IVec4::as_u8vec4(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec4(_self: Ref) -> Val { - let output: Val = bevy::math::IVec4::as_uvec4(&_self).into(); + fn as_uvec4(_self: Ref<::glam::IVec4>) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::IVec4::as_uvec4(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec4(_self: Ref) -> Val { - let output: Val = bevy::math::IVec4::as_vec4(&_self).into(); + fn as_vec4(_self: Ref<::glam::IVec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::IVec4::as_vec4(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::IVec4>) -> () { + let output: () = <::glam::IVec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -4314,11 +3971,11 @@ impl bevy::math::IVec4 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::clamp( + _self: Val<::glam::IVec4>, + min: Val<::glam::IVec4>, + max: Val<::glam::IVec4>, + ) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -4326,8 +3983,8 @@ impl bevy::math::IVec4 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::IVec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -4337,11 +3994,8 @@ impl bevy::math::IVec4 { /// `self` and `rhs`. /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. - fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::cmpeq( + fn cmpeq(_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::IVec4::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -4352,11 +4006,8 @@ impl bevy::math::IVec4 { /// `self` and `rhs`. /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. - fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::cmpge( + fn cmpge(_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::IVec4::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -4367,11 +4018,8 @@ impl bevy::math::IVec4 { /// `self` and `rhs`. /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. - fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::cmpgt( + fn cmpgt(_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::IVec4::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -4382,11 +4030,8 @@ impl bevy::math::IVec4 { /// `self` and `rhs`. /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. - fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::cmple( + fn cmple(_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::IVec4::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -4397,11 +4042,8 @@ impl bevy::math::IVec4 { /// `self` and `rhs`. /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. - fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::cmplt( + fn cmplt(_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::IVec4::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -4412,11 +4054,8 @@ impl bevy::math::IVec4 { /// `self` and `rhs`. /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. - fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::cmpne( + fn cmpne(_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::IVec4::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -4424,39 +4063,30 @@ impl bevy::math::IVec4 { output } /// Compute the squared euclidean distance between two points in space. - fn distance_squared( - _self: Val, - rhs: Val, - ) -> i32 { - let output: i32 = bevy::math::IVec4::distance_squared( + fn distance_squared(_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>) -> i32 { + let output: i32 = ::glam::IVec4::distance_squared( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::IVec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Div< + &::glam::IVec4, >>::div(_self.into_inner(), &rhs) .into(); output } - fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::IVec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Div< + ::glam::IVec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: i32) -> Val { - let output: Val = , rhs: i32) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Div< i32, >>::div(_self.into_inner(), rhs) .into(); @@ -4466,10 +4096,10 @@ impl bevy::math::IVec4 { /// # Panics /// This function will panic if any `rhs` element is 0 or the division results in overflow. fn div_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::div_euclid( + _self: Val<::glam::IVec4>, + rhs: Val<::glam::IVec4>, + ) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -4477,17 +4107,17 @@ impl bevy::math::IVec4 { output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> i32 { - let output: i32 = bevy::math::IVec4::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>) -> i32 { + let output: i32 = ::glam::IVec4::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::dot_into_vec( + _self: Val<::glam::IVec4>, + rhs: Val<::glam::IVec4>, + ) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -4496,48 +4126,44 @@ impl bevy::math::IVec4 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> i32 { - let output: i32 = bevy::math::IVec4::element_product(_self.into_inner()).into(); + fn element_product(_self: Val<::glam::IVec4>) -> i32 { + let output: i32 = ::glam::IVec4::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> i32 { - let output: i32 = bevy::math::IVec4::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::IVec4>) -> i32 { + let output: i32 = ::glam::IVec4::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::IVec4>) -> bool { + let output: bool = <::glam::IVec4 as ::core::cmp::PartialEq< + ::glam::IVec4, >>::eq(&_self, &other) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [i32; 4]) -> Val { - let output: Val = bevy::math::IVec4::from_array(a).into(); + fn from_array(a: [i32; 4]) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::from_array(a).into(); output } /// Returns a bitmask with the lowest 4 bits set to the sign bits from the elements of `self`. /// A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn is_negative_bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::IVec4::is_negative_bitmask(_self.into_inner()) - .into(); + fn is_negative_bitmask(_self: Val<::glam::IVec4>) -> u32 { + let output: u32 = ::glam::IVec4::is_negative_bitmask(_self.into_inner()).into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> i32 { - let output: i32 = bevy::math::IVec4::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::IVec4>) -> i32 { + let output: i32 = ::glam::IVec4::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. - fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::max( + fn max(_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::max( _self.into_inner(), rhs.into_inner(), ) @@ -4546,17 +4172,14 @@ impl bevy::math::IVec4 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> i32 { - let output: i32 = bevy::math::IVec4::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::IVec4>) -> i32 { + let output: i32 = ::glam::IVec4::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. - fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::min( + fn min(_self: Val<::glam::IVec4>, rhs: Val<::glam::IVec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::min( _self.into_inner(), rhs.into_inner(), ) @@ -4565,71 +4188,59 @@ impl bevy::math::IVec4 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> i32 { - let output: i32 = bevy::math::IVec4::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::IVec4>) -> i32 { + let output: i32 = ::glam::IVec4::min_element(_self.into_inner()).into(); output } - fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::IVec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Mul< + &::glam::IVec4, >>::mul(_self.into_inner(), &rhs) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::IVec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Mul< + ::glam::IVec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: i32) -> Val { - let output: Val = , rhs: i32) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Mul< i32, >>::mul(_self.into_inner(), rhs) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::IVec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); output } /// Creates a new vector. - fn new(x: i32, y: i32, z: i32, w: i32) -> Val { - let output: Val = bevy::math::IVec4::new(x, y, z, w).into(); + fn new(x: i32, y: i32, z: i32, w: i32) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::new(x, y, z, w).into(); output } - fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::IVec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Rem< + &::glam::IVec4, >>::rem(_self.into_inner(), &rhs) .into(); output } - fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::IVec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Rem< + ::glam::IVec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: i32) -> Val { - let output: Val = , rhs: i32) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Rem< i32, >>::rem(_self.into_inner(), rhs) .into(); @@ -4640,10 +4251,10 @@ impl bevy::math::IVec4 { /// This function will panic if any `rhs` element is 0 or the division results in overflow. /// [Euclidean division]: i32::rem_euclid fn rem_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::rem_euclid( + _self: Val<::glam::IVec4>, + rhs: Val<::glam::IVec4>, + ) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::rem_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -4653,10 +4264,10 @@ impl bevy::math::IVec4 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::saturating_add( + _self: Val<::glam::IVec4>, + rhs: Val<::glam::IVec4>, + ) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -4665,10 +4276,10 @@ impl bevy::math::IVec4 { } /// In other words this computes `[self.x.saturating_add_unsigned(rhs.x), self.y.saturating_add_unsigned(rhs.y), ..]`. fn saturating_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::saturating_add_unsigned( + _self: Val<::glam::IVec4>, + rhs: Val<::glam::UVec4>, + ) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::saturating_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -4678,10 +4289,10 @@ impl bevy::math::IVec4 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::saturating_div( + _self: Val<::glam::IVec4>, + rhs: Val<::glam::IVec4>, + ) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -4691,10 +4302,10 @@ impl bevy::math::IVec4 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::saturating_mul( + _self: Val<::glam::IVec4>, + rhs: Val<::glam::IVec4>, + ) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -4704,10 +4315,10 @@ impl bevy::math::IVec4 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::saturating_sub( + _self: Val<::glam::IVec4>, + rhs: Val<::glam::IVec4>, + ) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -4717,10 +4328,10 @@ impl bevy::math::IVec4 { /// Returns a vector containing the saturating subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.saturating_sub_unsigned(rhs.x), self.y.saturating_sub_unsigned(rhs.y), ..]`. fn saturating_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::saturating_sub_unsigned( + _self: Val<::glam::IVec4>, + rhs: Val<::glam::UVec4>, + ) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::saturating_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -4732,11 +4343,11 @@ impl bevy::math::IVec4 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::select( + mask: Val<::glam::BVec4>, + if_true: Val<::glam::IVec4>, + if_false: Val<::glam::IVec4>, + ) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -4748,102 +4359,80 @@ impl bevy::math::IVec4 { /// - `0` if the number is zero /// - `1` if the number is positive /// - `-1` if the number is negative - fn signum(_self: Val) -> Val { - let output: Val = bevy::math::IVec4::signum( - _self.into_inner(), - ) + fn signum(_self: Val<::glam::IVec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::signum(_self.into_inner()) .into(); output } /// Creates a vector with all elements set to `v`. - fn splat(v: i32) -> Val { - let output: Val = bevy::math::IVec4::splat(v).into(); + fn splat(v: i32) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::splat(v).into(); output } - fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::IVec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Sub< + &::glam::IVec4, >>::sub(_self.into_inner(), &rhs) .into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::IVec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Sub< + ::glam::IVec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: i32) -> Val { - let output: Val = , rhs: i32) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = <::glam::IVec4 as ::core::ops::Sub< i32, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y, z, w]` - fn to_array(_self: Ref) -> [i32; 4] { - let output: [i32; 4] = bevy::math::IVec4::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::IVec4>) -> [i32; 4] { + let output: [i32; 4] = ::glam::IVec4::to_array(&_self).into(); output } /// Creates a 3D vector from the `x`, `y` and `z` elements of `self`, discarding `w`. /// Truncation to [`IVec3`] may also be performed by using [`self.xyz()`][crate::swizzles::Vec4Swizzles::xyz()]. - fn truncate(_self: Val) -> Val { - let output: Val = bevy::math::IVec4::truncate( - _self.into_inner(), - ) + fn truncate(_self: Val<::glam::IVec4>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::IVec4::truncate(_self.into_inner()) .into(); output } /// Creates a 4D vector from `self` with the given value of `w`. - fn with_w(_self: Val, w: i32) -> Val { - let output: Val = bevy::math::IVec4::with_w( - _self.into_inner(), - w, - ) + fn with_w(_self: Val<::glam::IVec4>, w: i32) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::with_w(_self.into_inner(), w) .into(); output } /// Creates a 4D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: i32) -> Val { - let output: Val = bevy::math::IVec4::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::IVec4>, x: i32) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::with_x(_self.into_inner(), x) .into(); output } /// Creates a 4D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: i32) -> Val { - let output: Val = bevy::math::IVec4::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::IVec4>, y: i32) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::with_y(_self.into_inner(), y) .into(); output } /// Creates a 4D vector from `self` with the given value of `z`. - fn with_z(_self: Val, z: i32) -> Val { - let output: Val = bevy::math::IVec4::with_z( - _self.into_inner(), - z, - ) + fn with_z(_self: Val<::glam::IVec4>, z: i32) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::with_z(_self.into_inner(), z) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::wrapping_add( + _self: Val<::glam::IVec4>, + rhs: Val<::glam::IVec4>, + ) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -4853,10 +4442,10 @@ impl bevy::math::IVec4 { /// Returns a vector containing the wrapping addition of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_add_unsigned(rhs.x), self.y.wrapping_add_unsigned(rhs.y), ..]`. fn wrapping_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::wrapping_add_unsigned( + _self: Val<::glam::IVec4>, + rhs: Val<::glam::UVec4>, + ) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::wrapping_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -4866,10 +4455,10 @@ impl bevy::math::IVec4 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::wrapping_div( + _self: Val<::glam::IVec4>, + rhs: Val<::glam::IVec4>, + ) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -4879,10 +4468,10 @@ impl bevy::math::IVec4 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::wrapping_mul( + _self: Val<::glam::IVec4>, + rhs: Val<::glam::IVec4>, + ) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -4892,10 +4481,10 @@ impl bevy::math::IVec4 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::wrapping_sub( + _self: Val<::glam::IVec4>, + rhs: Val<::glam::IVec4>, + ) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -4905,10 +4494,10 @@ impl bevy::math::IVec4 { /// Returns a vector containing the wrapping subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_sub_unsigned(rhs.x), self.y.wrapping_sub_unsigned(rhs.y), ..]`. fn wrapping_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::IVec4::wrapping_sub_unsigned( + _self: Val<::glam::IVec4>, + rhs: Val<::glam::UVec4>, + ) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::IVec4::wrapping_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -4922,92 +4511,80 @@ impl bevy::math::IVec4 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::I8Vec2 { +impl ::glam::I8Vec2 { /// Returns a vector containing the absolute value of each element of `self`. - fn abs(_self: Val) -> Val { - let output: Val = bevy::math::I8Vec2::abs(_self.into_inner()) - .into(); + fn abs(_self: Val<::glam::I8Vec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::abs(_self.into_inner()).into(); output } - fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::I8Vec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Add< + &::glam::I8Vec2, >>::add(_self.into_inner(), &rhs) .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::I8Vec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Add< + ::glam::I8Vec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: i8) -> Val { - let output: Val = , rhs: i8) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Add< i8, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec2(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec2::as_dvec2(&_self).into(); + fn as_dvec2(_self: Ref<::glam::I8Vec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::I8Vec2::as_dvec2(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec2(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec2::as_i16vec2(&_self) - .into(); + fn as_i16vec2(_self: Ref<::glam::I8Vec2>) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I8Vec2::as_i16vec2(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec2(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec2::as_i64vec2(&_self) - .into(); + fn as_i64vec2(_self: Ref<::glam::I8Vec2>) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I8Vec2::as_i64vec2(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec2(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec2::as_ivec2(&_self).into(); + fn as_ivec2(_self: Ref<::glam::I8Vec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::I8Vec2::as_ivec2(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec2(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec2::as_u16vec2(&_self) - .into(); + fn as_u16vec2(_self: Ref<::glam::I8Vec2>) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::I8Vec2::as_u16vec2(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec2(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec2::as_u64vec2(&_self) - .into(); + fn as_u64vec2(_self: Ref<::glam::I8Vec2>) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::I8Vec2::as_u64vec2(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec2(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec2::as_u8vec2(&_self) - .into(); + fn as_u8vec2(_self: Ref<::glam::I8Vec2>) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::I8Vec2::as_u8vec2(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec2(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec2::as_uvec2(&_self).into(); + fn as_uvec2(_self: Ref<::glam::I8Vec2>) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::I8Vec2::as_uvec2(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec2(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec2::as_vec2(&_self).into(); + fn as_vec2(_self: Ref<::glam::I8Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::I8Vec2::as_vec2(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::I8Vec2>) -> () { + let output: () = <::glam::I8Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -5018,11 +4595,11 @@ impl bevy::math::I8Vec2 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::clamp( + _self: Val<::glam::I8Vec2>, + min: Val<::glam::I8Vec2>, + max: Val<::glam::I8Vec2>, + ) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -5030,8 +4607,8 @@ impl bevy::math::I8Vec2 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::I8Vec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -5042,10 +4619,10 @@ impl bevy::math::I8Vec2 { /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::cmpeq( + _self: Val<::glam::I8Vec2>, + rhs: Val<::glam::I8Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::I8Vec2::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -5057,10 +4634,10 @@ impl bevy::math::I8Vec2 { /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::cmpge( + _self: Val<::glam::I8Vec2>, + rhs: Val<::glam::I8Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::I8Vec2::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -5072,10 +4649,10 @@ impl bevy::math::I8Vec2 { /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::cmpgt( + _self: Val<::glam::I8Vec2>, + rhs: Val<::glam::I8Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::I8Vec2::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -5087,10 +4664,10 @@ impl bevy::math::I8Vec2 { /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::cmple( + _self: Val<::glam::I8Vec2>, + rhs: Val<::glam::I8Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::I8Vec2::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -5102,10 +4679,10 @@ impl bevy::math::I8Vec2 { /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::cmplt( + _self: Val<::glam::I8Vec2>, + rhs: Val<::glam::I8Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::I8Vec2::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -5117,10 +4694,10 @@ impl bevy::math::I8Vec2 { /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::cmpne( + _self: Val<::glam::I8Vec2>, + rhs: Val<::glam::I8Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::I8Vec2::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -5128,39 +4705,30 @@ impl bevy::math::I8Vec2 { output } /// Compute the squared euclidean distance between two points in space. - fn distance_squared( - _self: Val, - rhs: Val, - ) -> i8 { - let output: i8 = bevy::math::I8Vec2::distance_squared( + fn distance_squared(_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>) -> i8 { + let output: i8 = ::glam::I8Vec2::distance_squared( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::I8Vec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Div< + &::glam::I8Vec2, >>::div(_self.into_inner(), &rhs) .into(); output } - fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::I8Vec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Div< + ::glam::I8Vec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: i8) -> Val { - let output: Val = , rhs: i8) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Div< i8, >>::div(_self.into_inner(), rhs) .into(); @@ -5170,10 +4738,10 @@ impl bevy::math::I8Vec2 { /// # Panics /// This function will panic if any `rhs` element is 0 or the division results in overflow. fn div_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::div_euclid( + _self: Val<::glam::I8Vec2>, + rhs: Val<::glam::I8Vec2>, + ) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -5181,17 +4749,17 @@ impl bevy::math::I8Vec2 { output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> i8 { - let output: i8 = bevy::math::I8Vec2::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>) -> i8 { + let output: i8 = ::glam::I8Vec2::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::dot_into_vec( + _self: Val<::glam::I8Vec2>, + rhs: Val<::glam::I8Vec2>, + ) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -5200,57 +4768,50 @@ impl bevy::math::I8Vec2 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> i8 { - let output: i8 = bevy::math::I8Vec2::element_product(_self.into_inner()).into(); + fn element_product(_self: Val<::glam::I8Vec2>) -> i8 { + let output: i8 = ::glam::I8Vec2::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> i8 { - let output: i8 = bevy::math::I8Vec2::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::I8Vec2>) -> i8 { + let output: i8 = ::glam::I8Vec2::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::I8Vec2>) -> bool { + let output: bool = <::glam::I8Vec2 as ::core::cmp::PartialEq< + ::glam::I8Vec2, >>::eq(&_self, &other) .into(); output } /// Creates a 3D vector from `self` and the given `z` value. - fn extend(_self: Val, z: i8) -> Val { - let output: Val = bevy::math::I8Vec2::extend( - _self.into_inner(), - z, - ) + fn extend(_self: Val<::glam::I8Vec2>, z: i8) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec2::extend(_self.into_inner(), z) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [i8; 2]) -> Val { - let output: Val = bevy::math::I8Vec2::from_array(a).into(); + fn from_array(a: [i8; 2]) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::from_array(a).into(); output } /// Returns a bitmask with the lowest 2 bits set to the sign bits from the elements of `self`. /// A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn is_negative_bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::I8Vec2::is_negative_bitmask(_self.into_inner()) - .into(); + fn is_negative_bitmask(_self: Val<::glam::I8Vec2>) -> u32 { + let output: u32 = ::glam::I8Vec2::is_negative_bitmask(_self.into_inner()).into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> i8 { - let output: i8 = bevy::math::I8Vec2::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::I8Vec2>) -> i8 { + let output: i8 = ::glam::I8Vec2::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. - fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::max( + fn max(_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::max( _self.into_inner(), rhs.into_inner(), ) @@ -5259,17 +4820,14 @@ impl bevy::math::I8Vec2 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> i8 { - let output: i8 = bevy::math::I8Vec2::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::I8Vec2>) -> i8 { + let output: i8 = ::glam::I8Vec2::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. - fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::min( + fn min(_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::min( _self.into_inner(), rhs.into_inner(), ) @@ -5278,89 +4836,72 @@ impl bevy::math::I8Vec2 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> i8 { - let output: i8 = bevy::math::I8Vec2::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::I8Vec2>) -> i8 { + let output: i8 = ::glam::I8Vec2::min_element(_self.into_inner()).into(); output } - fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::I8Vec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Mul< + &::glam::I8Vec2, >>::mul(_self.into_inner(), &rhs) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::I8Vec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Mul< + ::glam::I8Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: i8) -> Val { - let output: Val = , rhs: i8) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Mul< i8, >>::mul(_self.into_inner(), rhs) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::I8Vec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); output } /// Creates a new vector. - fn new(x: i8, y: i8) -> Val { - let output: Val = bevy::math::I8Vec2::new(x, y).into(); + fn new(x: i8, y: i8) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::new(x, y).into(); output } /// Returns a vector that is equal to `self` rotated by 90 degrees. - fn perp(_self: Val) -> Val { - let output: Val = bevy::math::I8Vec2::perp( - _self.into_inner(), - ) + fn perp(_self: Val<::glam::I8Vec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::perp(_self.into_inner()) .into(); output } /// The perpendicular dot product of `self` and `rhs`. /// Also known as the wedge product, 2D cross product, and determinant. - fn perp_dot(_self: Val, rhs: Val) -> i8 { - let output: i8 = bevy::math::I8Vec2::perp_dot( - _self.into_inner(), - rhs.into_inner(), - ) + fn perp_dot(_self: Val<::glam::I8Vec2>, rhs: Val<::glam::I8Vec2>) -> i8 { + let output: i8 = ::glam::I8Vec2::perp_dot(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::I8Vec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Rem< + &::glam::I8Vec2, >>::rem(_self.into_inner(), &rhs) .into(); output } - fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::I8Vec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Rem< + ::glam::I8Vec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: i8) -> Val { - let output: Val = , rhs: i8) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Rem< i8, >>::rem(_self.into_inner(), rhs) .into(); @@ -5371,10 +4912,10 @@ impl bevy::math::I8Vec2 { /// This function will panic if any `rhs` element is 0 or the division results in overflow. /// [Euclidean division]: i8::rem_euclid fn rem_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::rem_euclid( + _self: Val<::glam::I8Vec2>, + rhs: Val<::glam::I8Vec2>, + ) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::rem_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -5385,10 +4926,10 @@ impl bevy::math::I8Vec2 { /// then this just rotation. This is what you usually want. Otherwise, /// it will be like a rotation with a multiplication by `self`'s length. fn rotate( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::rotate( + _self: Val<::glam::I8Vec2>, + rhs: Val<::glam::I8Vec2>, + ) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::rotate( _self.into_inner(), rhs.into_inner(), ) @@ -5398,10 +4939,10 @@ impl bevy::math::I8Vec2 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::saturating_add( + _self: Val<::glam::I8Vec2>, + rhs: Val<::glam::I8Vec2>, + ) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -5410,10 +4951,10 @@ impl bevy::math::I8Vec2 { } /// In other words this computes `[self.x.saturating_add_unsigned(rhs.x), self.y.saturating_add_unsigned(rhs.y), ..]`. fn saturating_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::saturating_add_unsigned( + _self: Val<::glam::I8Vec2>, + rhs: Val<::glam::U8Vec2>, + ) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::saturating_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -5423,10 +4964,10 @@ impl bevy::math::I8Vec2 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::saturating_div( + _self: Val<::glam::I8Vec2>, + rhs: Val<::glam::I8Vec2>, + ) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -5436,10 +4977,10 @@ impl bevy::math::I8Vec2 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::saturating_mul( + _self: Val<::glam::I8Vec2>, + rhs: Val<::glam::I8Vec2>, + ) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -5449,10 +4990,10 @@ impl bevy::math::I8Vec2 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::saturating_sub( + _self: Val<::glam::I8Vec2>, + rhs: Val<::glam::I8Vec2>, + ) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -5462,10 +5003,10 @@ impl bevy::math::I8Vec2 { /// Returns a vector containing the saturating subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.saturating_sub_unsigned(rhs.x), self.y.saturating_sub_unsigned(rhs.y), ..]`. fn saturating_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::saturating_sub_unsigned( + _self: Val<::glam::I8Vec2>, + rhs: Val<::glam::U8Vec2>, + ) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::saturating_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -5477,11 +5018,11 @@ impl bevy::math::I8Vec2 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::select( + mask: Val<::glam::BVec2>, + if_true: Val<::glam::I8Vec2>, + if_false: Val<::glam::I8Vec2>, + ) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -5493,75 +5034,61 @@ impl bevy::math::I8Vec2 { /// - `0` if the number is zero /// - `1` if the number is positive /// - `-1` if the number is negative - fn signum(_self: Val) -> Val { - let output: Val = bevy::math::I8Vec2::signum( - _self.into_inner(), - ) + fn signum(_self: Val<::glam::I8Vec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::signum(_self.into_inner()) .into(); output } /// Creates a vector with all elements set to `v`. - fn splat(v: i8) -> Val { - let output: Val = bevy::math::I8Vec2::splat(v).into(); + fn splat(v: i8) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::splat(v).into(); output } - fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::I8Vec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Sub< + &::glam::I8Vec2, >>::sub(_self.into_inner(), &rhs) .into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::I8Vec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Sub< + ::glam::I8Vec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: i8) -> Val { - let output: Val = , rhs: i8) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = <::glam::I8Vec2 as ::core::ops::Sub< i8, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y]` - fn to_array(_self: Ref) -> [i8; 2] { - let output: [i8; 2] = bevy::math::I8Vec2::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::I8Vec2>) -> [i8; 2] { + let output: [i8; 2] = ::glam::I8Vec2::to_array(&_self).into(); output } /// Creates a 2D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: i8) -> Val { - let output: Val = bevy::math::I8Vec2::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::I8Vec2>, x: i8) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::with_x(_self.into_inner(), x) .into(); output } /// Creates a 2D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: i8) -> Val { - let output: Val = bevy::math::I8Vec2::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::I8Vec2>, y: i8) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::with_y(_self.into_inner(), y) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::wrapping_add( + _self: Val<::glam::I8Vec2>, + rhs: Val<::glam::I8Vec2>, + ) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -5571,10 +5098,10 @@ impl bevy::math::I8Vec2 { /// Returns a vector containing the wrapping addition of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_add_unsigned(rhs.x), self.y.wrapping_add_unsigned(rhs.y), ..]`. fn wrapping_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::wrapping_add_unsigned( + _self: Val<::glam::I8Vec2>, + rhs: Val<::glam::U8Vec2>, + ) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::wrapping_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -5584,10 +5111,10 @@ impl bevy::math::I8Vec2 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::wrapping_div( + _self: Val<::glam::I8Vec2>, + rhs: Val<::glam::I8Vec2>, + ) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -5597,10 +5124,10 @@ impl bevy::math::I8Vec2 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::wrapping_mul( + _self: Val<::glam::I8Vec2>, + rhs: Val<::glam::I8Vec2>, + ) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -5610,10 +5137,10 @@ impl bevy::math::I8Vec2 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::wrapping_sub( + _self: Val<::glam::I8Vec2>, + rhs: Val<::glam::I8Vec2>, + ) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -5623,10 +5150,10 @@ impl bevy::math::I8Vec2 { /// Returns a vector containing the wrapping subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_sub_unsigned(rhs.x), self.y.wrapping_sub_unsigned(rhs.y), ..]`. fn wrapping_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec2::wrapping_sub_unsigned( + _self: Val<::glam::I8Vec2>, + rhs: Val<::glam::U8Vec2>, + ) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec2::wrapping_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -5640,97 +5167,85 @@ impl bevy::math::I8Vec2 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::I8Vec3 { +impl ::glam::I8Vec3 { /// Returns a vector containing the absolute value of each element of `self`. - fn abs(_self: Val) -> Val { - let output: Val = bevy::math::I8Vec3::abs(_self.into_inner()) - .into(); + fn abs(_self: Val<::glam::I8Vec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::abs(_self.into_inner()).into(); output } - fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::I8Vec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Add< + &::glam::I8Vec3, >>::add(_self.into_inner(), &rhs) .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::I8Vec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Add< + ::glam::I8Vec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: i8) -> Val { - let output: Val = , rhs: i8) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Add< i8, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec3(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec3::as_dvec3(&_self).into(); + fn as_dvec3(_self: Ref<::glam::I8Vec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::I8Vec3::as_dvec3(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec3(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec3::as_i16vec3(&_self) - .into(); + fn as_i16vec3(_self: Ref<::glam::I8Vec3>) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I8Vec3::as_i16vec3(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec3(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec3::as_i64vec3(&_self) - .into(); + fn as_i64vec3(_self: Ref<::glam::I8Vec3>) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I8Vec3::as_i64vec3(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec3(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec3::as_ivec3(&_self).into(); + fn as_ivec3(_self: Ref<::glam::I8Vec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::I8Vec3::as_ivec3(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec3(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec3::as_u16vec3(&_self) - .into(); + fn as_u16vec3(_self: Ref<::glam::I8Vec3>) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::I8Vec3::as_u16vec3(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec3(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec3::as_u64vec3(&_self) - .into(); + fn as_u64vec3(_self: Ref<::glam::I8Vec3>) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::I8Vec3::as_u64vec3(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec3(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec3::as_u8vec3(&_self) - .into(); + fn as_u8vec3(_self: Ref<::glam::I8Vec3>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::I8Vec3::as_u8vec3(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec3(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec3::as_uvec3(&_self).into(); + fn as_uvec3(_self: Ref<::glam::I8Vec3>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::I8Vec3::as_uvec3(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec3(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec3::as_vec3(&_self).into(); + fn as_vec3(_self: Ref<::glam::I8Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::I8Vec3::as_vec3(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec3a(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec3::as_vec3a(&_self).into(); + fn as_vec3a(_self: Ref<::glam::I8Vec3>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::I8Vec3::as_vec3a(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::I8Vec3>) -> () { + let output: () = <::glam::I8Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -5741,11 +5256,11 @@ impl bevy::math::I8Vec3 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::clamp( + _self: Val<::glam::I8Vec3>, + min: Val<::glam::I8Vec3>, + max: Val<::glam::I8Vec3>, + ) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -5753,8 +5268,8 @@ impl bevy::math::I8Vec3 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::I8Vec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -5765,10 +5280,10 @@ impl bevy::math::I8Vec3 { /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::cmpeq( + _self: Val<::glam::I8Vec3>, + rhs: Val<::glam::I8Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::I8Vec3::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -5780,10 +5295,10 @@ impl bevy::math::I8Vec3 { /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::cmpge( + _self: Val<::glam::I8Vec3>, + rhs: Val<::glam::I8Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::I8Vec3::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -5795,10 +5310,10 @@ impl bevy::math::I8Vec3 { /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::cmpgt( + _self: Val<::glam::I8Vec3>, + rhs: Val<::glam::I8Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::I8Vec3::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -5810,10 +5325,10 @@ impl bevy::math::I8Vec3 { /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::cmple( + _self: Val<::glam::I8Vec3>, + rhs: Val<::glam::I8Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::I8Vec3::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -5825,10 +5340,10 @@ impl bevy::math::I8Vec3 { /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::cmplt( + _self: Val<::glam::I8Vec3>, + rhs: Val<::glam::I8Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::I8Vec3::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -5840,10 +5355,10 @@ impl bevy::math::I8Vec3 { /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::cmpne( + _self: Val<::glam::I8Vec3>, + rhs: Val<::glam::I8Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::I8Vec3::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -5852,10 +5367,10 @@ impl bevy::math::I8Vec3 { } /// Computes the cross product of `self` and `rhs`. fn cross( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::cross( + _self: Val<::glam::I8Vec3>, + rhs: Val<::glam::I8Vec3>, + ) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::cross( _self.into_inner(), rhs.into_inner(), ) @@ -5863,39 +5378,30 @@ impl bevy::math::I8Vec3 { output } /// Compute the squared euclidean distance between two points in space. - fn distance_squared( - _self: Val, - rhs: Val, - ) -> i8 { - let output: i8 = bevy::math::I8Vec3::distance_squared( + fn distance_squared(_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>) -> i8 { + let output: i8 = ::glam::I8Vec3::distance_squared( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::I8Vec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Div< + &::glam::I8Vec3, >>::div(_self.into_inner(), &rhs) .into(); output } - fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::I8Vec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Div< + ::glam::I8Vec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: i8) -> Val { - let output: Val = , rhs: i8) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Div< i8, >>::div(_self.into_inner(), rhs) .into(); @@ -5905,10 +5411,10 @@ impl bevy::math::I8Vec3 { /// # Panics /// This function will panic if any `rhs` element is 0 or the division results in overflow. fn div_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::div_euclid( + _self: Val<::glam::I8Vec3>, + rhs: Val<::glam::I8Vec3>, + ) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -5916,17 +5422,17 @@ impl bevy::math::I8Vec3 { output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> i8 { - let output: i8 = bevy::math::I8Vec3::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>) -> i8 { + let output: i8 = ::glam::I8Vec3::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::dot_into_vec( + _self: Val<::glam::I8Vec3>, + rhs: Val<::glam::I8Vec3>, + ) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -5935,57 +5441,50 @@ impl bevy::math::I8Vec3 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> i8 { - let output: i8 = bevy::math::I8Vec3::element_product(_self.into_inner()).into(); + fn element_product(_self: Val<::glam::I8Vec3>) -> i8 { + let output: i8 = ::glam::I8Vec3::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> i8 { - let output: i8 = bevy::math::I8Vec3::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::I8Vec3>) -> i8 { + let output: i8 = ::glam::I8Vec3::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::I8Vec3>) -> bool { + let output: bool = <::glam::I8Vec3 as ::core::cmp::PartialEq< + ::glam::I8Vec3, >>::eq(&_self, &other) .into(); output } /// Creates a 4D vector from `self` and the given `w` value. - fn extend(_self: Val, w: i8) -> Val { - let output: Val = bevy::math::I8Vec3::extend( - _self.into_inner(), - w, - ) + fn extend(_self: Val<::glam::I8Vec3>, w: i8) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec3::extend(_self.into_inner(), w) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [i8; 3]) -> Val { - let output: Val = bevy::math::I8Vec3::from_array(a).into(); + fn from_array(a: [i8; 3]) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::from_array(a).into(); output } /// Returns a bitmask with the lowest 3 bits set to the sign bits from the elements of `self`. /// A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn is_negative_bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::I8Vec3::is_negative_bitmask(_self.into_inner()) - .into(); + fn is_negative_bitmask(_self: Val<::glam::I8Vec3>) -> u32 { + let output: u32 = ::glam::I8Vec3::is_negative_bitmask(_self.into_inner()).into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> i8 { - let output: i8 = bevy::math::I8Vec3::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::I8Vec3>) -> i8 { + let output: i8 = ::glam::I8Vec3::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. - fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::max( + fn max(_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::max( _self.into_inner(), rhs.into_inner(), ) @@ -5994,17 +5493,14 @@ impl bevy::math::I8Vec3 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> i8 { - let output: i8 = bevy::math::I8Vec3::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::I8Vec3>) -> i8 { + let output: i8 = ::glam::I8Vec3::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. - fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::min( + fn min(_self: Val<::glam::I8Vec3>, rhs: Val<::glam::I8Vec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::min( _self.into_inner(), rhs.into_inner(), ) @@ -6013,71 +5509,59 @@ impl bevy::math::I8Vec3 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> i8 { - let output: i8 = bevy::math::I8Vec3::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::I8Vec3>) -> i8 { + let output: i8 = ::glam::I8Vec3::min_element(_self.into_inner()).into(); output } - fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::I8Vec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Mul< + &::glam::I8Vec3, >>::mul(_self.into_inner(), &rhs) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::I8Vec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Mul< + ::glam::I8Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: i8) -> Val { - let output: Val = , rhs: i8) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Mul< i8, >>::mul(_self.into_inner(), rhs) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::I8Vec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); output } /// Creates a new vector. - fn new(x: i8, y: i8, z: i8) -> Val { - let output: Val = bevy::math::I8Vec3::new(x, y, z).into(); + fn new(x: i8, y: i8, z: i8) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::new(x, y, z).into(); output } - fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::I8Vec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Rem< + &::glam::I8Vec3, >>::rem(_self.into_inner(), &rhs) .into(); output } - fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::I8Vec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Rem< + ::glam::I8Vec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: i8) -> Val { - let output: Val = , rhs: i8) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Rem< i8, >>::rem(_self.into_inner(), rhs) .into(); @@ -6088,10 +5572,10 @@ impl bevy::math::I8Vec3 { /// This function will panic if any `rhs` element is 0 or the division results in overflow. /// [Euclidean division]: i8::rem_euclid fn rem_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::rem_euclid( + _self: Val<::glam::I8Vec3>, + rhs: Val<::glam::I8Vec3>, + ) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::rem_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -6101,10 +5585,10 @@ impl bevy::math::I8Vec3 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::saturating_add( + _self: Val<::glam::I8Vec3>, + rhs: Val<::glam::I8Vec3>, + ) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -6113,10 +5597,10 @@ impl bevy::math::I8Vec3 { } /// In other words this computes `[self.x.saturating_add_unsigned(rhs.x), self.y.saturating_add_unsigned(rhs.y), ..]`. fn saturating_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::saturating_add_unsigned( + _self: Val<::glam::I8Vec3>, + rhs: Val<::glam::U8Vec3>, + ) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::saturating_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -6126,10 +5610,10 @@ impl bevy::math::I8Vec3 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::saturating_div( + _self: Val<::glam::I8Vec3>, + rhs: Val<::glam::I8Vec3>, + ) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -6139,10 +5623,10 @@ impl bevy::math::I8Vec3 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::saturating_mul( + _self: Val<::glam::I8Vec3>, + rhs: Val<::glam::I8Vec3>, + ) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -6152,10 +5636,10 @@ impl bevy::math::I8Vec3 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::saturating_sub( + _self: Val<::glam::I8Vec3>, + rhs: Val<::glam::I8Vec3>, + ) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -6165,10 +5649,10 @@ impl bevy::math::I8Vec3 { /// Returns a vector containing the saturating subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.saturating_sub_unsigned(rhs.x), self.y.saturating_sub_unsigned(rhs.y), ..]`. fn saturating_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::saturating_sub_unsigned( + _self: Val<::glam::I8Vec3>, + rhs: Val<::glam::U8Vec3>, + ) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::saturating_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -6180,11 +5664,11 @@ impl bevy::math::I8Vec3 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::select( + mask: Val<::glam::BVec3>, + if_true: Val<::glam::I8Vec3>, + if_false: Val<::glam::I8Vec3>, + ) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -6196,93 +5680,74 @@ impl bevy::math::I8Vec3 { /// - `0` if the number is zero /// - `1` if the number is positive /// - `-1` if the number is negative - fn signum(_self: Val) -> Val { - let output: Val = bevy::math::I8Vec3::signum( - _self.into_inner(), - ) + fn signum(_self: Val<::glam::I8Vec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::signum(_self.into_inner()) .into(); output } /// Creates a vector with all elements set to `v`. - fn splat(v: i8) -> Val { - let output: Val = bevy::math::I8Vec3::splat(v).into(); + fn splat(v: i8) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::splat(v).into(); output } - fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::I8Vec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Sub< + &::glam::I8Vec3, >>::sub(_self.into_inner(), &rhs) .into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::I8Vec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Sub< + ::glam::I8Vec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: i8) -> Val { - let output: Val = , rhs: i8) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = <::glam::I8Vec3 as ::core::ops::Sub< i8, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y, z]` - fn to_array(_self: Ref) -> [i8; 3] { - let output: [i8; 3] = bevy::math::I8Vec3::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::I8Vec3>) -> [i8; 3] { + let output: [i8; 3] = ::glam::I8Vec3::to_array(&_self).into(); output } /// Creates a 2D vector from the `x` and `y` elements of `self`, discarding `z`. /// Truncation may also be performed by using [`self.xy()`][crate::swizzles::Vec3Swizzles::xy()]. - fn truncate(_self: Val) -> Val { - let output: Val = bevy::math::I8Vec3::truncate( - _self.into_inner(), - ) + fn truncate(_self: Val<::glam::I8Vec3>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I8Vec3::truncate(_self.into_inner()) .into(); output } /// Creates a 3D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: i8) -> Val { - let output: Val = bevy::math::I8Vec3::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::I8Vec3>, x: i8) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::with_x(_self.into_inner(), x) .into(); output } /// Creates a 3D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: i8) -> Val { - let output: Val = bevy::math::I8Vec3::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::I8Vec3>, y: i8) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::with_y(_self.into_inner(), y) .into(); output } /// Creates a 3D vector from `self` with the given value of `z`. - fn with_z(_self: Val, z: i8) -> Val { - let output: Val = bevy::math::I8Vec3::with_z( - _self.into_inner(), - z, - ) + fn with_z(_self: Val<::glam::I8Vec3>, z: i8) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::with_z(_self.into_inner(), z) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::wrapping_add( + _self: Val<::glam::I8Vec3>, + rhs: Val<::glam::I8Vec3>, + ) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -6292,10 +5757,10 @@ impl bevy::math::I8Vec3 { /// Returns a vector containing the wrapping addition of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_add_unsigned(rhs.x), self.y.wrapping_add_unsigned(rhs.y), ..]`. fn wrapping_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::wrapping_add_unsigned( + _self: Val<::glam::I8Vec3>, + rhs: Val<::glam::U8Vec3>, + ) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::wrapping_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -6305,10 +5770,10 @@ impl bevy::math::I8Vec3 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::wrapping_div( + _self: Val<::glam::I8Vec3>, + rhs: Val<::glam::I8Vec3>, + ) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -6318,10 +5783,10 @@ impl bevy::math::I8Vec3 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::wrapping_mul( + _self: Val<::glam::I8Vec3>, + rhs: Val<::glam::I8Vec3>, + ) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -6331,10 +5796,10 @@ impl bevy::math::I8Vec3 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::wrapping_sub( + _self: Val<::glam::I8Vec3>, + rhs: Val<::glam::I8Vec3>, + ) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -6344,10 +5809,10 @@ impl bevy::math::I8Vec3 { /// Returns a vector containing the wrapping subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_sub_unsigned(rhs.x), self.y.wrapping_sub_unsigned(rhs.y), ..]`. fn wrapping_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec3::wrapping_sub_unsigned( + _self: Val<::glam::I8Vec3>, + rhs: Val<::glam::U8Vec3>, + ) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec3::wrapping_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -6361,92 +5826,80 @@ impl bevy::math::I8Vec3 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::I8Vec4 { +impl ::glam::I8Vec4 { /// Returns a vector containing the absolute value of each element of `self`. - fn abs(_self: Val) -> Val { - let output: Val = bevy::math::I8Vec4::abs(_self.into_inner()) - .into(); + fn abs(_self: Val<::glam::I8Vec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::abs(_self.into_inner()).into(); output } - fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::I8Vec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Add< + &::glam::I8Vec4, >>::add(_self.into_inner(), &rhs) .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::I8Vec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Add< + ::glam::I8Vec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: i8) -> Val { - let output: Val = , rhs: i8) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Add< i8, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec4(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec4::as_dvec4(&_self).into(); + fn as_dvec4(_self: Ref<::glam::I8Vec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::I8Vec4::as_dvec4(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec4(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec4::as_i16vec4(&_self) - .into(); + fn as_i16vec4(_self: Ref<::glam::I8Vec4>) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I8Vec4::as_i16vec4(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec4(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec4::as_i64vec4(&_self) - .into(); + fn as_i64vec4(_self: Ref<::glam::I8Vec4>) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I8Vec4::as_i64vec4(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec4(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec4::as_ivec4(&_self).into(); + fn as_ivec4(_self: Ref<::glam::I8Vec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::I8Vec4::as_ivec4(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec4(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec4::as_u16vec4(&_self) - .into(); + fn as_u16vec4(_self: Ref<::glam::I8Vec4>) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::I8Vec4::as_u16vec4(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec4(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec4::as_u64vec4(&_self) - .into(); + fn as_u64vec4(_self: Ref<::glam::I8Vec4>) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::I8Vec4::as_u64vec4(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec4(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec4::as_u8vec4(&_self) - .into(); + fn as_u8vec4(_self: Ref<::glam::I8Vec4>) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::I8Vec4::as_u8vec4(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec4(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec4::as_uvec4(&_self).into(); + fn as_uvec4(_self: Ref<::glam::I8Vec4>) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::I8Vec4::as_uvec4(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec4(_self: Ref) -> Val { - let output: Val = bevy::math::I8Vec4::as_vec4(&_self).into(); + fn as_vec4(_self: Ref<::glam::I8Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::I8Vec4::as_vec4(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::I8Vec4>) -> () { + let output: () = <::glam::I8Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -6457,11 +5910,11 @@ impl bevy::math::I8Vec4 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::clamp( + _self: Val<::glam::I8Vec4>, + min: Val<::glam::I8Vec4>, + max: Val<::glam::I8Vec4>, + ) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -6469,8 +5922,8 @@ impl bevy::math::I8Vec4 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::I8Vec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -6481,10 +5934,10 @@ impl bevy::math::I8Vec4 { /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::cmpeq( + _self: Val<::glam::I8Vec4>, + rhs: Val<::glam::I8Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::I8Vec4::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -6496,10 +5949,10 @@ impl bevy::math::I8Vec4 { /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::cmpge( + _self: Val<::glam::I8Vec4>, + rhs: Val<::glam::I8Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::I8Vec4::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -6511,10 +5964,10 @@ impl bevy::math::I8Vec4 { /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::cmpgt( + _self: Val<::glam::I8Vec4>, + rhs: Val<::glam::I8Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::I8Vec4::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -6526,10 +5979,10 @@ impl bevy::math::I8Vec4 { /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::cmple( + _self: Val<::glam::I8Vec4>, + rhs: Val<::glam::I8Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::I8Vec4::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -6541,10 +5994,10 @@ impl bevy::math::I8Vec4 { /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::cmplt( + _self: Val<::glam::I8Vec4>, + rhs: Val<::glam::I8Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::I8Vec4::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -6556,10 +6009,10 @@ impl bevy::math::I8Vec4 { /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::cmpne( + _self: Val<::glam::I8Vec4>, + rhs: Val<::glam::I8Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::I8Vec4::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -6567,39 +6020,30 @@ impl bevy::math::I8Vec4 { output } /// Compute the squared euclidean distance between two points in space. - fn distance_squared( - _self: Val, - rhs: Val, - ) -> i8 { - let output: i8 = bevy::math::I8Vec4::distance_squared( + fn distance_squared(_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>) -> i8 { + let output: i8 = ::glam::I8Vec4::distance_squared( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::I8Vec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Div< + &::glam::I8Vec4, >>::div(_self.into_inner(), &rhs) .into(); output } - fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::I8Vec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Div< + ::glam::I8Vec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: i8) -> Val { - let output: Val = , rhs: i8) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Div< i8, >>::div(_self.into_inner(), rhs) .into(); @@ -6609,10 +6053,10 @@ impl bevy::math::I8Vec4 { /// # Panics /// This function will panic if any `rhs` element is 0 or the division results in overflow. fn div_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::div_euclid( + _self: Val<::glam::I8Vec4>, + rhs: Val<::glam::I8Vec4>, + ) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -6620,17 +6064,17 @@ impl bevy::math::I8Vec4 { output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> i8 { - let output: i8 = bevy::math::I8Vec4::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>) -> i8 { + let output: i8 = ::glam::I8Vec4::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::dot_into_vec( + _self: Val<::glam::I8Vec4>, + rhs: Val<::glam::I8Vec4>, + ) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -6639,48 +6083,44 @@ impl bevy::math::I8Vec4 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> i8 { - let output: i8 = bevy::math::I8Vec4::element_product(_self.into_inner()).into(); + fn element_product(_self: Val<::glam::I8Vec4>) -> i8 { + let output: i8 = ::glam::I8Vec4::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> i8 { - let output: i8 = bevy::math::I8Vec4::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::I8Vec4>) -> i8 { + let output: i8 = ::glam::I8Vec4::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::I8Vec4>) -> bool { + let output: bool = <::glam::I8Vec4 as ::core::cmp::PartialEq< + ::glam::I8Vec4, >>::eq(&_self, &other) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [i8; 4]) -> Val { - let output: Val = bevy::math::I8Vec4::from_array(a).into(); + fn from_array(a: [i8; 4]) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::from_array(a).into(); output } /// Returns a bitmask with the lowest 4 bits set to the sign bits from the elements of `self`. /// A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn is_negative_bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::I8Vec4::is_negative_bitmask(_self.into_inner()) - .into(); + fn is_negative_bitmask(_self: Val<::glam::I8Vec4>) -> u32 { + let output: u32 = ::glam::I8Vec4::is_negative_bitmask(_self.into_inner()).into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> i8 { - let output: i8 = bevy::math::I8Vec4::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::I8Vec4>) -> i8 { + let output: i8 = ::glam::I8Vec4::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. - fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::max( + fn max(_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::max( _self.into_inner(), rhs.into_inner(), ) @@ -6689,17 +6129,14 @@ impl bevy::math::I8Vec4 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> i8 { - let output: i8 = bevy::math::I8Vec4::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::I8Vec4>) -> i8 { + let output: i8 = ::glam::I8Vec4::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. - fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::min( + fn min(_self: Val<::glam::I8Vec4>, rhs: Val<::glam::I8Vec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::min( _self.into_inner(), rhs.into_inner(), ) @@ -6708,71 +6145,59 @@ impl bevy::math::I8Vec4 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> i8 { - let output: i8 = bevy::math::I8Vec4::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::I8Vec4>) -> i8 { + let output: i8 = ::glam::I8Vec4::min_element(_self.into_inner()).into(); output } - fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::I8Vec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Mul< + &::glam::I8Vec4, >>::mul(_self.into_inner(), &rhs) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::I8Vec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Mul< + ::glam::I8Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: i8) -> Val { - let output: Val = , rhs: i8) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Mul< i8, >>::mul(_self.into_inner(), rhs) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::I8Vec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); output } /// Creates a new vector. - fn new(x: i8, y: i8, z: i8, w: i8) -> Val { - let output: Val = bevy::math::I8Vec4::new(x, y, z, w).into(); + fn new(x: i8, y: i8, z: i8, w: i8) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::new(x, y, z, w).into(); output } - fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::I8Vec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Rem< + &::glam::I8Vec4, >>::rem(_self.into_inner(), &rhs) .into(); output } - fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::I8Vec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Rem< + ::glam::I8Vec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: i8) -> Val { - let output: Val = , rhs: i8) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Rem< i8, >>::rem(_self.into_inner(), rhs) .into(); @@ -6783,10 +6208,10 @@ impl bevy::math::I8Vec4 { /// This function will panic if any `rhs` element is 0 or the division results in overflow. /// [Euclidean division]: i8::rem_euclid fn rem_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::rem_euclid( + _self: Val<::glam::I8Vec4>, + rhs: Val<::glam::I8Vec4>, + ) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::rem_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -6796,10 +6221,10 @@ impl bevy::math::I8Vec4 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::saturating_add( + _self: Val<::glam::I8Vec4>, + rhs: Val<::glam::I8Vec4>, + ) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -6808,10 +6233,10 @@ impl bevy::math::I8Vec4 { } /// In other words this computes `[self.x.saturating_add_unsigned(rhs.x), self.y.saturating_add_unsigned(rhs.y), ..]`. fn saturating_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::saturating_add_unsigned( + _self: Val<::glam::I8Vec4>, + rhs: Val<::glam::U8Vec4>, + ) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::saturating_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -6821,10 +6246,10 @@ impl bevy::math::I8Vec4 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::saturating_div( + _self: Val<::glam::I8Vec4>, + rhs: Val<::glam::I8Vec4>, + ) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -6834,10 +6259,10 @@ impl bevy::math::I8Vec4 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::saturating_mul( + _self: Val<::glam::I8Vec4>, + rhs: Val<::glam::I8Vec4>, + ) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -6847,10 +6272,10 @@ impl bevy::math::I8Vec4 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::saturating_sub( + _self: Val<::glam::I8Vec4>, + rhs: Val<::glam::I8Vec4>, + ) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -6860,10 +6285,10 @@ impl bevy::math::I8Vec4 { /// Returns a vector containing the saturating subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.saturating_sub_unsigned(rhs.x), self.y.saturating_sub_unsigned(rhs.y), ..]`. fn saturating_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::saturating_sub_unsigned( + _self: Val<::glam::I8Vec4>, + rhs: Val<::glam::U8Vec4>, + ) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::saturating_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -6875,11 +6300,11 @@ impl bevy::math::I8Vec4 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::select( + mask: Val<::glam::BVec4>, + if_true: Val<::glam::I8Vec4>, + if_false: Val<::glam::I8Vec4>, + ) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -6891,102 +6316,80 @@ impl bevy::math::I8Vec4 { /// - `0` if the number is zero /// - `1` if the number is positive /// - `-1` if the number is negative - fn signum(_self: Val) -> Val { - let output: Val = bevy::math::I8Vec4::signum( - _self.into_inner(), - ) + fn signum(_self: Val<::glam::I8Vec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::signum(_self.into_inner()) .into(); output } /// Creates a vector with all elements set to `v`. - fn splat(v: i8) -> Val { - let output: Val = bevy::math::I8Vec4::splat(v).into(); + fn splat(v: i8) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::splat(v).into(); output } - fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::I8Vec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Sub< + &::glam::I8Vec4, >>::sub(_self.into_inner(), &rhs) .into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::I8Vec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Sub< + ::glam::I8Vec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: i8) -> Val { - let output: Val = , rhs: i8) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = <::glam::I8Vec4 as ::core::ops::Sub< i8, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y, z, w]` - fn to_array(_self: Ref) -> [i8; 4] { - let output: [i8; 4] = bevy::math::I8Vec4::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::I8Vec4>) -> [i8; 4] { + let output: [i8; 4] = ::glam::I8Vec4::to_array(&_self).into(); output } /// Creates a 3D vector from the `x`, `y` and `z` elements of `self`, discarding `w`. /// Truncation to [`I8Vec3`] may also be performed by using [`self.xyz()`][crate::swizzles::Vec4Swizzles::xyz()]. - fn truncate(_self: Val) -> Val { - let output: Val = bevy::math::I8Vec4::truncate( - _self.into_inner(), - ) + fn truncate(_self: Val<::glam::I8Vec4>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I8Vec4::truncate(_self.into_inner()) .into(); output } /// Creates a 4D vector from `self` with the given value of `w`. - fn with_w(_self: Val, w: i8) -> Val { - let output: Val = bevy::math::I8Vec4::with_w( - _self.into_inner(), - w, - ) + fn with_w(_self: Val<::glam::I8Vec4>, w: i8) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::with_w(_self.into_inner(), w) .into(); output } /// Creates a 4D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: i8) -> Val { - let output: Val = bevy::math::I8Vec4::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::I8Vec4>, x: i8) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::with_x(_self.into_inner(), x) .into(); output } /// Creates a 4D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: i8) -> Val { - let output: Val = bevy::math::I8Vec4::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::I8Vec4>, y: i8) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::with_y(_self.into_inner(), y) .into(); output } /// Creates a 4D vector from `self` with the given value of `z`. - fn with_z(_self: Val, z: i8) -> Val { - let output: Val = bevy::math::I8Vec4::with_z( - _self.into_inner(), - z, - ) + fn with_z(_self: Val<::glam::I8Vec4>, z: i8) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::with_z(_self.into_inner(), z) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::wrapping_add( + _self: Val<::glam::I8Vec4>, + rhs: Val<::glam::I8Vec4>, + ) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -6996,10 +6399,10 @@ impl bevy::math::I8Vec4 { /// Returns a vector containing the wrapping addition of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_add_unsigned(rhs.x), self.y.wrapping_add_unsigned(rhs.y), ..]`. fn wrapping_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::wrapping_add_unsigned( + _self: Val<::glam::I8Vec4>, + rhs: Val<::glam::U8Vec4>, + ) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::wrapping_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -7009,10 +6412,10 @@ impl bevy::math::I8Vec4 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::wrapping_div( + _self: Val<::glam::I8Vec4>, + rhs: Val<::glam::I8Vec4>, + ) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -7022,10 +6425,10 @@ impl bevy::math::I8Vec4 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::wrapping_mul( + _self: Val<::glam::I8Vec4>, + rhs: Val<::glam::I8Vec4>, + ) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -7035,10 +6438,10 @@ impl bevy::math::I8Vec4 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::wrapping_sub( + _self: Val<::glam::I8Vec4>, + rhs: Val<::glam::I8Vec4>, + ) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -7048,10 +6451,10 @@ impl bevy::math::I8Vec4 { /// Returns a vector containing the wrapping subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_sub_unsigned(rhs.x), self.y.wrapping_sub_unsigned(rhs.y), ..]`. fn wrapping_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I8Vec4::wrapping_sub_unsigned( + _self: Val<::glam::I8Vec4>, + rhs: Val<::glam::U8Vec4>, + ) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I8Vec4::wrapping_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -7065,97 +6468,87 @@ impl bevy::math::I8Vec4 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::I16Vec2 { +impl ::glam::I16Vec2 { /// Returns a vector containing the absolute value of each element of `self`. - fn abs(_self: Val) -> Val { - let output: Val = bevy::math::I16Vec2::abs( - _self.into_inner(), - ) + fn abs(_self: Val<::glam::I16Vec2>) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::abs(_self.into_inner()) .into(); output } fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Add< + &::glam::I16Vec2, >>::add(_self.into_inner(), &rhs) .into(); output } fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Add< + ::glam::I16Vec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: i16) -> Val { - let output: Val = , rhs: i16) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Add< i16, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec2(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec2::as_dvec2(&_self) - .into(); + fn as_dvec2(_self: Ref<::glam::I16Vec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::I16Vec2::as_dvec2(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec2(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec2::as_i64vec2(&_self) - .into(); + fn as_i64vec2(_self: Ref<::glam::I16Vec2>) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I16Vec2::as_i64vec2(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec2(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec2::as_i8vec2(&_self) - .into(); + fn as_i8vec2(_self: Ref<::glam::I16Vec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I16Vec2::as_i8vec2(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec2(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec2::as_ivec2(&_self) - .into(); + fn as_ivec2(_self: Ref<::glam::I16Vec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::I16Vec2::as_ivec2(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec2(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec2::as_u16vec2(&_self) - .into(); + fn as_u16vec2(_self: Ref<::glam::I16Vec2>) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::I16Vec2::as_u16vec2(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec2(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec2::as_u64vec2(&_self) - .into(); + fn as_u64vec2(_self: Ref<::glam::I16Vec2>) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::I16Vec2::as_u64vec2(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec2(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec2::as_u8vec2(&_self) - .into(); + fn as_u8vec2(_self: Ref<::glam::I16Vec2>) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::I16Vec2::as_u8vec2(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec2(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec2::as_uvec2(&_self) - .into(); + fn as_uvec2(_self: Ref<::glam::I16Vec2>) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::I16Vec2::as_uvec2(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec2(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec2::as_vec2(&_self).into(); + fn as_vec2(_self: Ref<::glam::I16Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::I16Vec2::as_vec2(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::I16Vec2>) -> () { + let output: () = <::glam::I16Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -7166,11 +6559,11 @@ impl bevy::math::I16Vec2 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::clamp( + _self: Val<::glam::I16Vec2>, + min: Val<::glam::I16Vec2>, + max: Val<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -7178,8 +6571,8 @@ impl bevy::math::I16Vec2 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::I16Vec2>) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -7190,10 +6583,10 @@ impl bevy::math::I16Vec2 { /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::cmpeq( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::I16Vec2::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -7205,10 +6598,10 @@ impl bevy::math::I16Vec2 { /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::cmpge( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::I16Vec2::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -7220,10 +6613,10 @@ impl bevy::math::I16Vec2 { /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::cmpgt( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::I16Vec2::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -7235,10 +6628,10 @@ impl bevy::math::I16Vec2 { /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::cmple( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::I16Vec2::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -7250,10 +6643,10 @@ impl bevy::math::I16Vec2 { /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::cmplt( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::I16Vec2::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -7265,10 +6658,10 @@ impl bevy::math::I16Vec2 { /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::cmpne( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::I16Vec2::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -7276,11 +6669,8 @@ impl bevy::math::I16Vec2 { output } /// Compute the squared euclidean distance between two points in space. - fn distance_squared( - _self: Val, - rhs: Val, - ) -> i16 { - let output: i16 = bevy::math::I16Vec2::distance_squared( + fn distance_squared(_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>) -> i16 { + let output: i16 = ::glam::I16Vec2::distance_squared( _self.into_inner(), rhs.into_inner(), ) @@ -7288,27 +6678,27 @@ impl bevy::math::I16Vec2 { output } fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Div< + &::glam::I16Vec2, >>::div(_self.into_inner(), &rhs) .into(); output } fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Div< + ::glam::I16Vec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: i16) -> Val { - let output: Val = , rhs: i16) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Div< i16, >>::div(_self.into_inner(), rhs) .into(); @@ -7318,10 +6708,10 @@ impl bevy::math::I16Vec2 { /// # Panics /// This function will panic if any `rhs` element is 0 or the division results in overflow. fn div_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::div_euclid( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -7329,17 +6719,17 @@ impl bevy::math::I16Vec2 { output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> i16 { - let output: i16 = bevy::math::I16Vec2::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>) -> i16 { + let output: i16 = ::glam::I16Vec2::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::dot_into_vec( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -7348,58 +6738,54 @@ impl bevy::math::I16Vec2 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> i16 { - let output: i16 = bevy::math::I16Vec2::element_product(_self.into_inner()) - .into(); + fn element_product(_self: Val<::glam::I16Vec2>) -> i16 { + let output: i16 = ::glam::I16Vec2::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> i16 { - let output: i16 = bevy::math::I16Vec2::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::I16Vec2>) -> i16 { + let output: i16 = ::glam::I16Vec2::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::I16Vec2>) -> bool { + let output: bool = <::glam::I16Vec2 as ::core::cmp::PartialEq< + ::glam::I16Vec2, >>::eq(&_self, &other) .into(); output } /// Creates a 3D vector from `self` and the given `z` value. - fn extend(_self: Val, z: i16) -> Val { - let output: Val = bevy::math::I16Vec2::extend( - _self.into_inner(), - z, - ) + fn extend(_self: Val<::glam::I16Vec2>, z: i16) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec2::extend(_self.into_inner(), z) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [i16; 2]) -> Val { - let output: Val = bevy::math::I16Vec2::from_array(a).into(); + fn from_array(a: [i16; 2]) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::from_array(a).into(); output } /// Returns a bitmask with the lowest 2 bits set to the sign bits from the elements of `self`. /// A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn is_negative_bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::I16Vec2::is_negative_bitmask(_self.into_inner()) + fn is_negative_bitmask(_self: Val<::glam::I16Vec2>) -> u32 { + let output: u32 = ::glam::I16Vec2::is_negative_bitmask(_self.into_inner()) .into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> i16 { - let output: i16 = bevy::math::I16Vec2::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::I16Vec2>) -> i16 { + let output: i16 = ::glam::I16Vec2::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::max( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::max( _self.into_inner(), rhs.into_inner(), ) @@ -7408,17 +6794,17 @@ impl bevy::math::I16Vec2 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> i16 { - let output: i16 = bevy::math::I16Vec2::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::I16Vec2>) -> i16 { + let output: i16 = ::glam::I16Vec2::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::min( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::min( _self.into_inner(), rhs.into_inner(), ) @@ -7427,89 +6813,84 @@ impl bevy::math::I16Vec2 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> i16 { - let output: i16 = bevy::math::I16Vec2::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::I16Vec2>) -> i16 { + let output: i16 = ::glam::I16Vec2::min_element(_self.into_inner()).into(); output } fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Mul< + &::glam::I16Vec2, >>::mul(_self.into_inner(), &rhs) .into(); output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Mul< + ::glam::I16Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: i16) -> Val { - let output: Val = , rhs: i16) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Mul< i16, >>::mul(_self.into_inner(), rhs) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::I16Vec2>) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); output } /// Creates a new vector. - fn new(x: i16, y: i16) -> Val { - let output: Val = bevy::math::I16Vec2::new(x, y).into(); + fn new(x: i16, y: i16) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::new(x, y).into(); output } /// Returns a vector that is equal to `self` rotated by 90 degrees. - fn perp(_self: Val) -> Val { - let output: Val = bevy::math::I16Vec2::perp( - _self.into_inner(), - ) + fn perp(_self: Val<::glam::I16Vec2>) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::perp(_self.into_inner()) .into(); output } /// The perpendicular dot product of `self` and `rhs`. /// Also known as the wedge product, 2D cross product, and determinant. - fn perp_dot(_self: Val, rhs: Val) -> i16 { - let output: i16 = bevy::math::I16Vec2::perp_dot( - _self.into_inner(), - rhs.into_inner(), - ) + fn perp_dot(_self: Val<::glam::I16Vec2>, rhs: Val<::glam::I16Vec2>) -> i16 { + let output: i16 = ::glam::I16Vec2::perp_dot(_self.into_inner(), rhs.into_inner()) .into(); output } fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Rem< + &::glam::I16Vec2, >>::rem(_self.into_inner(), &rhs) .into(); output } fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Rem< + ::glam::I16Vec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: i16) -> Val { - let output: Val = , rhs: i16) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Rem< i16, >>::rem(_self.into_inner(), rhs) .into(); @@ -7520,10 +6901,10 @@ impl bevy::math::I16Vec2 { /// This function will panic if any `rhs` element is 0 or the division results in overflow. /// [Euclidean division]: i16::rem_euclid fn rem_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::rem_euclid( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::rem_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -7534,10 +6915,10 @@ impl bevy::math::I16Vec2 { /// then this just rotation. This is what you usually want. Otherwise, /// it will be like a rotation with a multiplication by `self`'s length. fn rotate( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::rotate( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::rotate( _self.into_inner(), rhs.into_inner(), ) @@ -7547,10 +6928,10 @@ impl bevy::math::I16Vec2 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::saturating_add( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -7559,10 +6940,10 @@ impl bevy::math::I16Vec2 { } /// In other words this computes `[self.x.saturating_add_unsigned(rhs.x), self.y.saturating_add_unsigned(rhs.y), ..]`. fn saturating_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::saturating_add_unsigned( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::saturating_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -7572,10 +6953,10 @@ impl bevy::math::I16Vec2 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::saturating_div( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -7585,10 +6966,10 @@ impl bevy::math::I16Vec2 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::saturating_mul( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -7598,10 +6979,10 @@ impl bevy::math::I16Vec2 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::saturating_sub( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -7611,10 +6992,10 @@ impl bevy::math::I16Vec2 { /// Returns a vector containing the saturating subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.saturating_sub_unsigned(rhs.x), self.y.saturating_sub_unsigned(rhs.y), ..]`. fn saturating_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::saturating_sub_unsigned( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::saturating_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -7626,11 +7007,11 @@ impl bevy::math::I16Vec2 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::select( + mask: Val<::glam::BVec2>, + if_true: Val<::glam::I16Vec2>, + if_false: Val<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -7642,75 +7023,67 @@ impl bevy::math::I16Vec2 { /// - `0` if the number is zero /// - `1` if the number is positive /// - `-1` if the number is negative - fn signum(_self: Val) -> Val { - let output: Val = bevy::math::I16Vec2::signum( - _self.into_inner(), - ) + fn signum(_self: Val<::glam::I16Vec2>) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::signum(_self.into_inner()) .into(); output } /// Creates a vector with all elements set to `v`. - fn splat(v: i16) -> Val { - let output: Val = bevy::math::I16Vec2::splat(v).into(); + fn splat(v: i16) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::splat(v).into(); output } fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Sub< + &::glam::I16Vec2, >>::sub(_self.into_inner(), &rhs) .into(); output } fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Sub< + ::glam::I16Vec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: i16) -> Val { - let output: Val = , rhs: i16) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = <::glam::I16Vec2 as ::core::ops::Sub< i16, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y]` - fn to_array(_self: Ref) -> [i16; 2] { - let output: [i16; 2] = bevy::math::I16Vec2::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::I16Vec2>) -> [i16; 2] { + let output: [i16; 2] = ::glam::I16Vec2::to_array(&_self).into(); output } /// Creates a 2D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: i16) -> Val { - let output: Val = bevy::math::I16Vec2::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::I16Vec2>, x: i16) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::with_x(_self.into_inner(), x) .into(); output } /// Creates a 2D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: i16) -> Val { - let output: Val = bevy::math::I16Vec2::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::I16Vec2>, y: i16) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::with_y(_self.into_inner(), y) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::wrapping_add( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -7720,10 +7093,10 @@ impl bevy::math::I16Vec2 { /// Returns a vector containing the wrapping addition of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_add_unsigned(rhs.x), self.y.wrapping_add_unsigned(rhs.y), ..]`. fn wrapping_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::wrapping_add_unsigned( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::wrapping_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -7733,10 +7106,10 @@ impl bevy::math::I16Vec2 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::wrapping_div( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -7746,10 +7119,10 @@ impl bevy::math::I16Vec2 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::wrapping_mul( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -7759,10 +7132,10 @@ impl bevy::math::I16Vec2 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::wrapping_sub( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -7772,10 +7145,10 @@ impl bevy::math::I16Vec2 { /// Returns a vector containing the wrapping subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_sub_unsigned(rhs.x), self.y.wrapping_sub_unsigned(rhs.y), ..]`. fn wrapping_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec2::wrapping_sub_unsigned( + _self: Val<::glam::I16Vec2>, + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec2::wrapping_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -7789,103 +7162,92 @@ impl bevy::math::I16Vec2 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::I16Vec3 { +impl ::glam::I16Vec3 { /// Returns a vector containing the absolute value of each element of `self`. - fn abs(_self: Val) -> Val { - let output: Val = bevy::math::I16Vec3::abs( - _self.into_inner(), - ) + fn abs(_self: Val<::glam::I16Vec3>) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::abs(_self.into_inner()) .into(); output } fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Add< + &::glam::I16Vec3, >>::add(_self.into_inner(), &rhs) .into(); output } fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Add< + ::glam::I16Vec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: i16) -> Val { - let output: Val = , rhs: i16) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Add< i16, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec3(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec3::as_dvec3(&_self) - .into(); + fn as_dvec3(_self: Ref<::glam::I16Vec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::I16Vec3::as_dvec3(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec3(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec3::as_i64vec3(&_self) - .into(); + fn as_i64vec3(_self: Ref<::glam::I16Vec3>) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I16Vec3::as_i64vec3(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec3(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec3::as_i8vec3(&_self) - .into(); + fn as_i8vec3(_self: Ref<::glam::I16Vec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I16Vec3::as_i8vec3(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec3(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec3::as_ivec3(&_self) - .into(); + fn as_ivec3(_self: Ref<::glam::I16Vec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::I16Vec3::as_ivec3(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec3(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec3::as_u16vec3(&_self) - .into(); + fn as_u16vec3(_self: Ref<::glam::I16Vec3>) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::I16Vec3::as_u16vec3(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec3(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec3::as_u64vec3(&_self) - .into(); + fn as_u64vec3(_self: Ref<::glam::I16Vec3>) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::I16Vec3::as_u64vec3(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec3(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec3::as_u8vec3(&_self) - .into(); + fn as_u8vec3(_self: Ref<::glam::I16Vec3>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::I16Vec3::as_u8vec3(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec3(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec3::as_uvec3(&_self) - .into(); + fn as_uvec3(_self: Ref<::glam::I16Vec3>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::I16Vec3::as_uvec3(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec3(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec3::as_vec3(&_self).into(); + fn as_vec3(_self: Ref<::glam::I16Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::I16Vec3::as_vec3(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec3a(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec3::as_vec3a(&_self) - .into(); + fn as_vec3a(_self: Ref<::glam::I16Vec3>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::I16Vec3::as_vec3a(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::I16Vec3>) -> () { + let output: () = <::glam::I16Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -7896,11 +7258,11 @@ impl bevy::math::I16Vec3 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::clamp( + _self: Val<::glam::I16Vec3>, + min: Val<::glam::I16Vec3>, + max: Val<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -7908,8 +7270,8 @@ impl bevy::math::I16Vec3 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::I16Vec3>) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -7920,10 +7282,10 @@ impl bevy::math::I16Vec3 { /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::cmpeq( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::I16Vec3::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -7935,10 +7297,10 @@ impl bevy::math::I16Vec3 { /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::cmpge( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::I16Vec3::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -7950,10 +7312,10 @@ impl bevy::math::I16Vec3 { /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::cmpgt( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::I16Vec3::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -7965,10 +7327,10 @@ impl bevy::math::I16Vec3 { /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::cmple( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::I16Vec3::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -7980,10 +7342,10 @@ impl bevy::math::I16Vec3 { /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::cmplt( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::I16Vec3::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -7995,10 +7357,10 @@ impl bevy::math::I16Vec3 { /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::cmpne( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::I16Vec3::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -8007,10 +7369,10 @@ impl bevy::math::I16Vec3 { } /// Computes the cross product of `self` and `rhs`. fn cross( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::cross( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::cross( _self.into_inner(), rhs.into_inner(), ) @@ -8018,11 +7380,8 @@ impl bevy::math::I16Vec3 { output } /// Compute the squared euclidean distance between two points in space. - fn distance_squared( - _self: Val, - rhs: Val, - ) -> i16 { - let output: i16 = bevy::math::I16Vec3::distance_squared( + fn distance_squared(_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>) -> i16 { + let output: i16 = ::glam::I16Vec3::distance_squared( _self.into_inner(), rhs.into_inner(), ) @@ -8030,27 +7389,27 @@ impl bevy::math::I16Vec3 { output } fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Div< + &::glam::I16Vec3, >>::div(_self.into_inner(), &rhs) .into(); output } fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Div< + ::glam::I16Vec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: i16) -> Val { - let output: Val = , rhs: i16) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Div< i16, >>::div(_self.into_inner(), rhs) .into(); @@ -8060,10 +7419,10 @@ impl bevy::math::I16Vec3 { /// # Panics /// This function will panic if any `rhs` element is 0 or the division results in overflow. fn div_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::div_euclid( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -8071,17 +7430,17 @@ impl bevy::math::I16Vec3 { output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> i16 { - let output: i16 = bevy::math::I16Vec3::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::I16Vec3>, rhs: Val<::glam::I16Vec3>) -> i16 { + let output: i16 = ::glam::I16Vec3::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::dot_into_vec( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -8090,58 +7449,54 @@ impl bevy::math::I16Vec3 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> i16 { - let output: i16 = bevy::math::I16Vec3::element_product(_self.into_inner()) - .into(); + fn element_product(_self: Val<::glam::I16Vec3>) -> i16 { + let output: i16 = ::glam::I16Vec3::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> i16 { - let output: i16 = bevy::math::I16Vec3::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::I16Vec3>) -> i16 { + let output: i16 = ::glam::I16Vec3::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::I16Vec3>) -> bool { + let output: bool = <::glam::I16Vec3 as ::core::cmp::PartialEq< + ::glam::I16Vec3, >>::eq(&_self, &other) .into(); output } /// Creates a 4D vector from `self` and the given `w` value. - fn extend(_self: Val, w: i16) -> Val { - let output: Val = bevy::math::I16Vec3::extend( - _self.into_inner(), - w, - ) + fn extend(_self: Val<::glam::I16Vec3>, w: i16) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec3::extend(_self.into_inner(), w) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [i16; 3]) -> Val { - let output: Val = bevy::math::I16Vec3::from_array(a).into(); + fn from_array(a: [i16; 3]) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::from_array(a).into(); output } /// Returns a bitmask with the lowest 3 bits set to the sign bits from the elements of `self`. /// A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn is_negative_bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::I16Vec3::is_negative_bitmask(_self.into_inner()) + fn is_negative_bitmask(_self: Val<::glam::I16Vec3>) -> u32 { + let output: u32 = ::glam::I16Vec3::is_negative_bitmask(_self.into_inner()) .into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> i16 { - let output: i16 = bevy::math::I16Vec3::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::I16Vec3>) -> i16 { + let output: i16 = ::glam::I16Vec3::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::max( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::max( _self.into_inner(), rhs.into_inner(), ) @@ -8150,17 +7505,17 @@ impl bevy::math::I16Vec3 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> i16 { - let output: i16 = bevy::math::I16Vec3::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::I16Vec3>) -> i16 { + let output: i16 = ::glam::I16Vec3::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::min( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::min( _self.into_inner(), rhs.into_inner(), ) @@ -8169,71 +7524,71 @@ impl bevy::math::I16Vec3 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> i16 { - let output: i16 = bevy::math::I16Vec3::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::I16Vec3>) -> i16 { + let output: i16 = ::glam::I16Vec3::min_element(_self.into_inner()).into(); output } fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Mul< + &::glam::I16Vec3, >>::mul(_self.into_inner(), &rhs) .into(); output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Mul< + ::glam::I16Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: i16) -> Val { - let output: Val = , rhs: i16) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Mul< i16, >>::mul(_self.into_inner(), rhs) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::I16Vec3>) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); output } /// Creates a new vector. - fn new(x: i16, y: i16, z: i16) -> Val { - let output: Val = bevy::math::I16Vec3::new(x, y, z).into(); + fn new(x: i16, y: i16, z: i16) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::new(x, y, z).into(); output } fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Rem< + &::glam::I16Vec3, >>::rem(_self.into_inner(), &rhs) .into(); output } fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Rem< + ::glam::I16Vec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: i16) -> Val { - let output: Val = , rhs: i16) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Rem< i16, >>::rem(_self.into_inner(), rhs) .into(); @@ -8244,10 +7599,10 @@ impl bevy::math::I16Vec3 { /// This function will panic if any `rhs` element is 0 or the division results in overflow. /// [Euclidean division]: i16::rem_euclid fn rem_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::rem_euclid( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::rem_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -8257,10 +7612,10 @@ impl bevy::math::I16Vec3 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::saturating_add( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -8269,10 +7624,10 @@ impl bevy::math::I16Vec3 { } /// In other words this computes `[self.x.saturating_add_unsigned(rhs.x), self.y.saturating_add_unsigned(rhs.y), ..]`. fn saturating_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::saturating_add_unsigned( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::saturating_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -8282,10 +7637,10 @@ impl bevy::math::I16Vec3 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::saturating_div( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -8295,10 +7650,10 @@ impl bevy::math::I16Vec3 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::saturating_mul( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -8308,10 +7663,10 @@ impl bevy::math::I16Vec3 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::saturating_sub( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -8321,10 +7676,10 @@ impl bevy::math::I16Vec3 { /// Returns a vector containing the saturating subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.saturating_sub_unsigned(rhs.x), self.y.saturating_sub_unsigned(rhs.y), ..]`. fn saturating_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::saturating_sub_unsigned( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::saturating_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -8336,11 +7691,11 @@ impl bevy::math::I16Vec3 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::select( + mask: Val<::glam::BVec3>, + if_true: Val<::glam::I16Vec3>, + if_false: Val<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -8352,93 +7707,80 @@ impl bevy::math::I16Vec3 { /// - `0` if the number is zero /// - `1` if the number is positive /// - `-1` if the number is negative - fn signum(_self: Val) -> Val { - let output: Val = bevy::math::I16Vec3::signum( - _self.into_inner(), - ) + fn signum(_self: Val<::glam::I16Vec3>) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::signum(_self.into_inner()) .into(); output } /// Creates a vector with all elements set to `v`. - fn splat(v: i16) -> Val { - let output: Val = bevy::math::I16Vec3::splat(v).into(); + fn splat(v: i16) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::splat(v).into(); output } fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Sub< + &::glam::I16Vec3, >>::sub(_self.into_inner(), &rhs) .into(); output } fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Sub< + ::glam::I16Vec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: i16) -> Val { - let output: Val = , rhs: i16) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = <::glam::I16Vec3 as ::core::ops::Sub< i16, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y, z]` - fn to_array(_self: Ref) -> [i16; 3] { - let output: [i16; 3] = bevy::math::I16Vec3::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::I16Vec3>) -> [i16; 3] { + let output: [i16; 3] = ::glam::I16Vec3::to_array(&_self).into(); output } /// Creates a 2D vector from the `x` and `y` elements of `self`, discarding `z`. /// Truncation may also be performed by using [`self.xy()`][crate::swizzles::Vec3Swizzles::xy()]. - fn truncate(_self: Val) -> Val { - let output: Val = bevy::math::I16Vec3::truncate( - _self.into_inner(), - ) + fn truncate(_self: Val<::glam::I16Vec3>) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I16Vec3::truncate(_self.into_inner()) .into(); output } /// Creates a 3D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: i16) -> Val { - let output: Val = bevy::math::I16Vec3::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::I16Vec3>, x: i16) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::with_x(_self.into_inner(), x) .into(); output } /// Creates a 3D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: i16) -> Val { - let output: Val = bevy::math::I16Vec3::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::I16Vec3>, y: i16) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::with_y(_self.into_inner(), y) .into(); output } /// Creates a 3D vector from `self` with the given value of `z`. - fn with_z(_self: Val, z: i16) -> Val { - let output: Val = bevy::math::I16Vec3::with_z( - _self.into_inner(), - z, - ) + fn with_z(_self: Val<::glam::I16Vec3>, z: i16) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::with_z(_self.into_inner(), z) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::wrapping_add( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -8448,10 +7790,10 @@ impl bevy::math::I16Vec3 { /// Returns a vector containing the wrapping addition of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_add_unsigned(rhs.x), self.y.wrapping_add_unsigned(rhs.y), ..]`. fn wrapping_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::wrapping_add_unsigned( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::wrapping_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -8461,10 +7803,10 @@ impl bevy::math::I16Vec3 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::wrapping_div( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -8474,10 +7816,10 @@ impl bevy::math::I16Vec3 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::wrapping_mul( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -8487,10 +7829,10 @@ impl bevy::math::I16Vec3 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::wrapping_sub( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -8500,10 +7842,10 @@ impl bevy::math::I16Vec3 { /// Returns a vector containing the wrapping subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_sub_unsigned(rhs.x), self.y.wrapping_sub_unsigned(rhs.y), ..]`. fn wrapping_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec3::wrapping_sub_unsigned( + _self: Val<::glam::I16Vec3>, + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec3::wrapping_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -8517,97 +7859,87 @@ impl bevy::math::I16Vec3 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::I16Vec4 { +impl ::glam::I16Vec4 { /// Returns a vector containing the absolute value of each element of `self`. - fn abs(_self: Val) -> Val { - let output: Val = bevy::math::I16Vec4::abs( - _self.into_inner(), - ) + fn abs(_self: Val<::glam::I16Vec4>) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::abs(_self.into_inner()) .into(); output } fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Add< + &::glam::I16Vec4, >>::add(_self.into_inner(), &rhs) .into(); output } fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Add< + ::glam::I16Vec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: i16) -> Val { - let output: Val = , rhs: i16) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Add< i16, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec4(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec4::as_dvec4(&_self) - .into(); + fn as_dvec4(_self: Ref<::glam::I16Vec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::I16Vec4::as_dvec4(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec4(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec4::as_i64vec4(&_self) - .into(); + fn as_i64vec4(_self: Ref<::glam::I16Vec4>) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I16Vec4::as_i64vec4(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec4(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec4::as_i8vec4(&_self) - .into(); + fn as_i8vec4(_self: Ref<::glam::I16Vec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I16Vec4::as_i8vec4(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec4(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec4::as_ivec4(&_self) - .into(); + fn as_ivec4(_self: Ref<::glam::I16Vec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::I16Vec4::as_ivec4(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec4(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec4::as_u16vec4(&_self) - .into(); + fn as_u16vec4(_self: Ref<::glam::I16Vec4>) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::I16Vec4::as_u16vec4(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec4(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec4::as_u64vec4(&_self) - .into(); + fn as_u64vec4(_self: Ref<::glam::I16Vec4>) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::I16Vec4::as_u64vec4(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec4(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec4::as_u8vec4(&_self) - .into(); + fn as_u8vec4(_self: Ref<::glam::I16Vec4>) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::I16Vec4::as_u8vec4(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec4(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec4::as_uvec4(&_self) - .into(); + fn as_uvec4(_self: Ref<::glam::I16Vec4>) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::I16Vec4::as_uvec4(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec4(_self: Ref) -> Val { - let output: Val = bevy::math::I16Vec4::as_vec4(&_self).into(); + fn as_vec4(_self: Ref<::glam::I16Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::I16Vec4::as_vec4(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::I16Vec4>) -> () { + let output: () = <::glam::I16Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -8618,11 +7950,11 @@ impl bevy::math::I16Vec4 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::clamp( + _self: Val<::glam::I16Vec4>, + min: Val<::glam::I16Vec4>, + max: Val<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -8630,8 +7962,8 @@ impl bevy::math::I16Vec4 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::I16Vec4>) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -8642,10 +7974,10 @@ impl bevy::math::I16Vec4 { /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::cmpeq( + _self: Val<::glam::I16Vec4>, + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::I16Vec4::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -8657,10 +7989,10 @@ impl bevy::math::I16Vec4 { /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::cmpge( + _self: Val<::glam::I16Vec4>, + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::I16Vec4::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -8672,10 +8004,10 @@ impl bevy::math::I16Vec4 { /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::cmpgt( + _self: Val<::glam::I16Vec4>, + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::I16Vec4::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -8687,10 +8019,10 @@ impl bevy::math::I16Vec4 { /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::cmple( + _self: Val<::glam::I16Vec4>, + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::I16Vec4::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -8702,10 +8034,10 @@ impl bevy::math::I16Vec4 { /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::cmplt( + _self: Val<::glam::I16Vec4>, + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::I16Vec4::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -8717,10 +8049,10 @@ impl bevy::math::I16Vec4 { /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::cmpne( + _self: Val<::glam::I16Vec4>, + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::I16Vec4::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -8728,11 +8060,8 @@ impl bevy::math::I16Vec4 { output } /// Compute the squared euclidean distance between two points in space. - fn distance_squared( - _self: Val, - rhs: Val, - ) -> i16 { - let output: i16 = bevy::math::I16Vec4::distance_squared( + fn distance_squared(_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>) -> i16 { + let output: i16 = ::glam::I16Vec4::distance_squared( _self.into_inner(), rhs.into_inner(), ) @@ -8740,27 +8069,27 @@ impl bevy::math::I16Vec4 { output } fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Div< + &::glam::I16Vec4, >>::div(_self.into_inner(), &rhs) .into(); output } fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Div< + ::glam::I16Vec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: i16) -> Val { - let output: Val = , rhs: i16) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Div< i16, >>::div(_self.into_inner(), rhs) .into(); @@ -8770,10 +8099,10 @@ impl bevy::math::I16Vec4 { /// # Panics /// This function will panic if any `rhs` element is 0 or the division results in overflow. fn div_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::div_euclid( + _self: Val<::glam::I16Vec4>, + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -8781,17 +8110,17 @@ impl bevy::math::I16Vec4 { output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> i16 { - let output: i16 = bevy::math::I16Vec4::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::I16Vec4>, rhs: Val<::glam::I16Vec4>) -> i16 { + let output: i16 = ::glam::I16Vec4::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::dot_into_vec( + _self: Val<::glam::I16Vec4>, + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -8800,49 +8129,48 @@ impl bevy::math::I16Vec4 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> i16 { - let output: i16 = bevy::math::I16Vec4::element_product(_self.into_inner()) - .into(); + fn element_product(_self: Val<::glam::I16Vec4>) -> i16 { + let output: i16 = ::glam::I16Vec4::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> i16 { - let output: i16 = bevy::math::I16Vec4::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::I16Vec4>) -> i16 { + let output: i16 = ::glam::I16Vec4::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::I16Vec4>) -> bool { + let output: bool = <::glam::I16Vec4 as ::core::cmp::PartialEq< + ::glam::I16Vec4, >>::eq(&_self, &other) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [i16; 4]) -> Val { - let output: Val = bevy::math::I16Vec4::from_array(a).into(); + fn from_array(a: [i16; 4]) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::from_array(a).into(); output } /// Returns a bitmask with the lowest 4 bits set to the sign bits from the elements of `self`. /// A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn is_negative_bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::I16Vec4::is_negative_bitmask(_self.into_inner()) + fn is_negative_bitmask(_self: Val<::glam::I16Vec4>) -> u32 { + let output: u32 = ::glam::I16Vec4::is_negative_bitmask(_self.into_inner()) .into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> i16 { - let output: i16 = bevy::math::I16Vec4::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::I16Vec4>) -> i16 { + let output: i16 = ::glam::I16Vec4::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::max( + _self: Val<::glam::I16Vec4>, + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::max( _self.into_inner(), rhs.into_inner(), ) @@ -8851,17 +8179,17 @@ impl bevy::math::I16Vec4 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> i16 { - let output: i16 = bevy::math::I16Vec4::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::I16Vec4>) -> i16 { + let output: i16 = ::glam::I16Vec4::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::min( + _self: Val<::glam::I16Vec4>, + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::min( _self.into_inner(), rhs.into_inner(), ) @@ -8870,72 +8198,71 @@ impl bevy::math::I16Vec4 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> i16 { - let output: i16 = bevy::math::I16Vec4::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::I16Vec4>) -> i16 { + let output: i16 = ::glam::I16Vec4::min_element(_self.into_inner()).into(); output } fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Mul< + &::glam::I16Vec4, >>::mul(_self.into_inner(), &rhs) .into(); output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Mul< + ::glam::I16Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: i16) -> Val { - let output: Val = , rhs: i16) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Mul< i16, >>::mul(_self.into_inner(), rhs) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::I16Vec4>) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); output } /// Creates a new vector. - fn new(x: i16, y: i16, z: i16, w: i16) -> Val { - let output: Val = bevy::math::I16Vec4::new(x, y, z, w) - .into(); + fn new(x: i16, y: i16, z: i16, w: i16) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::new(x, y, z, w).into(); output } fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Rem< + &::glam::I16Vec4, >>::rem(_self.into_inner(), &rhs) .into(); output } fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Rem< + ::glam::I16Vec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: i16) -> Val { - let output: Val = , rhs: i16) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Rem< i16, >>::rem(_self.into_inner(), rhs) .into(); @@ -8946,10 +8273,10 @@ impl bevy::math::I16Vec4 { /// This function will panic if any `rhs` element is 0 or the division results in overflow. /// [Euclidean division]: i16::rem_euclid fn rem_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::rem_euclid( + _self: Val<::glam::I16Vec4>, + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::rem_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -8959,10 +8286,10 @@ impl bevy::math::I16Vec4 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::saturating_add( + _self: Val<::glam::I16Vec4>, + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -8971,10 +8298,10 @@ impl bevy::math::I16Vec4 { } /// In other words this computes `[self.x.saturating_add_unsigned(rhs.x), self.y.saturating_add_unsigned(rhs.y), ..]`. fn saturating_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::saturating_add_unsigned( + _self: Val<::glam::I16Vec4>, + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::saturating_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -8984,10 +8311,10 @@ impl bevy::math::I16Vec4 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::saturating_div( + _self: Val<::glam::I16Vec4>, + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -8997,10 +8324,10 @@ impl bevy::math::I16Vec4 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::saturating_mul( + _self: Val<::glam::I16Vec4>, + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -9010,10 +8337,10 @@ impl bevy::math::I16Vec4 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::saturating_sub( + _self: Val<::glam::I16Vec4>, + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -9023,10 +8350,10 @@ impl bevy::math::I16Vec4 { /// Returns a vector containing the saturating subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.saturating_sub_unsigned(rhs.x), self.y.saturating_sub_unsigned(rhs.y), ..]`. fn saturating_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::saturating_sub_unsigned( + _self: Val<::glam::I16Vec4>, + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::saturating_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -9038,11 +8365,11 @@ impl bevy::math::I16Vec4 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::select( + mask: Val<::glam::BVec4>, + if_true: Val<::glam::I16Vec4>, + if_false: Val<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -9054,102 +8381,86 @@ impl bevy::math::I16Vec4 { /// - `0` if the number is zero /// - `1` if the number is positive /// - `-1` if the number is negative - fn signum(_self: Val) -> Val { - let output: Val = bevy::math::I16Vec4::signum( - _self.into_inner(), - ) + fn signum(_self: Val<::glam::I16Vec4>) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::signum(_self.into_inner()) .into(); output } /// Creates a vector with all elements set to `v`. - fn splat(v: i16) -> Val { - let output: Val = bevy::math::I16Vec4::splat(v).into(); + fn splat(v: i16) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::splat(v).into(); output } fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Sub< + &::glam::I16Vec4, >>::sub(_self.into_inner(), &rhs) .into(); output } fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Sub< + ::glam::I16Vec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: i16) -> Val { - let output: Val = , rhs: i16) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = <::glam::I16Vec4 as ::core::ops::Sub< i16, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y, z, w]` - fn to_array(_self: Ref) -> [i16; 4] { - let output: [i16; 4] = bevy::math::I16Vec4::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::I16Vec4>) -> [i16; 4] { + let output: [i16; 4] = ::glam::I16Vec4::to_array(&_self).into(); output } /// Creates a 3D vector from the `x`, `y` and `z` elements of `self`, discarding `w`. /// Truncation to [`I16Vec3`] may also be performed by using [`self.xyz()`][crate::swizzles::Vec4Swizzles::xyz()]. - fn truncate(_self: Val) -> Val { - let output: Val = bevy::math::I16Vec4::truncate( - _self.into_inner(), - ) + fn truncate(_self: Val<::glam::I16Vec4>) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I16Vec4::truncate(_self.into_inner()) .into(); output } /// Creates a 4D vector from `self` with the given value of `w`. - fn with_w(_self: Val, w: i16) -> Val { - let output: Val = bevy::math::I16Vec4::with_w( - _self.into_inner(), - w, - ) + fn with_w(_self: Val<::glam::I16Vec4>, w: i16) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::with_w(_self.into_inner(), w) .into(); output } /// Creates a 4D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: i16) -> Val { - let output: Val = bevy::math::I16Vec4::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::I16Vec4>, x: i16) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::with_x(_self.into_inner(), x) .into(); output } /// Creates a 4D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: i16) -> Val { - let output: Val = bevy::math::I16Vec4::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::I16Vec4>, y: i16) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::with_y(_self.into_inner(), y) .into(); output } /// Creates a 4D vector from `self` with the given value of `z`. - fn with_z(_self: Val, z: i16) -> Val { - let output: Val = bevy::math::I16Vec4::with_z( - _self.into_inner(), - z, - ) + fn with_z(_self: Val<::glam::I16Vec4>, z: i16) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::with_z(_self.into_inner(), z) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::wrapping_add( + _self: Val<::glam::I16Vec4>, + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -9159,10 +8470,10 @@ impl bevy::math::I16Vec4 { /// Returns a vector containing the wrapping addition of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_add_unsigned(rhs.x), self.y.wrapping_add_unsigned(rhs.y), ..]`. fn wrapping_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::wrapping_add_unsigned( + _self: Val<::glam::I16Vec4>, + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::wrapping_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -9172,10 +8483,10 @@ impl bevy::math::I16Vec4 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::wrapping_div( + _self: Val<::glam::I16Vec4>, + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -9185,10 +8496,10 @@ impl bevy::math::I16Vec4 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::wrapping_mul( + _self: Val<::glam::I16Vec4>, + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -9198,10 +8509,10 @@ impl bevy::math::I16Vec4 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::wrapping_sub( + _self: Val<::glam::I16Vec4>, + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -9211,10 +8522,10 @@ impl bevy::math::I16Vec4 { /// Returns a vector containing the wrapping subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_sub_unsigned(rhs.x), self.y.wrapping_sub_unsigned(rhs.y), ..]`. fn wrapping_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I16Vec4::wrapping_sub_unsigned( + _self: Val<::glam::I16Vec4>, + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I16Vec4::wrapping_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -9228,97 +8539,87 @@ impl bevy::math::I16Vec4 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::I64Vec2 { +impl ::glam::I64Vec2 { /// Returns a vector containing the absolute value of each element of `self`. - fn abs(_self: Val) -> Val { - let output: Val = bevy::math::I64Vec2::abs( - _self.into_inner(), - ) + fn abs(_self: Val<::glam::I64Vec2>) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::abs(_self.into_inner()) .into(); output } fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Add< + &::glam::I64Vec2, >>::add(_self.into_inner(), &rhs) .into(); output } fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Add< + ::glam::I64Vec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: i64) -> Val { - let output: Val = , rhs: i64) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Add< i64, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec2(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec2::as_dvec2(&_self) - .into(); + fn as_dvec2(_self: Ref<::glam::I64Vec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::I64Vec2::as_dvec2(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec2(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec2::as_i16vec2(&_self) - .into(); + fn as_i16vec2(_self: Ref<::glam::I64Vec2>) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::I64Vec2::as_i16vec2(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec2(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec2::as_i8vec2(&_self) - .into(); + fn as_i8vec2(_self: Ref<::glam::I64Vec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::I64Vec2::as_i8vec2(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec2(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec2::as_ivec2(&_self) - .into(); + fn as_ivec2(_self: Ref<::glam::I64Vec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::I64Vec2::as_ivec2(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec2(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec2::as_u16vec2(&_self) - .into(); + fn as_u16vec2(_self: Ref<::glam::I64Vec2>) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::I64Vec2::as_u16vec2(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec2(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec2::as_u64vec2(&_self) - .into(); + fn as_u64vec2(_self: Ref<::glam::I64Vec2>) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::I64Vec2::as_u64vec2(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec2(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec2::as_u8vec2(&_self) - .into(); + fn as_u8vec2(_self: Ref<::glam::I64Vec2>) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::I64Vec2::as_u8vec2(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec2(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec2::as_uvec2(&_self) - .into(); + fn as_uvec2(_self: Ref<::glam::I64Vec2>) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::I64Vec2::as_uvec2(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec2(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec2::as_vec2(&_self).into(); + fn as_vec2(_self: Ref<::glam::I64Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::I64Vec2::as_vec2(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::I64Vec2>) -> () { + let output: () = <::glam::I64Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -9329,11 +8630,11 @@ impl bevy::math::I64Vec2 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::clamp( + _self: Val<::glam::I64Vec2>, + min: Val<::glam::I64Vec2>, + max: Val<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -9341,8 +8642,8 @@ impl bevy::math::I64Vec2 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::I64Vec2>) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -9353,10 +8654,10 @@ impl bevy::math::I64Vec2 { /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::cmpeq( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::I64Vec2::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -9368,10 +8669,10 @@ impl bevy::math::I64Vec2 { /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::cmpge( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::I64Vec2::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -9383,10 +8684,10 @@ impl bevy::math::I64Vec2 { /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::cmpgt( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::I64Vec2::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -9398,10 +8699,10 @@ impl bevy::math::I64Vec2 { /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::cmple( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::I64Vec2::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -9413,10 +8714,10 @@ impl bevy::math::I64Vec2 { /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::cmplt( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::I64Vec2::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -9428,10 +8729,10 @@ impl bevy::math::I64Vec2 { /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::cmpne( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::I64Vec2::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -9439,11 +8740,8 @@ impl bevy::math::I64Vec2 { output } /// Compute the squared euclidean distance between two points in space. - fn distance_squared( - _self: Val, - rhs: Val, - ) -> i64 { - let output: i64 = bevy::math::I64Vec2::distance_squared( + fn distance_squared(_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>) -> i64 { + let output: i64 = ::glam::I64Vec2::distance_squared( _self.into_inner(), rhs.into_inner(), ) @@ -9451,27 +8749,27 @@ impl bevy::math::I64Vec2 { output } fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Div< + &::glam::I64Vec2, >>::div(_self.into_inner(), &rhs) .into(); output } fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Div< + ::glam::I64Vec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: i64) -> Val { - let output: Val = , rhs: i64) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Div< i64, >>::div(_self.into_inner(), rhs) .into(); @@ -9481,10 +8779,10 @@ impl bevy::math::I64Vec2 { /// # Panics /// This function will panic if any `rhs` element is 0 or the division results in overflow. fn div_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::div_euclid( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -9492,17 +8790,17 @@ impl bevy::math::I64Vec2 { output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> i64 { - let output: i64 = bevy::math::I64Vec2::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>) -> i64 { + let output: i64 = ::glam::I64Vec2::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::dot_into_vec( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -9511,58 +8809,54 @@ impl bevy::math::I64Vec2 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> i64 { - let output: i64 = bevy::math::I64Vec2::element_product(_self.into_inner()) - .into(); + fn element_product(_self: Val<::glam::I64Vec2>) -> i64 { + let output: i64 = ::glam::I64Vec2::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> i64 { - let output: i64 = bevy::math::I64Vec2::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::I64Vec2>) -> i64 { + let output: i64 = ::glam::I64Vec2::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::I64Vec2>) -> bool { + let output: bool = <::glam::I64Vec2 as ::core::cmp::PartialEq< + ::glam::I64Vec2, >>::eq(&_self, &other) .into(); output } /// Creates a 3D vector from `self` and the given `z` value. - fn extend(_self: Val, z: i64) -> Val { - let output: Val = bevy::math::I64Vec2::extend( - _self.into_inner(), - z, - ) + fn extend(_self: Val<::glam::I64Vec2>, z: i64) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec2::extend(_self.into_inner(), z) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [i64; 2]) -> Val { - let output: Val = bevy::math::I64Vec2::from_array(a).into(); + fn from_array(a: [i64; 2]) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::from_array(a).into(); output } /// Returns a bitmask with the lowest 2 bits set to the sign bits from the elements of `self`. /// A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn is_negative_bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::I64Vec2::is_negative_bitmask(_self.into_inner()) + fn is_negative_bitmask(_self: Val<::glam::I64Vec2>) -> u32 { + let output: u32 = ::glam::I64Vec2::is_negative_bitmask(_self.into_inner()) .into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> i64 { - let output: i64 = bevy::math::I64Vec2::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::I64Vec2>) -> i64 { + let output: i64 = ::glam::I64Vec2::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::max( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::max( _self.into_inner(), rhs.into_inner(), ) @@ -9571,17 +8865,17 @@ impl bevy::math::I64Vec2 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> i64 { - let output: i64 = bevy::math::I64Vec2::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::I64Vec2>) -> i64 { + let output: i64 = ::glam::I64Vec2::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::min( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::min( _self.into_inner(), rhs.into_inner(), ) @@ -9590,89 +8884,84 @@ impl bevy::math::I64Vec2 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> i64 { - let output: i64 = bevy::math::I64Vec2::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::I64Vec2>) -> i64 { + let output: i64 = ::glam::I64Vec2::min_element(_self.into_inner()).into(); output } fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Mul< + &::glam::I64Vec2, >>::mul(_self.into_inner(), &rhs) .into(); output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Mul< + ::glam::I64Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: i64) -> Val { - let output: Val = , rhs: i64) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Mul< i64, >>::mul(_self.into_inner(), rhs) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::I64Vec2>) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); output } /// Creates a new vector. - fn new(x: i64, y: i64) -> Val { - let output: Val = bevy::math::I64Vec2::new(x, y).into(); + fn new(x: i64, y: i64) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::new(x, y).into(); output } /// Returns a vector that is equal to `self` rotated by 90 degrees. - fn perp(_self: Val) -> Val { - let output: Val = bevy::math::I64Vec2::perp( - _self.into_inner(), - ) + fn perp(_self: Val<::glam::I64Vec2>) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::perp(_self.into_inner()) .into(); output } /// The perpendicular dot product of `self` and `rhs`. /// Also known as the wedge product, 2D cross product, and determinant. - fn perp_dot(_self: Val, rhs: Val) -> i64 { - let output: i64 = bevy::math::I64Vec2::perp_dot( - _self.into_inner(), - rhs.into_inner(), - ) + fn perp_dot(_self: Val<::glam::I64Vec2>, rhs: Val<::glam::I64Vec2>) -> i64 { + let output: i64 = ::glam::I64Vec2::perp_dot(_self.into_inner(), rhs.into_inner()) .into(); output } fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Rem< + &::glam::I64Vec2, >>::rem(_self.into_inner(), &rhs) .into(); output } fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Rem< + ::glam::I64Vec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: i64) -> Val { - let output: Val = , rhs: i64) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Rem< i64, >>::rem(_self.into_inner(), rhs) .into(); @@ -9683,10 +8972,10 @@ impl bevy::math::I64Vec2 { /// This function will panic if any `rhs` element is 0 or the division results in overflow. /// [Euclidean division]: i64::rem_euclid fn rem_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::rem_euclid( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::rem_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -9697,10 +8986,10 @@ impl bevy::math::I64Vec2 { /// then this just rotation. This is what you usually want. Otherwise, /// it will be like a rotation with a multiplication by `self`'s length. fn rotate( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::rotate( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::rotate( _self.into_inner(), rhs.into_inner(), ) @@ -9710,10 +8999,10 @@ impl bevy::math::I64Vec2 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::saturating_add( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -9722,10 +9011,10 @@ impl bevy::math::I64Vec2 { } /// In other words this computes `[self.x.saturating_add_unsigned(rhs.x), self.y.saturating_add_unsigned(rhs.y), ..]`. fn saturating_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::saturating_add_unsigned( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::saturating_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -9735,10 +9024,10 @@ impl bevy::math::I64Vec2 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::saturating_div( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -9748,10 +9037,10 @@ impl bevy::math::I64Vec2 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::saturating_mul( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -9761,10 +9050,10 @@ impl bevy::math::I64Vec2 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::saturating_sub( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -9774,10 +9063,10 @@ impl bevy::math::I64Vec2 { /// Returns a vector containing the saturating subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.saturating_sub_unsigned(rhs.x), self.y.saturating_sub_unsigned(rhs.y), ..]`. fn saturating_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::saturating_sub_unsigned( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::saturating_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -9789,11 +9078,11 @@ impl bevy::math::I64Vec2 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::select( + mask: Val<::glam::BVec2>, + if_true: Val<::glam::I64Vec2>, + if_false: Val<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -9805,75 +9094,67 @@ impl bevy::math::I64Vec2 { /// - `0` if the number is zero /// - `1` if the number is positive /// - `-1` if the number is negative - fn signum(_self: Val) -> Val { - let output: Val = bevy::math::I64Vec2::signum( - _self.into_inner(), - ) + fn signum(_self: Val<::glam::I64Vec2>) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::signum(_self.into_inner()) .into(); output } /// Creates a vector with all elements set to `v`. - fn splat(v: i64) -> Val { - let output: Val = bevy::math::I64Vec2::splat(v).into(); + fn splat(v: i64) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::splat(v).into(); output } fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Sub< + &::glam::I64Vec2, >>::sub(_self.into_inner(), &rhs) .into(); output } fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Sub< + ::glam::I64Vec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: i64) -> Val { - let output: Val = , rhs: i64) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = <::glam::I64Vec2 as ::core::ops::Sub< i64, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y]` - fn to_array(_self: Ref) -> [i64; 2] { - let output: [i64; 2] = bevy::math::I64Vec2::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::I64Vec2>) -> [i64; 2] { + let output: [i64; 2] = ::glam::I64Vec2::to_array(&_self).into(); output } /// Creates a 2D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: i64) -> Val { - let output: Val = bevy::math::I64Vec2::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::I64Vec2>, x: i64) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::with_x(_self.into_inner(), x) .into(); output } /// Creates a 2D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: i64) -> Val { - let output: Val = bevy::math::I64Vec2::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::I64Vec2>, y: i64) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::with_y(_self.into_inner(), y) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::wrapping_add( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -9883,10 +9164,10 @@ impl bevy::math::I64Vec2 { /// Returns a vector containing the wrapping addition of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_add_unsigned(rhs.x), self.y.wrapping_add_unsigned(rhs.y), ..]`. fn wrapping_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::wrapping_add_unsigned( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::wrapping_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -9896,10 +9177,10 @@ impl bevy::math::I64Vec2 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::wrapping_div( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -9909,10 +9190,10 @@ impl bevy::math::I64Vec2 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::wrapping_mul( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -9922,10 +9203,10 @@ impl bevy::math::I64Vec2 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::wrapping_sub( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -9935,10 +9216,10 @@ impl bevy::math::I64Vec2 { /// Returns a vector containing the wrapping subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_sub_unsigned(rhs.x), self.y.wrapping_sub_unsigned(rhs.y), ..]`. fn wrapping_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec2::wrapping_sub_unsigned( + _self: Val<::glam::I64Vec2>, + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec2::wrapping_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -9952,103 +9233,92 @@ impl bevy::math::I64Vec2 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::I64Vec3 { +impl ::glam::I64Vec3 { /// Returns a vector containing the absolute value of each element of `self`. - fn abs(_self: Val) -> Val { - let output: Val = bevy::math::I64Vec3::abs( - _self.into_inner(), - ) + fn abs(_self: Val<::glam::I64Vec3>) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::abs(_self.into_inner()) .into(); output } fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Add< + &::glam::I64Vec3, >>::add(_self.into_inner(), &rhs) .into(); output } fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Add< + ::glam::I64Vec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: i64) -> Val { - let output: Val = , rhs: i64) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Add< i64, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec3(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec3::as_dvec3(&_self) - .into(); + fn as_dvec3(_self: Ref<::glam::I64Vec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::I64Vec3::as_dvec3(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec3(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec3::as_i16vec3(&_self) - .into(); + fn as_i16vec3(_self: Ref<::glam::I64Vec3>) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::I64Vec3::as_i16vec3(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec3(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec3::as_i8vec3(&_self) - .into(); + fn as_i8vec3(_self: Ref<::glam::I64Vec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::I64Vec3::as_i8vec3(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec3(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec3::as_ivec3(&_self) - .into(); + fn as_ivec3(_self: Ref<::glam::I64Vec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::I64Vec3::as_ivec3(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec3(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec3::as_u16vec3(&_self) - .into(); + fn as_u16vec3(_self: Ref<::glam::I64Vec3>) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::I64Vec3::as_u16vec3(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec3(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec3::as_u64vec3(&_self) - .into(); + fn as_u64vec3(_self: Ref<::glam::I64Vec3>) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::I64Vec3::as_u64vec3(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec3(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec3::as_u8vec3(&_self) - .into(); + fn as_u8vec3(_self: Ref<::glam::I64Vec3>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::I64Vec3::as_u8vec3(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec3(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec3::as_uvec3(&_self) - .into(); + fn as_uvec3(_self: Ref<::glam::I64Vec3>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::I64Vec3::as_uvec3(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec3(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec3::as_vec3(&_self).into(); + fn as_vec3(_self: Ref<::glam::I64Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::I64Vec3::as_vec3(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec3a(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec3::as_vec3a(&_self) - .into(); + fn as_vec3a(_self: Ref<::glam::I64Vec3>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::I64Vec3::as_vec3a(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::I64Vec3>) -> () { + let output: () = <::glam::I64Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -10059,11 +9329,11 @@ impl bevy::math::I64Vec3 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::clamp( + _self: Val<::glam::I64Vec3>, + min: Val<::glam::I64Vec3>, + max: Val<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -10071,8 +9341,8 @@ impl bevy::math::I64Vec3 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::I64Vec3>) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -10083,10 +9353,10 @@ impl bevy::math::I64Vec3 { /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::cmpeq( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::I64Vec3::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -10098,10 +9368,10 @@ impl bevy::math::I64Vec3 { /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::cmpge( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::I64Vec3::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -10113,10 +9383,10 @@ impl bevy::math::I64Vec3 { /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::cmpgt( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::I64Vec3::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -10128,10 +9398,10 @@ impl bevy::math::I64Vec3 { /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::cmple( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::I64Vec3::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -10143,10 +9413,10 @@ impl bevy::math::I64Vec3 { /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::cmplt( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::I64Vec3::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -10158,10 +9428,10 @@ impl bevy::math::I64Vec3 { /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::cmpne( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::I64Vec3::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -10170,10 +9440,10 @@ impl bevy::math::I64Vec3 { } /// Computes the cross product of `self` and `rhs`. fn cross( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::cross( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::cross( _self.into_inner(), rhs.into_inner(), ) @@ -10181,11 +9451,8 @@ impl bevy::math::I64Vec3 { output } /// Compute the squared euclidean distance between two points in space. - fn distance_squared( - _self: Val, - rhs: Val, - ) -> i64 { - let output: i64 = bevy::math::I64Vec3::distance_squared( + fn distance_squared(_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>) -> i64 { + let output: i64 = ::glam::I64Vec3::distance_squared( _self.into_inner(), rhs.into_inner(), ) @@ -10193,27 +9460,27 @@ impl bevy::math::I64Vec3 { output } fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Div< + &::glam::I64Vec3, >>::div(_self.into_inner(), &rhs) .into(); output } fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Div< + ::glam::I64Vec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: i64) -> Val { - let output: Val = , rhs: i64) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Div< i64, >>::div(_self.into_inner(), rhs) .into(); @@ -10223,10 +9490,10 @@ impl bevy::math::I64Vec3 { /// # Panics /// This function will panic if any `rhs` element is 0 or the division results in overflow. fn div_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::div_euclid( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -10234,17 +9501,17 @@ impl bevy::math::I64Vec3 { output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> i64 { - let output: i64 = bevy::math::I64Vec3::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::I64Vec3>, rhs: Val<::glam::I64Vec3>) -> i64 { + let output: i64 = ::glam::I64Vec3::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::dot_into_vec( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -10253,58 +9520,54 @@ impl bevy::math::I64Vec3 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> i64 { - let output: i64 = bevy::math::I64Vec3::element_product(_self.into_inner()) - .into(); + fn element_product(_self: Val<::glam::I64Vec3>) -> i64 { + let output: i64 = ::glam::I64Vec3::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> i64 { - let output: i64 = bevy::math::I64Vec3::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::I64Vec3>) -> i64 { + let output: i64 = ::glam::I64Vec3::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::I64Vec3>) -> bool { + let output: bool = <::glam::I64Vec3 as ::core::cmp::PartialEq< + ::glam::I64Vec3, >>::eq(&_self, &other) .into(); output } /// Creates a 4D vector from `self` and the given `w` value. - fn extend(_self: Val, w: i64) -> Val { - let output: Val = bevy::math::I64Vec3::extend( - _self.into_inner(), - w, - ) + fn extend(_self: Val<::glam::I64Vec3>, w: i64) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec3::extend(_self.into_inner(), w) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [i64; 3]) -> Val { - let output: Val = bevy::math::I64Vec3::from_array(a).into(); + fn from_array(a: [i64; 3]) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::from_array(a).into(); output } /// Returns a bitmask with the lowest 3 bits set to the sign bits from the elements of `self`. /// A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn is_negative_bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::I64Vec3::is_negative_bitmask(_self.into_inner()) + fn is_negative_bitmask(_self: Val<::glam::I64Vec3>) -> u32 { + let output: u32 = ::glam::I64Vec3::is_negative_bitmask(_self.into_inner()) .into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> i64 { - let output: i64 = bevy::math::I64Vec3::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::I64Vec3>) -> i64 { + let output: i64 = ::glam::I64Vec3::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::max( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::max( _self.into_inner(), rhs.into_inner(), ) @@ -10313,17 +9576,17 @@ impl bevy::math::I64Vec3 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> i64 { - let output: i64 = bevy::math::I64Vec3::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::I64Vec3>) -> i64 { + let output: i64 = ::glam::I64Vec3::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::min( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::min( _self.into_inner(), rhs.into_inner(), ) @@ -10332,71 +9595,71 @@ impl bevy::math::I64Vec3 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> i64 { - let output: i64 = bevy::math::I64Vec3::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::I64Vec3>) -> i64 { + let output: i64 = ::glam::I64Vec3::min_element(_self.into_inner()).into(); output } fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Mul< + &::glam::I64Vec3, >>::mul(_self.into_inner(), &rhs) .into(); output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Mul< + ::glam::I64Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: i64) -> Val { - let output: Val = , rhs: i64) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Mul< i64, >>::mul(_self.into_inner(), rhs) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::I64Vec3>) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); output } /// Creates a new vector. - fn new(x: i64, y: i64, z: i64) -> Val { - let output: Val = bevy::math::I64Vec3::new(x, y, z).into(); + fn new(x: i64, y: i64, z: i64) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::new(x, y, z).into(); output } fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Rem< + &::glam::I64Vec3, >>::rem(_self.into_inner(), &rhs) .into(); output } fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Rem< + ::glam::I64Vec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: i64) -> Val { - let output: Val = , rhs: i64) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Rem< i64, >>::rem(_self.into_inner(), rhs) .into(); @@ -10407,10 +9670,10 @@ impl bevy::math::I64Vec3 { /// This function will panic if any `rhs` element is 0 or the division results in overflow. /// [Euclidean division]: i64::rem_euclid fn rem_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::rem_euclid( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::rem_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -10420,10 +9683,10 @@ impl bevy::math::I64Vec3 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::saturating_add( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -10432,10 +9695,10 @@ impl bevy::math::I64Vec3 { } /// In other words this computes `[self.x.saturating_add_unsigned(rhs.x), self.y.saturating_add_unsigned(rhs.y), ..]`. fn saturating_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::saturating_add_unsigned( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::saturating_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -10445,10 +9708,10 @@ impl bevy::math::I64Vec3 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::saturating_div( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -10458,10 +9721,10 @@ impl bevy::math::I64Vec3 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::saturating_mul( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -10471,10 +9734,10 @@ impl bevy::math::I64Vec3 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::saturating_sub( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -10484,10 +9747,10 @@ impl bevy::math::I64Vec3 { /// Returns a vector containing the saturating subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.saturating_sub_unsigned(rhs.x), self.y.saturating_sub_unsigned(rhs.y), ..]`. fn saturating_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::saturating_sub_unsigned( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::saturating_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -10499,11 +9762,11 @@ impl bevy::math::I64Vec3 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::select( + mask: Val<::glam::BVec3>, + if_true: Val<::glam::I64Vec3>, + if_false: Val<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -10515,93 +9778,80 @@ impl bevy::math::I64Vec3 { /// - `0` if the number is zero /// - `1` if the number is positive /// - `-1` if the number is negative - fn signum(_self: Val) -> Val { - let output: Val = bevy::math::I64Vec3::signum( - _self.into_inner(), - ) + fn signum(_self: Val<::glam::I64Vec3>) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::signum(_self.into_inner()) .into(); output } /// Creates a vector with all elements set to `v`. - fn splat(v: i64) -> Val { - let output: Val = bevy::math::I64Vec3::splat(v).into(); + fn splat(v: i64) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::splat(v).into(); output } fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Sub< + &::glam::I64Vec3, >>::sub(_self.into_inner(), &rhs) .into(); output } fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Sub< + ::glam::I64Vec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: i64) -> Val { - let output: Val = , rhs: i64) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = <::glam::I64Vec3 as ::core::ops::Sub< i64, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y, z]` - fn to_array(_self: Ref) -> [i64; 3] { - let output: [i64; 3] = bevy::math::I64Vec3::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::I64Vec3>) -> [i64; 3] { + let output: [i64; 3] = ::glam::I64Vec3::to_array(&_self).into(); output } /// Creates a 2D vector from the `x` and `y` elements of `self`, discarding `z`. /// Truncation may also be performed by using [`self.xy()`][crate::swizzles::Vec3Swizzles::xy()]. - fn truncate(_self: Val) -> Val { - let output: Val = bevy::math::I64Vec3::truncate( - _self.into_inner(), - ) + fn truncate(_self: Val<::glam::I64Vec3>) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::I64Vec3::truncate(_self.into_inner()) .into(); output } /// Creates a 3D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: i64) -> Val { - let output: Val = bevy::math::I64Vec3::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::I64Vec3>, x: i64) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::with_x(_self.into_inner(), x) .into(); output } /// Creates a 3D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: i64) -> Val { - let output: Val = bevy::math::I64Vec3::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::I64Vec3>, y: i64) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::with_y(_self.into_inner(), y) .into(); output } /// Creates a 3D vector from `self` with the given value of `z`. - fn with_z(_self: Val, z: i64) -> Val { - let output: Val = bevy::math::I64Vec3::with_z( - _self.into_inner(), - z, - ) + fn with_z(_self: Val<::glam::I64Vec3>, z: i64) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::with_z(_self.into_inner(), z) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::wrapping_add( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -10611,10 +9861,10 @@ impl bevy::math::I64Vec3 { /// Returns a vector containing the wrapping addition of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_add_unsigned(rhs.x), self.y.wrapping_add_unsigned(rhs.y), ..]`. fn wrapping_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::wrapping_add_unsigned( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::wrapping_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -10624,10 +9874,10 @@ impl bevy::math::I64Vec3 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::wrapping_div( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -10637,10 +9887,10 @@ impl bevy::math::I64Vec3 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::wrapping_mul( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -10650,10 +9900,10 @@ impl bevy::math::I64Vec3 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::wrapping_sub( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -10663,10 +9913,10 @@ impl bevy::math::I64Vec3 { /// Returns a vector containing the wrapping subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_sub_unsigned(rhs.x), self.y.wrapping_sub_unsigned(rhs.y), ..]`. fn wrapping_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec3::wrapping_sub_unsigned( + _self: Val<::glam::I64Vec3>, + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec3::wrapping_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -10680,97 +9930,87 @@ impl bevy::math::I64Vec3 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::I64Vec4 { +impl ::glam::I64Vec4 { /// Returns a vector containing the absolute value of each element of `self`. - fn abs(_self: Val) -> Val { - let output: Val = bevy::math::I64Vec4::abs( - _self.into_inner(), - ) + fn abs(_self: Val<::glam::I64Vec4>) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::abs(_self.into_inner()) .into(); output } fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Add< + &::glam::I64Vec4, >>::add(_self.into_inner(), &rhs) .into(); output } fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Add< + ::glam::I64Vec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: i64) -> Val { - let output: Val = , rhs: i64) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Add< i64, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec4(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec4::as_dvec4(&_self) - .into(); + fn as_dvec4(_self: Ref<::glam::I64Vec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::I64Vec4::as_dvec4(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec4(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec4::as_i16vec4(&_self) - .into(); + fn as_i16vec4(_self: Ref<::glam::I64Vec4>) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::I64Vec4::as_i16vec4(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec4(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec4::as_i8vec4(&_self) - .into(); + fn as_i8vec4(_self: Ref<::glam::I64Vec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::I64Vec4::as_i8vec4(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec4(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec4::as_ivec4(&_self) - .into(); + fn as_ivec4(_self: Ref<::glam::I64Vec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::I64Vec4::as_ivec4(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec4(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec4::as_u16vec4(&_self) - .into(); + fn as_u16vec4(_self: Ref<::glam::I64Vec4>) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::I64Vec4::as_u16vec4(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec4(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec4::as_u64vec4(&_self) - .into(); + fn as_u64vec4(_self: Ref<::glam::I64Vec4>) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::I64Vec4::as_u64vec4(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec4(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec4::as_u8vec4(&_self) - .into(); + fn as_u8vec4(_self: Ref<::glam::I64Vec4>) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::I64Vec4::as_u8vec4(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec4(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec4::as_uvec4(&_self) - .into(); + fn as_uvec4(_self: Ref<::glam::I64Vec4>) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::I64Vec4::as_uvec4(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec4(_self: Ref) -> Val { - let output: Val = bevy::math::I64Vec4::as_vec4(&_self).into(); + fn as_vec4(_self: Ref<::glam::I64Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::I64Vec4::as_vec4(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::I64Vec4>) -> () { + let output: () = <::glam::I64Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -10781,11 +10021,11 @@ impl bevy::math::I64Vec4 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::clamp( + _self: Val<::glam::I64Vec4>, + min: Val<::glam::I64Vec4>, + max: Val<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -10793,8 +10033,8 @@ impl bevy::math::I64Vec4 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::I64Vec4>) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -10805,10 +10045,10 @@ impl bevy::math::I64Vec4 { /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::cmpeq( + _self: Val<::glam::I64Vec4>, + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::I64Vec4::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -10820,10 +10060,10 @@ impl bevy::math::I64Vec4 { /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::cmpge( + _self: Val<::glam::I64Vec4>, + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::I64Vec4::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -10835,10 +10075,10 @@ impl bevy::math::I64Vec4 { /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::cmpgt( + _self: Val<::glam::I64Vec4>, + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::I64Vec4::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -10850,10 +10090,10 @@ impl bevy::math::I64Vec4 { /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::cmple( + _self: Val<::glam::I64Vec4>, + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::I64Vec4::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -10865,10 +10105,10 @@ impl bevy::math::I64Vec4 { /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::cmplt( + _self: Val<::glam::I64Vec4>, + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::I64Vec4::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -10880,10 +10120,10 @@ impl bevy::math::I64Vec4 { /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::cmpne( + _self: Val<::glam::I64Vec4>, + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::I64Vec4::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -10891,11 +10131,8 @@ impl bevy::math::I64Vec4 { output } /// Compute the squared euclidean distance between two points in space. - fn distance_squared( - _self: Val, - rhs: Val, - ) -> i64 { - let output: i64 = bevy::math::I64Vec4::distance_squared( + fn distance_squared(_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>) -> i64 { + let output: i64 = ::glam::I64Vec4::distance_squared( _self.into_inner(), rhs.into_inner(), ) @@ -10903,27 +10140,27 @@ impl bevy::math::I64Vec4 { output } fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Div< + &::glam::I64Vec4, >>::div(_self.into_inner(), &rhs) .into(); output } fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Div< + ::glam::I64Vec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: i64) -> Val { - let output: Val = , rhs: i64) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Div< i64, >>::div(_self.into_inner(), rhs) .into(); @@ -10933,10 +10170,10 @@ impl bevy::math::I64Vec4 { /// # Panics /// This function will panic if any `rhs` element is 0 or the division results in overflow. fn div_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::div_euclid( + _self: Val<::glam::I64Vec4>, + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -10944,17 +10181,17 @@ impl bevy::math::I64Vec4 { output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> i64 { - let output: i64 = bevy::math::I64Vec4::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::I64Vec4>, rhs: Val<::glam::I64Vec4>) -> i64 { + let output: i64 = ::glam::I64Vec4::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::dot_into_vec( + _self: Val<::glam::I64Vec4>, + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -10963,49 +10200,48 @@ impl bevy::math::I64Vec4 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> i64 { - let output: i64 = bevy::math::I64Vec4::element_product(_self.into_inner()) - .into(); + fn element_product(_self: Val<::glam::I64Vec4>) -> i64 { + let output: i64 = ::glam::I64Vec4::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> i64 { - let output: i64 = bevy::math::I64Vec4::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::I64Vec4>) -> i64 { + let output: i64 = ::glam::I64Vec4::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::I64Vec4>) -> bool { + let output: bool = <::glam::I64Vec4 as ::core::cmp::PartialEq< + ::glam::I64Vec4, >>::eq(&_self, &other) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [i64; 4]) -> Val { - let output: Val = bevy::math::I64Vec4::from_array(a).into(); + fn from_array(a: [i64; 4]) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::from_array(a).into(); output } /// Returns a bitmask with the lowest 4 bits set to the sign bits from the elements of `self`. /// A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn is_negative_bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::I64Vec4::is_negative_bitmask(_self.into_inner()) + fn is_negative_bitmask(_self: Val<::glam::I64Vec4>) -> u32 { + let output: u32 = ::glam::I64Vec4::is_negative_bitmask(_self.into_inner()) .into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> i64 { - let output: i64 = bevy::math::I64Vec4::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::I64Vec4>) -> i64 { + let output: i64 = ::glam::I64Vec4::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::max( + _self: Val<::glam::I64Vec4>, + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::max( _self.into_inner(), rhs.into_inner(), ) @@ -11014,17 +10250,17 @@ impl bevy::math::I64Vec4 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> i64 { - let output: i64 = bevy::math::I64Vec4::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::I64Vec4>) -> i64 { + let output: i64 = ::glam::I64Vec4::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::min( + _self: Val<::glam::I64Vec4>, + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::min( _self.into_inner(), rhs.into_inner(), ) @@ -11033,72 +10269,71 @@ impl bevy::math::I64Vec4 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> i64 { - let output: i64 = bevy::math::I64Vec4::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::I64Vec4>) -> i64 { + let output: i64 = ::glam::I64Vec4::min_element(_self.into_inner()).into(); output } fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Mul< + &::glam::I64Vec4, >>::mul(_self.into_inner(), &rhs) .into(); output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Mul< + ::glam::I64Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: i64) -> Val { - let output: Val = , rhs: i64) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Mul< i64, >>::mul(_self.into_inner(), rhs) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::I64Vec4>) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); output } /// Creates a new vector. - fn new(x: i64, y: i64, z: i64, w: i64) -> Val { - let output: Val = bevy::math::I64Vec4::new(x, y, z, w) - .into(); + fn new(x: i64, y: i64, z: i64, w: i64) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::new(x, y, z, w).into(); output } fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Rem< + &::glam::I64Vec4, >>::rem(_self.into_inner(), &rhs) .into(); output } fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Rem< + ::glam::I64Vec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: i64) -> Val { - let output: Val = , rhs: i64) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Rem< i64, >>::rem(_self.into_inner(), rhs) .into(); @@ -11109,10 +10344,10 @@ impl bevy::math::I64Vec4 { /// This function will panic if any `rhs` element is 0 or the division results in overflow. /// [Euclidean division]: i64::rem_euclid fn rem_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::rem_euclid( + _self: Val<::glam::I64Vec4>, + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::rem_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -11122,10 +10357,10 @@ impl bevy::math::I64Vec4 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::saturating_add( + _self: Val<::glam::I64Vec4>, + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -11134,10 +10369,10 @@ impl bevy::math::I64Vec4 { } /// In other words this computes `[self.x.saturating_add_unsigned(rhs.x), self.y.saturating_add_unsigned(rhs.y), ..]`. fn saturating_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::saturating_add_unsigned( + _self: Val<::glam::I64Vec4>, + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::saturating_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -11147,10 +10382,10 @@ impl bevy::math::I64Vec4 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::saturating_div( + _self: Val<::glam::I64Vec4>, + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -11160,10 +10395,10 @@ impl bevy::math::I64Vec4 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::saturating_mul( + _self: Val<::glam::I64Vec4>, + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -11173,10 +10408,10 @@ impl bevy::math::I64Vec4 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::saturating_sub( + _self: Val<::glam::I64Vec4>, + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -11186,10 +10421,10 @@ impl bevy::math::I64Vec4 { /// Returns a vector containing the saturating subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.saturating_sub_unsigned(rhs.x), self.y.saturating_sub_unsigned(rhs.y), ..]`. fn saturating_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::saturating_sub_unsigned( + _self: Val<::glam::I64Vec4>, + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::saturating_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -11201,11 +10436,11 @@ impl bevy::math::I64Vec4 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::select( + mask: Val<::glam::BVec4>, + if_true: Val<::glam::I64Vec4>, + if_false: Val<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -11217,102 +10452,86 @@ impl bevy::math::I64Vec4 { /// - `0` if the number is zero /// - `1` if the number is positive /// - `-1` if the number is negative - fn signum(_self: Val) -> Val { - let output: Val = bevy::math::I64Vec4::signum( - _self.into_inner(), - ) + fn signum(_self: Val<::glam::I64Vec4>) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::signum(_self.into_inner()) .into(); output } /// Creates a vector with all elements set to `v`. - fn splat(v: i64) -> Val { - let output: Val = bevy::math::I64Vec4::splat(v).into(); + fn splat(v: i64) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::splat(v).into(); output } fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Sub< + &::glam::I64Vec4, >>::sub(_self.into_inner(), &rhs) .into(); output } fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Sub< + ::glam::I64Vec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: i64) -> Val { - let output: Val = , rhs: i64) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = <::glam::I64Vec4 as ::core::ops::Sub< i64, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y, z, w]` - fn to_array(_self: Ref) -> [i64; 4] { - let output: [i64; 4] = bevy::math::I64Vec4::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::I64Vec4>) -> [i64; 4] { + let output: [i64; 4] = ::glam::I64Vec4::to_array(&_self).into(); output } /// Creates a 3D vector from the `x`, `y` and `z` elements of `self`, discarding `w`. /// Truncation to [`I64Vec3`] may also be performed by using [`self.xyz()`][crate::swizzles::Vec4Swizzles::xyz()]. - fn truncate(_self: Val) -> Val { - let output: Val = bevy::math::I64Vec4::truncate( - _self.into_inner(), - ) + fn truncate(_self: Val<::glam::I64Vec4>) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::I64Vec4::truncate(_self.into_inner()) .into(); output } /// Creates a 4D vector from `self` with the given value of `w`. - fn with_w(_self: Val, w: i64) -> Val { - let output: Val = bevy::math::I64Vec4::with_w( - _self.into_inner(), - w, - ) + fn with_w(_self: Val<::glam::I64Vec4>, w: i64) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::with_w(_self.into_inner(), w) .into(); output } /// Creates a 4D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: i64) -> Val { - let output: Val = bevy::math::I64Vec4::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::I64Vec4>, x: i64) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::with_x(_self.into_inner(), x) .into(); output } /// Creates a 4D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: i64) -> Val { - let output: Val = bevy::math::I64Vec4::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::I64Vec4>, y: i64) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::with_y(_self.into_inner(), y) .into(); output } /// Creates a 4D vector from `self` with the given value of `z`. - fn with_z(_self: Val, z: i64) -> Val { - let output: Val = bevy::math::I64Vec4::with_z( - _self.into_inner(), - z, - ) + fn with_z(_self: Val<::glam::I64Vec4>, z: i64) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::with_z(_self.into_inner(), z) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::wrapping_add( + _self: Val<::glam::I64Vec4>, + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -11322,10 +10541,10 @@ impl bevy::math::I64Vec4 { /// Returns a vector containing the wrapping addition of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_add_unsigned(rhs.x), self.y.wrapping_add_unsigned(rhs.y), ..]`. fn wrapping_add_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::wrapping_add_unsigned( + _self: Val<::glam::I64Vec4>, + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::wrapping_add_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -11335,10 +10554,10 @@ impl bevy::math::I64Vec4 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::wrapping_div( + _self: Val<::glam::I64Vec4>, + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -11348,10 +10567,10 @@ impl bevy::math::I64Vec4 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::wrapping_mul( + _self: Val<::glam::I64Vec4>, + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -11361,10 +10580,10 @@ impl bevy::math::I64Vec4 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::wrapping_sub( + _self: Val<::glam::I64Vec4>, + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -11374,10 +10593,10 @@ impl bevy::math::I64Vec4 { /// Returns a vector containing the wrapping subtraction of `self` and unsigned vector `rhs`. /// In other words this computes `[self.x.wrapping_sub_unsigned(rhs.x), self.y.wrapping_sub_unsigned(rhs.y), ..]`. fn wrapping_sub_unsigned( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::I64Vec4::wrapping_sub_unsigned( + _self: Val<::glam::I64Vec4>, + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::I64Vec4::wrapping_sub_unsigned( _self.into_inner(), rhs.into_inner(), ) @@ -11391,87 +10610,75 @@ impl bevy::math::I64Vec4 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::UVec2 { - fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::UVec2>) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Add< + &::glam::UVec2, >>::add(_self.into_inner(), &rhs) .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::UVec2>) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Add< + ::glam::UVec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: u32) -> Val { - let output: Val = , rhs: u32) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Add< u32, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec2(_self: Ref) -> Val { - let output: Val = bevy::math::UVec2::as_dvec2(&_self).into(); + fn as_dvec2(_self: Ref<::glam::UVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::UVec2::as_dvec2(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec2(_self: Ref) -> Val { - let output: Val = bevy::math::UVec2::as_i16vec2(&_self) - .into(); + fn as_i16vec2(_self: Ref<::glam::UVec2>) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::UVec2::as_i16vec2(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec2(_self: Ref) -> Val { - let output: Val = bevy::math::UVec2::as_i64vec2(&_self) - .into(); + fn as_i64vec2(_self: Ref<::glam::UVec2>) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::UVec2::as_i64vec2(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec2(_self: Ref) -> Val { - let output: Val = bevy::math::UVec2::as_i8vec2(&_self) - .into(); + fn as_i8vec2(_self: Ref<::glam::UVec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::UVec2::as_i8vec2(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec2(_self: Ref) -> Val { - let output: Val = bevy::math::UVec2::as_ivec2(&_self).into(); + fn as_ivec2(_self: Ref<::glam::UVec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::UVec2::as_ivec2(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec2(_self: Ref) -> Val { - let output: Val = bevy::math::UVec2::as_u16vec2(&_self) - .into(); + fn as_u16vec2(_self: Ref<::glam::UVec2>) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::UVec2::as_u16vec2(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec2(_self: Ref) -> Val { - let output: Val = bevy::math::UVec2::as_u64vec2(&_self) - .into(); + fn as_u64vec2(_self: Ref<::glam::UVec2>) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::UVec2::as_u64vec2(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec2(_self: Ref) -> Val { - let output: Val = bevy::math::UVec2::as_u8vec2(&_self) - .into(); + fn as_u8vec2(_self: Ref<::glam::UVec2>) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::UVec2::as_u8vec2(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec2(_self: Ref) -> Val { - let output: Val = bevy::math::UVec2::as_vec2(&_self).into(); + fn as_vec2(_self: Ref<::glam::UVec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::UVec2::as_vec2(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::UVec2>) -> () { + let output: () = <::glam::UVec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -11482,11 +10689,11 @@ impl bevy::math::UVec2 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::UVec2::clamp( + _self: Val<::glam::UVec2>, + min: Val<::glam::UVec2>, + max: Val<::glam::UVec2>, + ) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::UVec2::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -11494,8 +10701,8 @@ impl bevy::math::UVec2 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::UVec2>) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -11505,11 +10712,8 @@ impl bevy::math::UVec2 { /// `self` and `rhs`. /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. - fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec2::cmpeq( + fn cmpeq(_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::UVec2::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -11520,11 +10724,8 @@ impl bevy::math::UVec2 { /// `self` and `rhs`. /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. - fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec2::cmpge( + fn cmpge(_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::UVec2::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -11535,11 +10736,8 @@ impl bevy::math::UVec2 { /// `self` and `rhs`. /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. - fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec2::cmpgt( + fn cmpgt(_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::UVec2::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -11550,11 +10748,8 @@ impl bevy::math::UVec2 { /// `self` and `rhs`. /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. - fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec2::cmple( + fn cmple(_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::UVec2::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -11565,11 +10760,8 @@ impl bevy::math::UVec2 { /// `self` and `rhs`. /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. - fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec2::cmplt( + fn cmplt(_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::UVec2::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -11580,56 +10772,47 @@ impl bevy::math::UVec2 { /// `self` and `rhs`. /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. - fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec2::cmpne( + fn cmpne(_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::UVec2::cmpne( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::UVec2>) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Div< + &::glam::UVec2, >>::div(_self.into_inner(), &rhs) .into(); output } - fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::UVec2>) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Div< + ::glam::UVec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: u32) -> Val { - let output: Val = , rhs: u32) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Div< u32, >>::div(_self.into_inner(), rhs) .into(); output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> u32 { - let output: u32 = bevy::math::UVec2::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>) -> u32 { + let output: u32 = ::glam::UVec2::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec2::dot_into_vec( + _self: Val<::glam::UVec2>, + rhs: Val<::glam::UVec2>, + ) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::UVec2::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -11638,49 +10821,43 @@ impl bevy::math::UVec2 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> u32 { - let output: u32 = bevy::math::UVec2::element_product(_self.into_inner()).into(); + fn element_product(_self: Val<::glam::UVec2>) -> u32 { + let output: u32 = ::glam::UVec2::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> u32 { - let output: u32 = bevy::math::UVec2::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::UVec2>) -> u32 { + let output: u32 = ::glam::UVec2::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::UVec2>) -> bool { + let output: bool = <::glam::UVec2 as ::core::cmp::PartialEq< + ::glam::UVec2, >>::eq(&_self, &other) .into(); output } /// Creates a 3D vector from `self` and the given `z` value. - fn extend(_self: Val, z: u32) -> Val { - let output: Val = bevy::math::UVec2::extend( - _self.into_inner(), - z, - ) + fn extend(_self: Val<::glam::UVec2>, z: u32) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec2::extend(_self.into_inner(), z) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [u32; 2]) -> Val { - let output: Val = bevy::math::UVec2::from_array(a).into(); + fn from_array(a: [u32; 2]) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::UVec2::from_array(a).into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> u32 { - let output: u32 = bevy::math::UVec2::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::UVec2>) -> u32 { + let output: u32 = ::glam::UVec2::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. - fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec2::max( + fn max(_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::UVec2::max( _self.into_inner(), rhs.into_inner(), ) @@ -11689,17 +10866,14 @@ impl bevy::math::UVec2 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> u32 { - let output: u32 = bevy::math::UVec2::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::UVec2>) -> u32 { + let output: u32 = ::glam::UVec2::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. - fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec2::min( + fn min(_self: Val<::glam::UVec2>, rhs: Val<::glam::UVec2>) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::UVec2::min( _self.into_inner(), rhs.into_inner(), ) @@ -11708,64 +10882,52 @@ impl bevy::math::UVec2 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> u32 { - let output: u32 = bevy::math::UVec2::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::UVec2>) -> u32 { + let output: u32 = ::glam::UVec2::min_element(_self.into_inner()).into(); output } - fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::UVec2>) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Mul< + &::glam::UVec2, >>::mul(_self.into_inner(), &rhs) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::UVec2>) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Mul< + ::glam::UVec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: u32) -> Val { - let output: Val = , rhs: u32) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Mul< u32, >>::mul(_self.into_inner(), rhs) .into(); output } /// Creates a new vector. - fn new(x: u32, y: u32) -> Val { - let output: Val = bevy::math::UVec2::new(x, y).into(); + fn new(x: u32, y: u32) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::UVec2::new(x, y).into(); output } - fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::UVec2>) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Rem< + &::glam::UVec2, >>::rem(_self.into_inner(), &rhs) .into(); output } - fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::UVec2>) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Rem< + ::glam::UVec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: u32) -> Val { - let output: Val = , rhs: u32) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Rem< u32, >>::rem(_self.into_inner(), rhs) .into(); @@ -11774,10 +10936,10 @@ impl bevy::math::UVec2 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec2::saturating_add( + _self: Val<::glam::UVec2>, + rhs: Val<::glam::UVec2>, + ) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::UVec2::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -11787,10 +10949,10 @@ impl bevy::math::UVec2 { /// Returns a vector containing the saturating addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.saturating_add_signed(rhs.x), self.y.saturating_add_signed(rhs.y), ..]`. fn saturating_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec2::saturating_add_signed( + _self: Val<::glam::UVec2>, + rhs: Val<::glam::IVec2>, + ) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::UVec2::saturating_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -11800,10 +10962,10 @@ impl bevy::math::UVec2 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec2::saturating_div( + _self: Val<::glam::UVec2>, + rhs: Val<::glam::UVec2>, + ) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::UVec2::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -11813,10 +10975,10 @@ impl bevy::math::UVec2 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec2::saturating_mul( + _self: Val<::glam::UVec2>, + rhs: Val<::glam::UVec2>, + ) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::UVec2::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -11826,10 +10988,10 @@ impl bevy::math::UVec2 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec2::saturating_sub( + _self: Val<::glam::UVec2>, + rhs: Val<::glam::UVec2>, + ) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::UVec2::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -11841,11 +11003,11 @@ impl bevy::math::UVec2 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::UVec2::select( + mask: Val<::glam::BVec2>, + if_true: Val<::glam::UVec2>, + if_false: Val<::glam::UVec2>, + ) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::UVec2::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -11854,67 +11016,55 @@ impl bevy::math::UVec2 { output } /// Creates a vector with all elements set to `v`. - fn splat(v: u32) -> Val { - let output: Val = bevy::math::UVec2::splat(v).into(); + fn splat(v: u32) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::UVec2::splat(v).into(); output } - fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::UVec2>) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Sub< + &::glam::UVec2, >>::sub(_self.into_inner(), &rhs) .into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::UVec2>) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Sub< + ::glam::UVec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: u32) -> Val { - let output: Val = , rhs: u32) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = <::glam::UVec2 as ::core::ops::Sub< u32, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y]` - fn to_array(_self: Ref) -> [u32; 2] { - let output: [u32; 2] = bevy::math::UVec2::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::UVec2>) -> [u32; 2] { + let output: [u32; 2] = ::glam::UVec2::to_array(&_self).into(); output } /// Creates a 2D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: u32) -> Val { - let output: Val = bevy::math::UVec2::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::UVec2>, x: u32) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::UVec2::with_x(_self.into_inner(), x) .into(); output } /// Creates a 2D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: u32) -> Val { - let output: Val = bevy::math::UVec2::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::UVec2>, y: u32) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::UVec2::with_y(_self.into_inner(), y) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec2::wrapping_add( + _self: Val<::glam::UVec2>, + rhs: Val<::glam::UVec2>, + ) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::UVec2::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -11924,10 +11074,10 @@ impl bevy::math::UVec2 { /// Returns a vector containing the wrapping addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.wrapping_add_signed(rhs.x), self.y.wrapping_add_signed(rhs.y), ..]`. fn wrapping_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec2::wrapping_add_signed( + _self: Val<::glam::UVec2>, + rhs: Val<::glam::IVec2>, + ) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::UVec2::wrapping_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -11937,10 +11087,10 @@ impl bevy::math::UVec2 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec2::wrapping_div( + _self: Val<::glam::UVec2>, + rhs: Val<::glam::UVec2>, + ) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::UVec2::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -11950,10 +11100,10 @@ impl bevy::math::UVec2 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec2::wrapping_mul( + _self: Val<::glam::UVec2>, + rhs: Val<::glam::UVec2>, + ) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::UVec2::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -11963,10 +11113,10 @@ impl bevy::math::UVec2 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec2::wrapping_sub( + _self: Val<::glam::UVec2>, + rhs: Val<::glam::UVec2>, + ) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::UVec2::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -11980,92 +11130,80 @@ impl bevy::math::UVec2 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::UVec3 { - fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::UVec3>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Add< + &::glam::UVec3, >>::add(_self.into_inner(), &rhs) .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::UVec3>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Add< + ::glam::UVec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: u32) -> Val { - let output: Val = , rhs: u32) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Add< u32, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec3(_self: Ref) -> Val { - let output: Val = bevy::math::UVec3::as_dvec3(&_self).into(); + fn as_dvec3(_self: Ref<::glam::UVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::UVec3::as_dvec3(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec3(_self: Ref) -> Val { - let output: Val = bevy::math::UVec3::as_i16vec3(&_self) - .into(); + fn as_i16vec3(_self: Ref<::glam::UVec3>) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::UVec3::as_i16vec3(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec3(_self: Ref) -> Val { - let output: Val = bevy::math::UVec3::as_i64vec3(&_self) - .into(); + fn as_i64vec3(_self: Ref<::glam::UVec3>) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::UVec3::as_i64vec3(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec3(_self: Ref) -> Val { - let output: Val = bevy::math::UVec3::as_i8vec3(&_self) - .into(); + fn as_i8vec3(_self: Ref<::glam::UVec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::UVec3::as_i8vec3(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec3(_self: Ref) -> Val { - let output: Val = bevy::math::UVec3::as_ivec3(&_self).into(); + fn as_ivec3(_self: Ref<::glam::UVec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::UVec3::as_ivec3(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec3(_self: Ref) -> Val { - let output: Val = bevy::math::UVec3::as_u16vec3(&_self) - .into(); + fn as_u16vec3(_self: Ref<::glam::UVec3>) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::UVec3::as_u16vec3(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec3(_self: Ref) -> Val { - let output: Val = bevy::math::UVec3::as_u64vec3(&_self) - .into(); + fn as_u64vec3(_self: Ref<::glam::UVec3>) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::UVec3::as_u64vec3(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec3(_self: Ref) -> Val { - let output: Val = bevy::math::UVec3::as_u8vec3(&_self) - .into(); + fn as_u8vec3(_self: Ref<::glam::UVec3>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::UVec3::as_u8vec3(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec3(_self: Ref) -> Val { - let output: Val = bevy::math::UVec3::as_vec3(&_self).into(); + fn as_vec3(_self: Ref<::glam::UVec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::UVec3::as_vec3(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec3a(_self: Ref) -> Val { - let output: Val = bevy::math::UVec3::as_vec3a(&_self).into(); + fn as_vec3a(_self: Ref<::glam::UVec3>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::UVec3::as_vec3a(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::UVec3>) -> () { + let output: () = <::glam::UVec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -12076,11 +11214,11 @@ impl bevy::math::UVec3 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::UVec3::clamp( + _self: Val<::glam::UVec3>, + min: Val<::glam::UVec3>, + max: Val<::glam::UVec3>, + ) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec3::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -12088,8 +11226,8 @@ impl bevy::math::UVec3 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::UVec3>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -12099,11 +11237,8 @@ impl bevy::math::UVec3 { /// `self` and `rhs`. /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. - fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec3::cmpeq( + fn cmpeq(_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::UVec3::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -12114,11 +11249,8 @@ impl bevy::math::UVec3 { /// `self` and `rhs`. /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. - fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec3::cmpge( + fn cmpge(_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::UVec3::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -12129,11 +11261,8 @@ impl bevy::math::UVec3 { /// `self` and `rhs`. /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. - fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec3::cmpgt( + fn cmpgt(_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::UVec3::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -12144,11 +11273,8 @@ impl bevy::math::UVec3 { /// `self` and `rhs`. /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. - fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec3::cmple( + fn cmple(_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::UVec3::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -12159,11 +11285,8 @@ impl bevy::math::UVec3 { /// `self` and `rhs`. /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. - fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec3::cmplt( + fn cmplt(_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::UVec3::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -12174,11 +11297,8 @@ impl bevy::math::UVec3 { /// `self` and `rhs`. /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. - fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec3::cmpne( + fn cmpne(_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::UVec3::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -12186,56 +11306,47 @@ impl bevy::math::UVec3 { output } /// Computes the cross product of `self` and `rhs`. - fn cross( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec3::cross( + fn cross(_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec3::cross( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::UVec3>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Div< + &::glam::UVec3, >>::div(_self.into_inner(), &rhs) .into(); output } - fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::UVec3>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Div< + ::glam::UVec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: u32) -> Val { - let output: Val = , rhs: u32) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Div< u32, >>::div(_self.into_inner(), rhs) .into(); output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> u32 { - let output: u32 = bevy::math::UVec3::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>) -> u32 { + let output: u32 = ::glam::UVec3::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec3::dot_into_vec( + _self: Val<::glam::UVec3>, + rhs: Val<::glam::UVec3>, + ) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec3::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -12244,49 +11355,43 @@ impl bevy::math::UVec3 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> u32 { - let output: u32 = bevy::math::UVec3::element_product(_self.into_inner()).into(); + fn element_product(_self: Val<::glam::UVec3>) -> u32 { + let output: u32 = ::glam::UVec3::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> u32 { - let output: u32 = bevy::math::UVec3::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::UVec3>) -> u32 { + let output: u32 = ::glam::UVec3::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::UVec3>) -> bool { + let output: bool = <::glam::UVec3 as ::core::cmp::PartialEq< + ::glam::UVec3, >>::eq(&_self, &other) .into(); output } /// Creates a 4D vector from `self` and the given `w` value. - fn extend(_self: Val, w: u32) -> Val { - let output: Val = bevy::math::UVec3::extend( - _self.into_inner(), - w, - ) + fn extend(_self: Val<::glam::UVec3>, w: u32) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::UVec3::extend(_self.into_inner(), w) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [u32; 3]) -> Val { - let output: Val = bevy::math::UVec3::from_array(a).into(); + fn from_array(a: [u32; 3]) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec3::from_array(a).into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> u32 { - let output: u32 = bevy::math::UVec3::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::UVec3>) -> u32 { + let output: u32 = ::glam::UVec3::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. - fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec3::max( + fn max(_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec3::max( _self.into_inner(), rhs.into_inner(), ) @@ -12295,17 +11400,14 @@ impl bevy::math::UVec3 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> u32 { - let output: u32 = bevy::math::UVec3::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::UVec3>) -> u32 { + let output: u32 = ::glam::UVec3::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. - fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec3::min( + fn min(_self: Val<::glam::UVec3>, rhs: Val<::glam::UVec3>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec3::min( _self.into_inner(), rhs.into_inner(), ) @@ -12314,64 +11416,52 @@ impl bevy::math::UVec3 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> u32 { - let output: u32 = bevy::math::UVec3::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::UVec3>) -> u32 { + let output: u32 = ::glam::UVec3::min_element(_self.into_inner()).into(); output } - fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::UVec3>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Mul< + &::glam::UVec3, >>::mul(_self.into_inner(), &rhs) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::UVec3>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Mul< + ::glam::UVec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: u32) -> Val { - let output: Val = , rhs: u32) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Mul< u32, >>::mul(_self.into_inner(), rhs) .into(); output } /// Creates a new vector. - fn new(x: u32, y: u32, z: u32) -> Val { - let output: Val = bevy::math::UVec3::new(x, y, z).into(); + fn new(x: u32, y: u32, z: u32) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec3::new(x, y, z).into(); output } - fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::UVec3>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Rem< + &::glam::UVec3, >>::rem(_self.into_inner(), &rhs) .into(); output } - fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::UVec3>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Rem< + ::glam::UVec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: u32) -> Val { - let output: Val = , rhs: u32) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Rem< u32, >>::rem(_self.into_inner(), rhs) .into(); @@ -12380,10 +11470,10 @@ impl bevy::math::UVec3 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec3::saturating_add( + _self: Val<::glam::UVec3>, + rhs: Val<::glam::UVec3>, + ) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec3::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -12393,10 +11483,10 @@ impl bevy::math::UVec3 { /// Returns a vector containing the saturating addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.saturating_add_signed(rhs.x), self.y.saturating_add_signed(rhs.y), ..]`. fn saturating_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec3::saturating_add_signed( + _self: Val<::glam::UVec3>, + rhs: Val<::glam::IVec3>, + ) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec3::saturating_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -12406,10 +11496,10 @@ impl bevy::math::UVec3 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec3::saturating_div( + _self: Val<::glam::UVec3>, + rhs: Val<::glam::UVec3>, + ) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec3::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -12419,10 +11509,10 @@ impl bevy::math::UVec3 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec3::saturating_mul( + _self: Val<::glam::UVec3>, + rhs: Val<::glam::UVec3>, + ) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec3::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -12432,10 +11522,10 @@ impl bevy::math::UVec3 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec3::saturating_sub( + _self: Val<::glam::UVec3>, + rhs: Val<::glam::UVec3>, + ) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec3::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -12447,11 +11537,11 @@ impl bevy::math::UVec3 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::UVec3::select( + mask: Val<::glam::BVec3>, + if_true: Val<::glam::UVec3>, + if_false: Val<::glam::UVec3>, + ) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec3::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -12460,85 +11550,68 @@ impl bevy::math::UVec3 { output } /// Creates a vector with all elements set to `v`. - fn splat(v: u32) -> Val { - let output: Val = bevy::math::UVec3::splat(v).into(); + fn splat(v: u32) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec3::splat(v).into(); output } - fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::UVec3>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Sub< + &::glam::UVec3, >>::sub(_self.into_inner(), &rhs) .into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::UVec3>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Sub< + ::glam::UVec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: u32) -> Val { - let output: Val = , rhs: u32) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = <::glam::UVec3 as ::core::ops::Sub< u32, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y, z]` - fn to_array(_self: Ref) -> [u32; 3] { - let output: [u32; 3] = bevy::math::UVec3::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::UVec3>) -> [u32; 3] { + let output: [u32; 3] = ::glam::UVec3::to_array(&_self).into(); output } /// Creates a 2D vector from the `x` and `y` elements of `self`, discarding `z`. /// Truncation may also be performed by using [`self.xy()`][crate::swizzles::Vec3Swizzles::xy()]. - fn truncate(_self: Val) -> Val { - let output: Val = bevy::math::UVec3::truncate( - _self.into_inner(), - ) + fn truncate(_self: Val<::glam::UVec3>) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::UVec3::truncate(_self.into_inner()) .into(); output } /// Creates a 3D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: u32) -> Val { - let output: Val = bevy::math::UVec3::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::UVec3>, x: u32) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec3::with_x(_self.into_inner(), x) .into(); output } /// Creates a 3D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: u32) -> Val { - let output: Val = bevy::math::UVec3::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::UVec3>, y: u32) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec3::with_y(_self.into_inner(), y) .into(); output } /// Creates a 3D vector from `self` with the given value of `z`. - fn with_z(_self: Val, z: u32) -> Val { - let output: Val = bevy::math::UVec3::with_z( - _self.into_inner(), - z, - ) + fn with_z(_self: Val<::glam::UVec3>, z: u32) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec3::with_z(_self.into_inner(), z) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec3::wrapping_add( + _self: Val<::glam::UVec3>, + rhs: Val<::glam::UVec3>, + ) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec3::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -12548,10 +11621,10 @@ impl bevy::math::UVec3 { /// Returns a vector containing the wrapping addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.wrapping_add_signed(rhs.x), self.y.wrapping_add_signed(rhs.y), ..]`. fn wrapping_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec3::wrapping_add_signed( + _self: Val<::glam::UVec3>, + rhs: Val<::glam::IVec3>, + ) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec3::wrapping_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -12561,10 +11634,10 @@ impl bevy::math::UVec3 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec3::wrapping_div( + _self: Val<::glam::UVec3>, + rhs: Val<::glam::UVec3>, + ) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec3::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -12574,10 +11647,10 @@ impl bevy::math::UVec3 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec3::wrapping_mul( + _self: Val<::glam::UVec3>, + rhs: Val<::glam::UVec3>, + ) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec3::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -12587,10 +11660,10 @@ impl bevy::math::UVec3 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec3::wrapping_sub( + _self: Val<::glam::UVec3>, + rhs: Val<::glam::UVec3>, + ) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec3::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -12604,87 +11677,75 @@ impl bevy::math::UVec3 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::UVec4 { - fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::UVec4>) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Add< + &::glam::UVec4, >>::add(_self.into_inner(), &rhs) .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::UVec4>) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Add< + ::glam::UVec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: u32) -> Val { - let output: Val = , rhs: u32) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Add< u32, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec4(_self: Ref) -> Val { - let output: Val = bevy::math::UVec4::as_dvec4(&_self).into(); + fn as_dvec4(_self: Ref<::glam::UVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::UVec4::as_dvec4(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec4(_self: Ref) -> Val { - let output: Val = bevy::math::UVec4::as_i16vec4(&_self) - .into(); + fn as_i16vec4(_self: Ref<::glam::UVec4>) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::UVec4::as_i16vec4(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec4(_self: Ref) -> Val { - let output: Val = bevy::math::UVec4::as_i64vec4(&_self) - .into(); + fn as_i64vec4(_self: Ref<::glam::UVec4>) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::UVec4::as_i64vec4(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec4(_self: Ref) -> Val { - let output: Val = bevy::math::UVec4::as_i8vec4(&_self) - .into(); + fn as_i8vec4(_self: Ref<::glam::UVec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::UVec4::as_i8vec4(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec4(_self: Ref) -> Val { - let output: Val = bevy::math::UVec4::as_ivec4(&_self).into(); + fn as_ivec4(_self: Ref<::glam::UVec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::UVec4::as_ivec4(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec4(_self: Ref) -> Val { - let output: Val = bevy::math::UVec4::as_u16vec4(&_self) - .into(); + fn as_u16vec4(_self: Ref<::glam::UVec4>) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::UVec4::as_u16vec4(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec4(_self: Ref) -> Val { - let output: Val = bevy::math::UVec4::as_u64vec4(&_self) - .into(); + fn as_u64vec4(_self: Ref<::glam::UVec4>) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::UVec4::as_u64vec4(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec4(_self: Ref) -> Val { - let output: Val = bevy::math::UVec4::as_u8vec4(&_self) - .into(); + fn as_u8vec4(_self: Ref<::glam::UVec4>) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::UVec4::as_u8vec4(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec4(_self: Ref) -> Val { - let output: Val = bevy::math::UVec4::as_vec4(&_self).into(); + fn as_vec4(_self: Ref<::glam::UVec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::UVec4::as_vec4(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::UVec4>) -> () { + let output: () = <::glam::UVec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -12695,11 +11756,11 @@ impl bevy::math::UVec4 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::UVec4::clamp( + _self: Val<::glam::UVec4>, + min: Val<::glam::UVec4>, + max: Val<::glam::UVec4>, + ) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::UVec4::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -12707,8 +11768,8 @@ impl bevy::math::UVec4 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::UVec4>) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -12718,11 +11779,8 @@ impl bevy::math::UVec4 { /// `self` and `rhs`. /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. - fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec4::cmpeq( + fn cmpeq(_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::UVec4::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -12733,11 +11791,8 @@ impl bevy::math::UVec4 { /// `self` and `rhs`. /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. - fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec4::cmpge( + fn cmpge(_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::UVec4::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -12748,11 +11803,8 @@ impl bevy::math::UVec4 { /// `self` and `rhs`. /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. - fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec4::cmpgt( + fn cmpgt(_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::UVec4::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -12763,11 +11815,8 @@ impl bevy::math::UVec4 { /// `self` and `rhs`. /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. - fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec4::cmple( + fn cmple(_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::UVec4::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -12778,11 +11827,8 @@ impl bevy::math::UVec4 { /// `self` and `rhs`. /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. - fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec4::cmplt( + fn cmplt(_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::UVec4::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -12793,56 +11839,47 @@ impl bevy::math::UVec4 { /// `self` and `rhs`. /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. - fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec4::cmpne( + fn cmpne(_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::UVec4::cmpne( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::UVec4>) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Div< + &::glam::UVec4, >>::div(_self.into_inner(), &rhs) .into(); output } - fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::UVec4>) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Div< + ::glam::UVec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: u32) -> Val { - let output: Val = , rhs: u32) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Div< u32, >>::div(_self.into_inner(), rhs) .into(); output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> u32 { - let output: u32 = bevy::math::UVec4::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>) -> u32 { + let output: u32 = ::glam::UVec4::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec4::dot_into_vec( + _self: Val<::glam::UVec4>, + rhs: Val<::glam::UVec4>, + ) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::UVec4::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -12851,40 +11888,37 @@ impl bevy::math::UVec4 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> u32 { - let output: u32 = bevy::math::UVec4::element_product(_self.into_inner()).into(); + fn element_product(_self: Val<::glam::UVec4>) -> u32 { + let output: u32 = ::glam::UVec4::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> u32 { - let output: u32 = bevy::math::UVec4::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::UVec4>) -> u32 { + let output: u32 = ::glam::UVec4::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::UVec4>) -> bool { + let output: bool = <::glam::UVec4 as ::core::cmp::PartialEq< + ::glam::UVec4, >>::eq(&_self, &other) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [u32; 4]) -> Val { - let output: Val = bevy::math::UVec4::from_array(a).into(); + fn from_array(a: [u32; 4]) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::UVec4::from_array(a).into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> u32 { - let output: u32 = bevy::math::UVec4::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::UVec4>) -> u32 { + let output: u32 = ::glam::UVec4::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. - fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec4::max( + fn max(_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::UVec4::max( _self.into_inner(), rhs.into_inner(), ) @@ -12893,17 +11927,14 @@ impl bevy::math::UVec4 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> u32 { - let output: u32 = bevy::math::UVec4::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::UVec4>) -> u32 { + let output: u32 = ::glam::UVec4::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. - fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec4::min( + fn min(_self: Val<::glam::UVec4>, rhs: Val<::glam::UVec4>) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::UVec4::min( _self.into_inner(), rhs.into_inner(), ) @@ -12912,64 +11943,52 @@ impl bevy::math::UVec4 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> u32 { - let output: u32 = bevy::math::UVec4::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::UVec4>) -> u32 { + let output: u32 = ::glam::UVec4::min_element(_self.into_inner()).into(); output } - fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::UVec4>) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Mul< + &::glam::UVec4, >>::mul(_self.into_inner(), &rhs) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::UVec4>) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Mul< + ::glam::UVec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: u32) -> Val { - let output: Val = , rhs: u32) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Mul< u32, >>::mul(_self.into_inner(), rhs) .into(); output } /// Creates a new vector. - fn new(x: u32, y: u32, z: u32, w: u32) -> Val { - let output: Val = bevy::math::UVec4::new(x, y, z, w).into(); + fn new(x: u32, y: u32, z: u32, w: u32) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::UVec4::new(x, y, z, w).into(); output } - fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::UVec4>) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Rem< + &::glam::UVec4, >>::rem(_self.into_inner(), &rhs) .into(); output } - fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::UVec4>) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Rem< + ::glam::UVec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: u32) -> Val { - let output: Val = , rhs: u32) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Rem< u32, >>::rem(_self.into_inner(), rhs) .into(); @@ -12978,10 +11997,10 @@ impl bevy::math::UVec4 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec4::saturating_add( + _self: Val<::glam::UVec4>, + rhs: Val<::glam::UVec4>, + ) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::UVec4::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -12991,10 +12010,10 @@ impl bevy::math::UVec4 { /// Returns a vector containing the saturating addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.saturating_add_signed(rhs.x), self.y.saturating_add_signed(rhs.y), ..]`. fn saturating_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec4::saturating_add_signed( + _self: Val<::glam::UVec4>, + rhs: Val<::glam::IVec4>, + ) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::UVec4::saturating_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -13004,10 +12023,10 @@ impl bevy::math::UVec4 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec4::saturating_div( + _self: Val<::glam::UVec4>, + rhs: Val<::glam::UVec4>, + ) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::UVec4::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -13017,10 +12036,10 @@ impl bevy::math::UVec4 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec4::saturating_mul( + _self: Val<::glam::UVec4>, + rhs: Val<::glam::UVec4>, + ) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::UVec4::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -13030,10 +12049,10 @@ impl bevy::math::UVec4 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec4::saturating_sub( + _self: Val<::glam::UVec4>, + rhs: Val<::glam::UVec4>, + ) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::UVec4::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -13045,11 +12064,11 @@ impl bevy::math::UVec4 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::UVec4::select( + mask: Val<::glam::BVec4>, + if_true: Val<::glam::UVec4>, + if_false: Val<::glam::UVec4>, + ) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::UVec4::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -13058,94 +12077,74 @@ impl bevy::math::UVec4 { output } /// Creates a vector with all elements set to `v`. - fn splat(v: u32) -> Val { - let output: Val = bevy::math::UVec4::splat(v).into(); + fn splat(v: u32) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::UVec4::splat(v).into(); output } - fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::UVec4>) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Sub< + &::glam::UVec4, >>::sub(_self.into_inner(), &rhs) .into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::UVec4>) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Sub< + ::glam::UVec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: u32) -> Val { - let output: Val = , rhs: u32) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = <::glam::UVec4 as ::core::ops::Sub< u32, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y, z, w]` - fn to_array(_self: Ref) -> [u32; 4] { - let output: [u32; 4] = bevy::math::UVec4::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::UVec4>) -> [u32; 4] { + let output: [u32; 4] = ::glam::UVec4::to_array(&_self).into(); output } /// Creates a 3D vector from the `x`, `y` and `z` elements of `self`, discarding `w`. /// Truncation to [`UVec3`] may also be performed by using [`self.xyz()`][crate::swizzles::Vec4Swizzles::xyz()]. - fn truncate(_self: Val) -> Val { - let output: Val = bevy::math::UVec4::truncate( - _self.into_inner(), - ) + fn truncate(_self: Val<::glam::UVec4>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::UVec4::truncate(_self.into_inner()) .into(); output } /// Creates a 4D vector from `self` with the given value of `w`. - fn with_w(_self: Val, w: u32) -> Val { - let output: Val = bevy::math::UVec4::with_w( - _self.into_inner(), - w, - ) + fn with_w(_self: Val<::glam::UVec4>, w: u32) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::UVec4::with_w(_self.into_inner(), w) .into(); output } /// Creates a 4D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: u32) -> Val { - let output: Val = bevy::math::UVec4::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::UVec4>, x: u32) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::UVec4::with_x(_self.into_inner(), x) .into(); output } /// Creates a 4D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: u32) -> Val { - let output: Val = bevy::math::UVec4::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::UVec4>, y: u32) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::UVec4::with_y(_self.into_inner(), y) .into(); output } /// Creates a 4D vector from `self` with the given value of `z`. - fn with_z(_self: Val, z: u32) -> Val { - let output: Val = bevy::math::UVec4::with_z( - _self.into_inner(), - z, - ) + fn with_z(_self: Val<::glam::UVec4>, z: u32) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::UVec4::with_z(_self.into_inner(), z) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec4::wrapping_add( + _self: Val<::glam::UVec4>, + rhs: Val<::glam::UVec4>, + ) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::UVec4::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -13155,10 +12154,10 @@ impl bevy::math::UVec4 { /// Returns a vector containing the wrapping addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.wrapping_add_signed(rhs.x), self.y.wrapping_add_signed(rhs.y), ..]`. fn wrapping_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec4::wrapping_add_signed( + _self: Val<::glam::UVec4>, + rhs: Val<::glam::IVec4>, + ) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::UVec4::wrapping_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -13168,10 +12167,10 @@ impl bevy::math::UVec4 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec4::wrapping_div( + _self: Val<::glam::UVec4>, + rhs: Val<::glam::UVec4>, + ) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::UVec4::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -13181,10 +12180,10 @@ impl bevy::math::UVec4 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec4::wrapping_mul( + _self: Val<::glam::UVec4>, + rhs: Val<::glam::UVec4>, + ) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::UVec4::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -13194,10 +12193,10 @@ impl bevy::math::UVec4 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::UVec4::wrapping_sub( + _self: Val<::glam::UVec4>, + rhs: Val<::glam::UVec4>, + ) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::UVec4::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -13211,86 +12210,75 @@ impl bevy::math::UVec4 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::U8Vec2 { - fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::U8Vec2>) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Add< + &::glam::U8Vec2, >>::add(_self.into_inner(), &rhs) .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::U8Vec2>) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Add< + ::glam::U8Vec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: u8) -> Val { - let output: Val = , rhs: u8) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Add< u8, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec2(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec2::as_dvec2(&_self).into(); + fn as_dvec2(_self: Ref<::glam::U8Vec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::U8Vec2::as_dvec2(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec2(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec2::as_i16vec2(&_self) - .into(); + fn as_i16vec2(_self: Ref<::glam::U8Vec2>) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::U8Vec2::as_i16vec2(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec2(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec2::as_i64vec2(&_self) - .into(); + fn as_i64vec2(_self: Ref<::glam::U8Vec2>) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::U8Vec2::as_i64vec2(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec2(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec2::as_i8vec2(&_self) - .into(); + fn as_i8vec2(_self: Ref<::glam::U8Vec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::U8Vec2::as_i8vec2(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec2(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec2::as_ivec2(&_self).into(); + fn as_ivec2(_self: Ref<::glam::U8Vec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::U8Vec2::as_ivec2(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec2(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec2::as_u16vec2(&_self) - .into(); + fn as_u16vec2(_self: Ref<::glam::U8Vec2>) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::U8Vec2::as_u16vec2(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec2(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec2::as_u64vec2(&_self) - .into(); + fn as_u64vec2(_self: Ref<::glam::U8Vec2>) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::U8Vec2::as_u64vec2(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec2(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec2::as_uvec2(&_self).into(); + fn as_uvec2(_self: Ref<::glam::U8Vec2>) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::U8Vec2::as_uvec2(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec2(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec2::as_vec2(&_self).into(); + fn as_vec2(_self: Ref<::glam::U8Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::U8Vec2::as_vec2(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::U8Vec2>) -> () { + let output: () = <::glam::U8Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -13301,11 +12289,11 @@ impl bevy::math::U8Vec2 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec2::clamp( + _self: Val<::glam::U8Vec2>, + min: Val<::glam::U8Vec2>, + max: Val<::glam::U8Vec2>, + ) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -13313,8 +12301,8 @@ impl bevy::math::U8Vec2 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::U8Vec2>) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -13325,10 +12313,10 @@ impl bevy::math::U8Vec2 { /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec2::cmpeq( + _self: Val<::glam::U8Vec2>, + rhs: Val<::glam::U8Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::U8Vec2::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -13340,10 +12328,10 @@ impl bevy::math::U8Vec2 { /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec2::cmpge( + _self: Val<::glam::U8Vec2>, + rhs: Val<::glam::U8Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::U8Vec2::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -13355,10 +12343,10 @@ impl bevy::math::U8Vec2 { /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec2::cmpgt( + _self: Val<::glam::U8Vec2>, + rhs: Val<::glam::U8Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::U8Vec2::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -13370,10 +12358,10 @@ impl bevy::math::U8Vec2 { /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec2::cmple( + _self: Val<::glam::U8Vec2>, + rhs: Val<::glam::U8Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::U8Vec2::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -13385,10 +12373,10 @@ impl bevy::math::U8Vec2 { /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec2::cmplt( + _self: Val<::glam::U8Vec2>, + rhs: Val<::glam::U8Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::U8Vec2::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -13400,55 +12388,49 @@ impl bevy::math::U8Vec2 { /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec2::cmpne( + _self: Val<::glam::U8Vec2>, + rhs: Val<::glam::U8Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::U8Vec2::cmpne( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::U8Vec2>) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Div< + &::glam::U8Vec2, >>::div(_self.into_inner(), &rhs) .into(); output } - fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::U8Vec2>) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Div< + ::glam::U8Vec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: u8) -> Val { - let output: Val = , rhs: u8) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Div< u8, >>::div(_self.into_inner(), rhs) .into(); output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> u8 { - let output: u8 = bevy::math::U8Vec2::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>) -> u8 { + let output: u8 = ::glam::U8Vec2::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec2::dot_into_vec( + _self: Val<::glam::U8Vec2>, + rhs: Val<::glam::U8Vec2>, + ) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -13457,49 +12439,43 @@ impl bevy::math::U8Vec2 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> u8 { - let output: u8 = bevy::math::U8Vec2::element_product(_self.into_inner()).into(); + fn element_product(_self: Val<::glam::U8Vec2>) -> u8 { + let output: u8 = ::glam::U8Vec2::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> u8 { - let output: u8 = bevy::math::U8Vec2::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::U8Vec2>) -> u8 { + let output: u8 = ::glam::U8Vec2::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::U8Vec2>) -> bool { + let output: bool = <::glam::U8Vec2 as ::core::cmp::PartialEq< + ::glam::U8Vec2, >>::eq(&_self, &other) .into(); output } /// Creates a 3D vector from `self` and the given `z` value. - fn extend(_self: Val, z: u8) -> Val { - let output: Val = bevy::math::U8Vec2::extend( - _self.into_inner(), - z, - ) + fn extend(_self: Val<::glam::U8Vec2>, z: u8) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec2::extend(_self.into_inner(), z) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [u8; 2]) -> Val { - let output: Val = bevy::math::U8Vec2::from_array(a).into(); + fn from_array(a: [u8; 2]) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::from_array(a).into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> u8 { - let output: u8 = bevy::math::U8Vec2::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::U8Vec2>) -> u8 { + let output: u8 = ::glam::U8Vec2::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. - fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec2::max( + fn max(_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::max( _self.into_inner(), rhs.into_inner(), ) @@ -13508,17 +12484,14 @@ impl bevy::math::U8Vec2 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> u8 { - let output: u8 = bevy::math::U8Vec2::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::U8Vec2>) -> u8 { + let output: u8 = ::glam::U8Vec2::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. - fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec2::min( + fn min(_self: Val<::glam::U8Vec2>, rhs: Val<::glam::U8Vec2>) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::min( _self.into_inner(), rhs.into_inner(), ) @@ -13527,64 +12500,52 @@ impl bevy::math::U8Vec2 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> u8 { - let output: u8 = bevy::math::U8Vec2::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::U8Vec2>) -> u8 { + let output: u8 = ::glam::U8Vec2::min_element(_self.into_inner()).into(); output } - fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::U8Vec2>) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Mul< + &::glam::U8Vec2, >>::mul(_self.into_inner(), &rhs) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::U8Vec2>) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Mul< + ::glam::U8Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: u8) -> Val { - let output: Val = , rhs: u8) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Mul< u8, >>::mul(_self.into_inner(), rhs) .into(); output } /// Creates a new vector. - fn new(x: u8, y: u8) -> Val { - let output: Val = bevy::math::U8Vec2::new(x, y).into(); + fn new(x: u8, y: u8) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::new(x, y).into(); output } - fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::U8Vec2>) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Rem< + &::glam::U8Vec2, >>::rem(_self.into_inner(), &rhs) .into(); output } - fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::U8Vec2>) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Rem< + ::glam::U8Vec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: u8) -> Val { - let output: Val = , rhs: u8) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Rem< u8, >>::rem(_self.into_inner(), rhs) .into(); @@ -13593,10 +12554,10 @@ impl bevy::math::U8Vec2 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec2::saturating_add( + _self: Val<::glam::U8Vec2>, + rhs: Val<::glam::U8Vec2>, + ) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -13606,10 +12567,10 @@ impl bevy::math::U8Vec2 { /// Returns a vector containing the saturating addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.saturating_add_signed(rhs.x), self.y.saturating_add_signed(rhs.y), ..]`. fn saturating_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec2::saturating_add_signed( + _self: Val<::glam::U8Vec2>, + rhs: Val<::glam::I8Vec2>, + ) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::saturating_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -13619,10 +12580,10 @@ impl bevy::math::U8Vec2 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec2::saturating_div( + _self: Val<::glam::U8Vec2>, + rhs: Val<::glam::U8Vec2>, + ) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -13632,10 +12593,10 @@ impl bevy::math::U8Vec2 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec2::saturating_mul( + _self: Val<::glam::U8Vec2>, + rhs: Val<::glam::U8Vec2>, + ) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -13645,10 +12606,10 @@ impl bevy::math::U8Vec2 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec2::saturating_sub( + _self: Val<::glam::U8Vec2>, + rhs: Val<::glam::U8Vec2>, + ) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -13660,11 +12621,11 @@ impl bevy::math::U8Vec2 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec2::select( + mask: Val<::glam::BVec2>, + if_true: Val<::glam::U8Vec2>, + if_false: Val<::glam::U8Vec2>, + ) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -13673,67 +12634,55 @@ impl bevy::math::U8Vec2 { output } /// Creates a vector with all elements set to `v`. - fn splat(v: u8) -> Val { - let output: Val = bevy::math::U8Vec2::splat(v).into(); + fn splat(v: u8) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::splat(v).into(); output } - fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::U8Vec2>) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Sub< + &::glam::U8Vec2, >>::sub(_self.into_inner(), &rhs) .into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::U8Vec2>) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Sub< + ::glam::U8Vec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: u8) -> Val { - let output: Val = , rhs: u8) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = <::glam::U8Vec2 as ::core::ops::Sub< u8, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y]` - fn to_array(_self: Ref) -> [u8; 2] { - let output: [u8; 2] = bevy::math::U8Vec2::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::U8Vec2>) -> [u8; 2] { + let output: [u8; 2] = ::glam::U8Vec2::to_array(&_self).into(); output } /// Creates a 2D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: u8) -> Val { - let output: Val = bevy::math::U8Vec2::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::U8Vec2>, x: u8) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::with_x(_self.into_inner(), x) .into(); output } /// Creates a 2D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: u8) -> Val { - let output: Val = bevy::math::U8Vec2::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::U8Vec2>, y: u8) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::with_y(_self.into_inner(), y) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec2::wrapping_add( + _self: Val<::glam::U8Vec2>, + rhs: Val<::glam::U8Vec2>, + ) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -13743,10 +12692,10 @@ impl bevy::math::U8Vec2 { /// Returns a vector containing the wrapping addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.wrapping_add_signed(rhs.x), self.y.wrapping_add_signed(rhs.y), ..]`. fn wrapping_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec2::wrapping_add_signed( + _self: Val<::glam::U8Vec2>, + rhs: Val<::glam::I8Vec2>, + ) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::wrapping_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -13756,10 +12705,10 @@ impl bevy::math::U8Vec2 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec2::wrapping_div( + _self: Val<::glam::U8Vec2>, + rhs: Val<::glam::U8Vec2>, + ) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -13769,10 +12718,10 @@ impl bevy::math::U8Vec2 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec2::wrapping_mul( + _self: Val<::glam::U8Vec2>, + rhs: Val<::glam::U8Vec2>, + ) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -13782,10 +12731,10 @@ impl bevy::math::U8Vec2 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec2::wrapping_sub( + _self: Val<::glam::U8Vec2>, + rhs: Val<::glam::U8Vec2>, + ) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::U8Vec2::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -13799,91 +12748,80 @@ impl bevy::math::U8Vec2 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::U8Vec3 { - fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::U8Vec3>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Add< + &::glam::U8Vec3, >>::add(_self.into_inner(), &rhs) .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::U8Vec3>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Add< + ::glam::U8Vec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: u8) -> Val { - let output: Val = , rhs: u8) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Add< u8, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec3(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec3::as_dvec3(&_self).into(); + fn as_dvec3(_self: Ref<::glam::U8Vec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::U8Vec3::as_dvec3(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec3(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec3::as_i16vec3(&_self) - .into(); + fn as_i16vec3(_self: Ref<::glam::U8Vec3>) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::U8Vec3::as_i16vec3(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec3(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec3::as_i64vec3(&_self) - .into(); + fn as_i64vec3(_self: Ref<::glam::U8Vec3>) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::U8Vec3::as_i64vec3(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec3(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec3::as_i8vec3(&_self) - .into(); + fn as_i8vec3(_self: Ref<::glam::U8Vec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::U8Vec3::as_i8vec3(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec3(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec3::as_ivec3(&_self).into(); + fn as_ivec3(_self: Ref<::glam::U8Vec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::U8Vec3::as_ivec3(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec3(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec3::as_u16vec3(&_self) - .into(); + fn as_u16vec3(_self: Ref<::glam::U8Vec3>) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U8Vec3::as_u16vec3(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec3(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec3::as_u64vec3(&_self) - .into(); + fn as_u64vec3(_self: Ref<::glam::U8Vec3>) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U8Vec3::as_u64vec3(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec3(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec3::as_uvec3(&_self).into(); + fn as_uvec3(_self: Ref<::glam::U8Vec3>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::U8Vec3::as_uvec3(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec3(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec3::as_vec3(&_self).into(); + fn as_vec3(_self: Ref<::glam::U8Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::U8Vec3::as_vec3(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec3a(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec3::as_vec3a(&_self).into(); + fn as_vec3a(_self: Ref<::glam::U8Vec3>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::U8Vec3::as_vec3a(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::U8Vec3>) -> () { + let output: () = <::glam::U8Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -13894,11 +12832,11 @@ impl bevy::math::U8Vec3 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec3::clamp( + _self: Val<::glam::U8Vec3>, + min: Val<::glam::U8Vec3>, + max: Val<::glam::U8Vec3>, + ) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -13906,8 +12844,8 @@ impl bevy::math::U8Vec3 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::U8Vec3>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -13918,10 +12856,10 @@ impl bevy::math::U8Vec3 { /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec3::cmpeq( + _self: Val<::glam::U8Vec3>, + rhs: Val<::glam::U8Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::U8Vec3::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -13933,10 +12871,10 @@ impl bevy::math::U8Vec3 { /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec3::cmpge( + _self: Val<::glam::U8Vec3>, + rhs: Val<::glam::U8Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::U8Vec3::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -13948,10 +12886,10 @@ impl bevy::math::U8Vec3 { /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec3::cmpgt( + _self: Val<::glam::U8Vec3>, + rhs: Val<::glam::U8Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::U8Vec3::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -13963,10 +12901,10 @@ impl bevy::math::U8Vec3 { /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec3::cmple( + _self: Val<::glam::U8Vec3>, + rhs: Val<::glam::U8Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::U8Vec3::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -13978,10 +12916,10 @@ impl bevy::math::U8Vec3 { /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec3::cmplt( + _self: Val<::glam::U8Vec3>, + rhs: Val<::glam::U8Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::U8Vec3::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -13993,10 +12931,10 @@ impl bevy::math::U8Vec3 { /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec3::cmpne( + _self: Val<::glam::U8Vec3>, + rhs: Val<::glam::U8Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::U8Vec3::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -14005,55 +12943,49 @@ impl bevy::math::U8Vec3 { } /// Computes the cross product of `self` and `rhs`. fn cross( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec3::cross( + _self: Val<::glam::U8Vec3>, + rhs: Val<::glam::U8Vec3>, + ) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::cross( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::U8Vec3>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Div< + &::glam::U8Vec3, >>::div(_self.into_inner(), &rhs) .into(); output } - fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::U8Vec3>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Div< + ::glam::U8Vec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: u8) -> Val { - let output: Val = , rhs: u8) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Div< u8, >>::div(_self.into_inner(), rhs) .into(); output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> u8 { - let output: u8 = bevy::math::U8Vec3::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>) -> u8 { + let output: u8 = ::glam::U8Vec3::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec3::dot_into_vec( + _self: Val<::glam::U8Vec3>, + rhs: Val<::glam::U8Vec3>, + ) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -14062,49 +12994,43 @@ impl bevy::math::U8Vec3 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> u8 { - let output: u8 = bevy::math::U8Vec3::element_product(_self.into_inner()).into(); + fn element_product(_self: Val<::glam::U8Vec3>) -> u8 { + let output: u8 = ::glam::U8Vec3::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> u8 { - let output: u8 = bevy::math::U8Vec3::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::U8Vec3>) -> u8 { + let output: u8 = ::glam::U8Vec3::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::U8Vec3>) -> bool { + let output: bool = <::glam::U8Vec3 as ::core::cmp::PartialEq< + ::glam::U8Vec3, >>::eq(&_self, &other) .into(); output } /// Creates a 4D vector from `self` and the given `w` value. - fn extend(_self: Val, w: u8) -> Val { - let output: Val = bevy::math::U8Vec3::extend( - _self.into_inner(), - w, - ) + fn extend(_self: Val<::glam::U8Vec3>, w: u8) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U8Vec3::extend(_self.into_inner(), w) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [u8; 3]) -> Val { - let output: Val = bevy::math::U8Vec3::from_array(a).into(); + fn from_array(a: [u8; 3]) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::from_array(a).into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> u8 { - let output: u8 = bevy::math::U8Vec3::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::U8Vec3>) -> u8 { + let output: u8 = ::glam::U8Vec3::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. - fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec3::max( + fn max(_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::max( _self.into_inner(), rhs.into_inner(), ) @@ -14113,17 +13039,14 @@ impl bevy::math::U8Vec3 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> u8 { - let output: u8 = bevy::math::U8Vec3::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::U8Vec3>) -> u8 { + let output: u8 = ::glam::U8Vec3::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. - fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec3::min( + fn min(_self: Val<::glam::U8Vec3>, rhs: Val<::glam::U8Vec3>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::min( _self.into_inner(), rhs.into_inner(), ) @@ -14132,64 +13055,52 @@ impl bevy::math::U8Vec3 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> u8 { - let output: u8 = bevy::math::U8Vec3::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::U8Vec3>) -> u8 { + let output: u8 = ::glam::U8Vec3::min_element(_self.into_inner()).into(); output } - fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::U8Vec3>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Mul< + &::glam::U8Vec3, >>::mul(_self.into_inner(), &rhs) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::U8Vec3>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Mul< + ::glam::U8Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: u8) -> Val { - let output: Val = , rhs: u8) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Mul< u8, >>::mul(_self.into_inner(), rhs) .into(); output } /// Creates a new vector. - fn new(x: u8, y: u8, z: u8) -> Val { - let output: Val = bevy::math::U8Vec3::new(x, y, z).into(); + fn new(x: u8, y: u8, z: u8) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::new(x, y, z).into(); output } - fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::U8Vec3>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Rem< + &::glam::U8Vec3, >>::rem(_self.into_inner(), &rhs) .into(); output } - fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::U8Vec3>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Rem< + ::glam::U8Vec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: u8) -> Val { - let output: Val = , rhs: u8) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Rem< u8, >>::rem(_self.into_inner(), rhs) .into(); @@ -14198,10 +13109,10 @@ impl bevy::math::U8Vec3 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec3::saturating_add( + _self: Val<::glam::U8Vec3>, + rhs: Val<::glam::U8Vec3>, + ) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -14211,10 +13122,10 @@ impl bevy::math::U8Vec3 { /// Returns a vector containing the saturating addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.saturating_add_signed(rhs.x), self.y.saturating_add_signed(rhs.y), ..]`. fn saturating_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec3::saturating_add_signed( + _self: Val<::glam::U8Vec3>, + rhs: Val<::glam::I8Vec3>, + ) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::saturating_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -14224,10 +13135,10 @@ impl bevy::math::U8Vec3 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec3::saturating_div( + _self: Val<::glam::U8Vec3>, + rhs: Val<::glam::U8Vec3>, + ) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -14237,10 +13148,10 @@ impl bevy::math::U8Vec3 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec3::saturating_mul( + _self: Val<::glam::U8Vec3>, + rhs: Val<::glam::U8Vec3>, + ) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -14250,10 +13161,10 @@ impl bevy::math::U8Vec3 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec3::saturating_sub( + _self: Val<::glam::U8Vec3>, + rhs: Val<::glam::U8Vec3>, + ) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -14265,11 +13176,11 @@ impl bevy::math::U8Vec3 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec3::select( + mask: Val<::glam::BVec3>, + if_true: Val<::glam::U8Vec3>, + if_false: Val<::glam::U8Vec3>, + ) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -14278,85 +13189,68 @@ impl bevy::math::U8Vec3 { output } /// Creates a vector with all elements set to `v`. - fn splat(v: u8) -> Val { - let output: Val = bevy::math::U8Vec3::splat(v).into(); + fn splat(v: u8) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::splat(v).into(); output } - fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::U8Vec3>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Sub< + &::glam::U8Vec3, >>::sub(_self.into_inner(), &rhs) .into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::U8Vec3>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Sub< + ::glam::U8Vec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: u8) -> Val { - let output: Val = , rhs: u8) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = <::glam::U8Vec3 as ::core::ops::Sub< u8, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y, z]` - fn to_array(_self: Ref) -> [u8; 3] { - let output: [u8; 3] = bevy::math::U8Vec3::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::U8Vec3>) -> [u8; 3] { + let output: [u8; 3] = ::glam::U8Vec3::to_array(&_self).into(); output } /// Creates a 2D vector from the `x` and `y` elements of `self`, discarding `z`. /// Truncation may also be performed by using [`self.xy()`][crate::swizzles::Vec3Swizzles::xy()]. - fn truncate(_self: Val) -> Val { - let output: Val = bevy::math::U8Vec3::truncate( - _self.into_inner(), - ) + fn truncate(_self: Val<::glam::U8Vec3>) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::U8Vec3::truncate(_self.into_inner()) .into(); output } /// Creates a 3D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: u8) -> Val { - let output: Val = bevy::math::U8Vec3::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::U8Vec3>, x: u8) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::with_x(_self.into_inner(), x) .into(); output } /// Creates a 3D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: u8) -> Val { - let output: Val = bevy::math::U8Vec3::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::U8Vec3>, y: u8) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::with_y(_self.into_inner(), y) .into(); output } /// Creates a 3D vector from `self` with the given value of `z`. - fn with_z(_self: Val, z: u8) -> Val { - let output: Val = bevy::math::U8Vec3::with_z( - _self.into_inner(), - z, - ) + fn with_z(_self: Val<::glam::U8Vec3>, z: u8) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::with_z(_self.into_inner(), z) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec3::wrapping_add( + _self: Val<::glam::U8Vec3>, + rhs: Val<::glam::U8Vec3>, + ) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -14366,10 +13260,10 @@ impl bevy::math::U8Vec3 { /// Returns a vector containing the wrapping addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.wrapping_add_signed(rhs.x), self.y.wrapping_add_signed(rhs.y), ..]`. fn wrapping_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec3::wrapping_add_signed( + _self: Val<::glam::U8Vec3>, + rhs: Val<::glam::I8Vec3>, + ) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::wrapping_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -14379,10 +13273,10 @@ impl bevy::math::U8Vec3 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec3::wrapping_div( + _self: Val<::glam::U8Vec3>, + rhs: Val<::glam::U8Vec3>, + ) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -14392,10 +13286,10 @@ impl bevy::math::U8Vec3 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec3::wrapping_mul( + _self: Val<::glam::U8Vec3>, + rhs: Val<::glam::U8Vec3>, + ) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -14405,10 +13299,10 @@ impl bevy::math::U8Vec3 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec3::wrapping_sub( + _self: Val<::glam::U8Vec3>, + rhs: Val<::glam::U8Vec3>, + ) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec3::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -14422,86 +13316,75 @@ impl bevy::math::U8Vec3 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::U8Vec4 { - fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::U8Vec4>) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Add< + &::glam::U8Vec4, >>::add(_self.into_inner(), &rhs) .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::U8Vec4>) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Add< + ::glam::U8Vec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: u8) -> Val { - let output: Val = , rhs: u8) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Add< u8, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec4(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec4::as_dvec4(&_self).into(); + fn as_dvec4(_self: Ref<::glam::U8Vec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::U8Vec4::as_dvec4(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec4(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec4::as_i16vec4(&_self) - .into(); + fn as_i16vec4(_self: Ref<::glam::U8Vec4>) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::U8Vec4::as_i16vec4(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec4(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec4::as_i64vec4(&_self) - .into(); + fn as_i64vec4(_self: Ref<::glam::U8Vec4>) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::U8Vec4::as_i64vec4(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec4(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec4::as_i8vec4(&_self) - .into(); + fn as_i8vec4(_self: Ref<::glam::U8Vec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::U8Vec4::as_i8vec4(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec4(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec4::as_ivec4(&_self).into(); + fn as_ivec4(_self: Ref<::glam::U8Vec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::U8Vec4::as_ivec4(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec4(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec4::as_u16vec4(&_self) - .into(); + fn as_u16vec4(_self: Ref<::glam::U8Vec4>) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U8Vec4::as_u16vec4(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec4(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec4::as_u64vec4(&_self) - .into(); + fn as_u64vec4(_self: Ref<::glam::U8Vec4>) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U8Vec4::as_u64vec4(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec4(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec4::as_uvec4(&_self).into(); + fn as_uvec4(_self: Ref<::glam::U8Vec4>) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::U8Vec4::as_uvec4(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec4(_self: Ref) -> Val { - let output: Val = bevy::math::U8Vec4::as_vec4(&_self).into(); + fn as_vec4(_self: Ref<::glam::U8Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::U8Vec4::as_vec4(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::U8Vec4>) -> () { + let output: () = <::glam::U8Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -14512,11 +13395,11 @@ impl bevy::math::U8Vec4 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec4::clamp( + _self: Val<::glam::U8Vec4>, + min: Val<::glam::U8Vec4>, + max: Val<::glam::U8Vec4>, + ) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -14524,8 +13407,8 @@ impl bevy::math::U8Vec4 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::U8Vec4>) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -14536,10 +13419,10 @@ impl bevy::math::U8Vec4 { /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec4::cmpeq( + _self: Val<::glam::U8Vec4>, + rhs: Val<::glam::U8Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::U8Vec4::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -14551,10 +13434,10 @@ impl bevy::math::U8Vec4 { /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec4::cmpge( + _self: Val<::glam::U8Vec4>, + rhs: Val<::glam::U8Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::U8Vec4::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -14566,10 +13449,10 @@ impl bevy::math::U8Vec4 { /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec4::cmpgt( + _self: Val<::glam::U8Vec4>, + rhs: Val<::glam::U8Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::U8Vec4::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -14581,10 +13464,10 @@ impl bevy::math::U8Vec4 { /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec4::cmple( + _self: Val<::glam::U8Vec4>, + rhs: Val<::glam::U8Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::U8Vec4::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -14596,10 +13479,10 @@ impl bevy::math::U8Vec4 { /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec4::cmplt( + _self: Val<::glam::U8Vec4>, + rhs: Val<::glam::U8Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::U8Vec4::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -14611,55 +13494,49 @@ impl bevy::math::U8Vec4 { /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec4::cmpne( + _self: Val<::glam::U8Vec4>, + rhs: Val<::glam::U8Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::U8Vec4::cmpne( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::U8Vec4>) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Div< + &::glam::U8Vec4, >>::div(_self.into_inner(), &rhs) .into(); output } - fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::U8Vec4>) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Div< + ::glam::U8Vec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: u8) -> Val { - let output: Val = , rhs: u8) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Div< u8, >>::div(_self.into_inner(), rhs) .into(); output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> u8 { - let output: u8 = bevy::math::U8Vec4::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>) -> u8 { + let output: u8 = ::glam::U8Vec4::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec4::dot_into_vec( + _self: Val<::glam::U8Vec4>, + rhs: Val<::glam::U8Vec4>, + ) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -14668,40 +13545,37 @@ impl bevy::math::U8Vec4 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> u8 { - let output: u8 = bevy::math::U8Vec4::element_product(_self.into_inner()).into(); + fn element_product(_self: Val<::glam::U8Vec4>) -> u8 { + let output: u8 = ::glam::U8Vec4::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> u8 { - let output: u8 = bevy::math::U8Vec4::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::U8Vec4>) -> u8 { + let output: u8 = ::glam::U8Vec4::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::U8Vec4>) -> bool { + let output: bool = <::glam::U8Vec4 as ::core::cmp::PartialEq< + ::glam::U8Vec4, >>::eq(&_self, &other) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [u8; 4]) -> Val { - let output: Val = bevy::math::U8Vec4::from_array(a).into(); + fn from_array(a: [u8; 4]) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::from_array(a).into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> u8 { - let output: u8 = bevy::math::U8Vec4::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::U8Vec4>) -> u8 { + let output: u8 = ::glam::U8Vec4::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. - fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec4::max( + fn max(_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::max( _self.into_inner(), rhs.into_inner(), ) @@ -14710,17 +13584,14 @@ impl bevy::math::U8Vec4 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> u8 { - let output: u8 = bevy::math::U8Vec4::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::U8Vec4>) -> u8 { + let output: u8 = ::glam::U8Vec4::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. - fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec4::min( + fn min(_self: Val<::glam::U8Vec4>, rhs: Val<::glam::U8Vec4>) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::min( _self.into_inner(), rhs.into_inner(), ) @@ -14729,64 +13600,52 @@ impl bevy::math::U8Vec4 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> u8 { - let output: u8 = bevy::math::U8Vec4::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::U8Vec4>) -> u8 { + let output: u8 = ::glam::U8Vec4::min_element(_self.into_inner()).into(); output } - fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::U8Vec4>) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Mul< + &::glam::U8Vec4, >>::mul(_self.into_inner(), &rhs) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::U8Vec4>) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Mul< + ::glam::U8Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: u8) -> Val { - let output: Val = , rhs: u8) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Mul< u8, >>::mul(_self.into_inner(), rhs) .into(); output } /// Creates a new vector. - fn new(x: u8, y: u8, z: u8, w: u8) -> Val { - let output: Val = bevy::math::U8Vec4::new(x, y, z, w).into(); + fn new(x: u8, y: u8, z: u8, w: u8) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::new(x, y, z, w).into(); output } - fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::U8Vec4>) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Rem< + &::glam::U8Vec4, >>::rem(_self.into_inner(), &rhs) .into(); output } - fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::U8Vec4>) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Rem< + ::glam::U8Vec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: u8) -> Val { - let output: Val = , rhs: u8) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Rem< u8, >>::rem(_self.into_inner(), rhs) .into(); @@ -14795,10 +13654,10 @@ impl bevy::math::U8Vec4 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec4::saturating_add( + _self: Val<::glam::U8Vec4>, + rhs: Val<::glam::U8Vec4>, + ) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -14808,10 +13667,10 @@ impl bevy::math::U8Vec4 { /// Returns a vector containing the saturating addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.saturating_add_signed(rhs.x), self.y.saturating_add_signed(rhs.y), ..]`. fn saturating_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec4::saturating_add_signed( + _self: Val<::glam::U8Vec4>, + rhs: Val<::glam::I8Vec4>, + ) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::saturating_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -14821,10 +13680,10 @@ impl bevy::math::U8Vec4 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec4::saturating_div( + _self: Val<::glam::U8Vec4>, + rhs: Val<::glam::U8Vec4>, + ) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -14834,10 +13693,10 @@ impl bevy::math::U8Vec4 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec4::saturating_mul( + _self: Val<::glam::U8Vec4>, + rhs: Val<::glam::U8Vec4>, + ) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -14847,10 +13706,10 @@ impl bevy::math::U8Vec4 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec4::saturating_sub( + _self: Val<::glam::U8Vec4>, + rhs: Val<::glam::U8Vec4>, + ) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -14862,11 +13721,11 @@ impl bevy::math::U8Vec4 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec4::select( + mask: Val<::glam::BVec4>, + if_true: Val<::glam::U8Vec4>, + if_false: Val<::glam::U8Vec4>, + ) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -14875,94 +13734,74 @@ impl bevy::math::U8Vec4 { output } /// Creates a vector with all elements set to `v`. - fn splat(v: u8) -> Val { - let output: Val = bevy::math::U8Vec4::splat(v).into(); + fn splat(v: u8) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::splat(v).into(); output } - fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::U8Vec4>) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Sub< + &::glam::U8Vec4, >>::sub(_self.into_inner(), &rhs) .into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::U8Vec4>) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Sub< + ::glam::U8Vec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: u8) -> Val { - let output: Val = , rhs: u8) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = <::glam::U8Vec4 as ::core::ops::Sub< u8, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y, z, w]` - fn to_array(_self: Ref) -> [u8; 4] { - let output: [u8; 4] = bevy::math::U8Vec4::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::U8Vec4>) -> [u8; 4] { + let output: [u8; 4] = ::glam::U8Vec4::to_array(&_self).into(); output } /// Creates a 3D vector from the `x`, `y` and `z` elements of `self`, discarding `w`. /// Truncation to [`U8Vec3`] may also be performed by using [`self.xyz()`][crate::swizzles::Vec4Swizzles::xyz()]. - fn truncate(_self: Val) -> Val { - let output: Val = bevy::math::U8Vec4::truncate( - _self.into_inner(), - ) + fn truncate(_self: Val<::glam::U8Vec4>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U8Vec4::truncate(_self.into_inner()) .into(); output } /// Creates a 4D vector from `self` with the given value of `w`. - fn with_w(_self: Val, w: u8) -> Val { - let output: Val = bevy::math::U8Vec4::with_w( - _self.into_inner(), - w, - ) + fn with_w(_self: Val<::glam::U8Vec4>, w: u8) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::with_w(_self.into_inner(), w) .into(); output } /// Creates a 4D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: u8) -> Val { - let output: Val = bevy::math::U8Vec4::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::U8Vec4>, x: u8) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::with_x(_self.into_inner(), x) .into(); output } /// Creates a 4D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: u8) -> Val { - let output: Val = bevy::math::U8Vec4::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::U8Vec4>, y: u8) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::with_y(_self.into_inner(), y) .into(); output } /// Creates a 4D vector from `self` with the given value of `z`. - fn with_z(_self: Val, z: u8) -> Val { - let output: Val = bevy::math::U8Vec4::with_z( - _self.into_inner(), - z, - ) + fn with_z(_self: Val<::glam::U8Vec4>, z: u8) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::with_z(_self.into_inner(), z) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec4::wrapping_add( + _self: Val<::glam::U8Vec4>, + rhs: Val<::glam::U8Vec4>, + ) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -14972,10 +13811,10 @@ impl bevy::math::U8Vec4 { /// Returns a vector containing the wrapping addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.wrapping_add_signed(rhs.x), self.y.wrapping_add_signed(rhs.y), ..]`. fn wrapping_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec4::wrapping_add_signed( + _self: Val<::glam::U8Vec4>, + rhs: Val<::glam::I8Vec4>, + ) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::wrapping_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -14985,10 +13824,10 @@ impl bevy::math::U8Vec4 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec4::wrapping_div( + _self: Val<::glam::U8Vec4>, + rhs: Val<::glam::U8Vec4>, + ) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -14998,10 +13837,10 @@ impl bevy::math::U8Vec4 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec4::wrapping_mul( + _self: Val<::glam::U8Vec4>, + rhs: Val<::glam::U8Vec4>, + ) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -15011,10 +13850,10 @@ impl bevy::math::U8Vec4 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U8Vec4::wrapping_sub( + _self: Val<::glam::U8Vec4>, + rhs: Val<::glam::U8Vec4>, + ) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U8Vec4::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -15028,89 +13867,81 @@ impl bevy::math::U8Vec4 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::U16Vec2 { +impl ::glam::U16Vec2 { fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Add< + &::glam::U16Vec2, >>::add(_self.into_inner(), &rhs) .into(); output } fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Add< + ::glam::U16Vec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: u16) -> Val { - let output: Val = , rhs: u16) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Add< u16, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec2(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec2::as_dvec2(&_self) - .into(); + fn as_dvec2(_self: Ref<::glam::U16Vec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::U16Vec2::as_dvec2(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec2(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec2::as_i16vec2(&_self) - .into(); + fn as_i16vec2(_self: Ref<::glam::U16Vec2>) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::U16Vec2::as_i16vec2(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec2(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec2::as_i64vec2(&_self) - .into(); + fn as_i64vec2(_self: Ref<::glam::U16Vec2>) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::U16Vec2::as_i64vec2(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec2(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec2::as_i8vec2(&_self) - .into(); + fn as_i8vec2(_self: Ref<::glam::U16Vec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::U16Vec2::as_i8vec2(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec2(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec2::as_ivec2(&_self) - .into(); + fn as_ivec2(_self: Ref<::glam::U16Vec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::U16Vec2::as_ivec2(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec2(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec2::as_u64vec2(&_self) - .into(); + fn as_u64vec2(_self: Ref<::glam::U16Vec2>) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::U16Vec2::as_u64vec2(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec2(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec2::as_u8vec2(&_self) - .into(); + fn as_u8vec2(_self: Ref<::glam::U16Vec2>) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::U16Vec2::as_u8vec2(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec2(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec2::as_uvec2(&_self) - .into(); + fn as_uvec2(_self: Ref<::glam::U16Vec2>) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::U16Vec2::as_uvec2(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec2(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec2::as_vec2(&_self).into(); + fn as_vec2(_self: Ref<::glam::U16Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::U16Vec2::as_vec2(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::U16Vec2>) -> () { + let output: () = <::glam::U16Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -15121,11 +13952,11 @@ impl bevy::math::U16Vec2 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec2::clamp( + _self: Val<::glam::U16Vec2>, + min: Val<::glam::U16Vec2>, + max: Val<::glam::U16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -15133,8 +13964,8 @@ impl bevy::math::U16Vec2 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::U16Vec2>) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -15145,10 +13976,10 @@ impl bevy::math::U16Vec2 { /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec2::cmpeq( + _self: Val<::glam::U16Vec2>, + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::U16Vec2::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -15160,10 +13991,10 @@ impl bevy::math::U16Vec2 { /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec2::cmpge( + _self: Val<::glam::U16Vec2>, + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::U16Vec2::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -15175,10 +14006,10 @@ impl bevy::math::U16Vec2 { /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec2::cmpgt( + _self: Val<::glam::U16Vec2>, + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::U16Vec2::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -15190,10 +14021,10 @@ impl bevy::math::U16Vec2 { /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec2::cmple( + _self: Val<::glam::U16Vec2>, + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::U16Vec2::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -15205,10 +14036,10 @@ impl bevy::math::U16Vec2 { /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec2::cmplt( + _self: Val<::glam::U16Vec2>, + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::U16Vec2::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -15220,10 +14051,10 @@ impl bevy::math::U16Vec2 { /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec2::cmpne( + _self: Val<::glam::U16Vec2>, + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::U16Vec2::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -15231,44 +14062,44 @@ impl bevy::math::U16Vec2 { output } fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Div< + &::glam::U16Vec2, >>::div(_self.into_inner(), &rhs) .into(); output } fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Div< + ::glam::U16Vec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: u16) -> Val { - let output: Val = , rhs: u16) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Div< u16, >>::div(_self.into_inner(), rhs) .into(); output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> u16 { - let output: u16 = bevy::math::U16Vec2::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::U16Vec2>, rhs: Val<::glam::U16Vec2>) -> u16 { + let output: u16 = ::glam::U16Vec2::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec2::dot_into_vec( + _self: Val<::glam::U16Vec2>, + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -15277,50 +14108,46 @@ impl bevy::math::U16Vec2 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> u16 { - let output: u16 = bevy::math::U16Vec2::element_product(_self.into_inner()) - .into(); + fn element_product(_self: Val<::glam::U16Vec2>) -> u16 { + let output: u16 = ::glam::U16Vec2::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> u16 { - let output: u16 = bevy::math::U16Vec2::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::U16Vec2>) -> u16 { + let output: u16 = ::glam::U16Vec2::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::U16Vec2>) -> bool { + let output: bool = <::glam::U16Vec2 as ::core::cmp::PartialEq< + ::glam::U16Vec2, >>::eq(&_self, &other) .into(); output } /// Creates a 3D vector from `self` and the given `z` value. - fn extend(_self: Val, z: u16) -> Val { - let output: Val = bevy::math::U16Vec2::extend( - _self.into_inner(), - z, - ) + fn extend(_self: Val<::glam::U16Vec2>, z: u16) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec2::extend(_self.into_inner(), z) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [u16; 2]) -> Val { - let output: Val = bevy::math::U16Vec2::from_array(a).into(); + fn from_array(a: [u16; 2]) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::from_array(a).into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> u16 { - let output: u16 = bevy::math::U16Vec2::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::U16Vec2>) -> u16 { + let output: u16 = ::glam::U16Vec2::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec2::max( + _self: Val<::glam::U16Vec2>, + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::max( _self.into_inner(), rhs.into_inner(), ) @@ -15329,17 +14156,17 @@ impl bevy::math::U16Vec2 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> u16 { - let output: u16 = bevy::math::U16Vec2::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::U16Vec2>) -> u16 { + let output: u16 = ::glam::U16Vec2::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec2::min( + _self: Val<::glam::U16Vec2>, + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::min( _self.into_inner(), rhs.into_inner(), ) @@ -15348,64 +14175,64 @@ impl bevy::math::U16Vec2 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> u16 { - let output: u16 = bevy::math::U16Vec2::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::U16Vec2>) -> u16 { + let output: u16 = ::glam::U16Vec2::min_element(_self.into_inner()).into(); output } fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Mul< + &::glam::U16Vec2, >>::mul(_self.into_inner(), &rhs) .into(); output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Mul< + ::glam::U16Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: u16) -> Val { - let output: Val = , rhs: u16) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Mul< u16, >>::mul(_self.into_inner(), rhs) .into(); output } /// Creates a new vector. - fn new(x: u16, y: u16) -> Val { - let output: Val = bevy::math::U16Vec2::new(x, y).into(); + fn new(x: u16, y: u16) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::new(x, y).into(); output } fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Rem< + &::glam::U16Vec2, >>::rem(_self.into_inner(), &rhs) .into(); output } fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Rem< + ::glam::U16Vec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: u16) -> Val { - let output: Val = , rhs: u16) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Rem< u16, >>::rem(_self.into_inner(), rhs) .into(); @@ -15414,10 +14241,10 @@ impl bevy::math::U16Vec2 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec2::saturating_add( + _self: Val<::glam::U16Vec2>, + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -15427,10 +14254,10 @@ impl bevy::math::U16Vec2 { /// Returns a vector containing the saturating addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.saturating_add_signed(rhs.x), self.y.saturating_add_signed(rhs.y), ..]`. fn saturating_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec2::saturating_add_signed( + _self: Val<::glam::U16Vec2>, + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::saturating_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -15440,10 +14267,10 @@ impl bevy::math::U16Vec2 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec2::saturating_div( + _self: Val<::glam::U16Vec2>, + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -15453,10 +14280,10 @@ impl bevy::math::U16Vec2 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec2::saturating_mul( + _self: Val<::glam::U16Vec2>, + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -15466,10 +14293,10 @@ impl bevy::math::U16Vec2 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec2::saturating_sub( + _self: Val<::glam::U16Vec2>, + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -15481,11 +14308,11 @@ impl bevy::math::U16Vec2 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec2::select( + mask: Val<::glam::BVec2>, + if_true: Val<::glam::U16Vec2>, + if_false: Val<::glam::U16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -15494,67 +14321,61 @@ impl bevy::math::U16Vec2 { output } /// Creates a vector with all elements set to `v`. - fn splat(v: u16) -> Val { - let output: Val = bevy::math::U16Vec2::splat(v).into(); + fn splat(v: u16) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::splat(v).into(); output } fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Sub< + &::glam::U16Vec2, >>::sub(_self.into_inner(), &rhs) .into(); output } fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Sub< + ::glam::U16Vec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: u16) -> Val { - let output: Val = , rhs: u16) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = <::glam::U16Vec2 as ::core::ops::Sub< u16, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y]` - fn to_array(_self: Ref) -> [u16; 2] { - let output: [u16; 2] = bevy::math::U16Vec2::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::U16Vec2>) -> [u16; 2] { + let output: [u16; 2] = ::glam::U16Vec2::to_array(&_self).into(); output } /// Creates a 2D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: u16) -> Val { - let output: Val = bevy::math::U16Vec2::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::U16Vec2>, x: u16) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::with_x(_self.into_inner(), x) .into(); output } /// Creates a 2D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: u16) -> Val { - let output: Val = bevy::math::U16Vec2::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::U16Vec2>, y: u16) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::with_y(_self.into_inner(), y) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec2::wrapping_add( + _self: Val<::glam::U16Vec2>, + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -15564,10 +14385,10 @@ impl bevy::math::U16Vec2 { /// Returns a vector containing the wrapping addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.wrapping_add_signed(rhs.x), self.y.wrapping_add_signed(rhs.y), ..]`. fn wrapping_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec2::wrapping_add_signed( + _self: Val<::glam::U16Vec2>, + rhs: Val<::glam::I16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::wrapping_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -15577,10 +14398,10 @@ impl bevy::math::U16Vec2 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec2::wrapping_div( + _self: Val<::glam::U16Vec2>, + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -15590,10 +14411,10 @@ impl bevy::math::U16Vec2 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec2::wrapping_mul( + _self: Val<::glam::U16Vec2>, + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -15603,10 +14424,10 @@ impl bevy::math::U16Vec2 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec2::wrapping_sub( + _self: Val<::glam::U16Vec2>, + rhs: Val<::glam::U16Vec2>, + ) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::U16Vec2::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -15620,95 +14441,86 @@ impl bevy::math::U16Vec2 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::U16Vec3 { +impl ::glam::U16Vec3 { fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Add< + &::glam::U16Vec3, >>::add(_self.into_inner(), &rhs) .into(); output } fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Add< + ::glam::U16Vec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: u16) -> Val { - let output: Val = , rhs: u16) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Add< u16, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec3(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec3::as_dvec3(&_self) - .into(); + fn as_dvec3(_self: Ref<::glam::U16Vec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::U16Vec3::as_dvec3(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec3(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec3::as_i16vec3(&_self) - .into(); + fn as_i16vec3(_self: Ref<::glam::U16Vec3>) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::U16Vec3::as_i16vec3(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec3(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec3::as_i64vec3(&_self) - .into(); + fn as_i64vec3(_self: Ref<::glam::U16Vec3>) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::U16Vec3::as_i64vec3(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec3(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec3::as_i8vec3(&_self) - .into(); + fn as_i8vec3(_self: Ref<::glam::U16Vec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::U16Vec3::as_i8vec3(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec3(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec3::as_ivec3(&_self) - .into(); + fn as_ivec3(_self: Ref<::glam::U16Vec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::U16Vec3::as_ivec3(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec3(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec3::as_u64vec3(&_self) - .into(); + fn as_u64vec3(_self: Ref<::glam::U16Vec3>) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U16Vec3::as_u64vec3(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec3(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec3::as_u8vec3(&_self) - .into(); + fn as_u8vec3(_self: Ref<::glam::U16Vec3>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U16Vec3::as_u8vec3(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec3(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec3::as_uvec3(&_self) - .into(); + fn as_uvec3(_self: Ref<::glam::U16Vec3>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::U16Vec3::as_uvec3(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec3(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec3::as_vec3(&_self).into(); + fn as_vec3(_self: Ref<::glam::U16Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::U16Vec3::as_vec3(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec3a(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec3::as_vec3a(&_self) - .into(); + fn as_vec3a(_self: Ref<::glam::U16Vec3>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::U16Vec3::as_vec3a(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::U16Vec3>) -> () { + let output: () = <::glam::U16Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -15719,11 +14531,11 @@ impl bevy::math::U16Vec3 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec3::clamp( + _self: Val<::glam::U16Vec3>, + min: Val<::glam::U16Vec3>, + max: Val<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -15731,8 +14543,8 @@ impl bevy::math::U16Vec3 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::U16Vec3>) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -15743,10 +14555,10 @@ impl bevy::math::U16Vec3 { /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec3::cmpeq( + _self: Val<::glam::U16Vec3>, + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::U16Vec3::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -15758,10 +14570,10 @@ impl bevy::math::U16Vec3 { /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec3::cmpge( + _self: Val<::glam::U16Vec3>, + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::U16Vec3::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -15773,10 +14585,10 @@ impl bevy::math::U16Vec3 { /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec3::cmpgt( + _self: Val<::glam::U16Vec3>, + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::U16Vec3::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -15788,10 +14600,10 @@ impl bevy::math::U16Vec3 { /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec3::cmple( + _self: Val<::glam::U16Vec3>, + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::U16Vec3::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -15803,10 +14615,10 @@ impl bevy::math::U16Vec3 { /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec3::cmplt( + _self: Val<::glam::U16Vec3>, + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::U16Vec3::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -15818,10 +14630,10 @@ impl bevy::math::U16Vec3 { /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec3::cmpne( + _self: Val<::glam::U16Vec3>, + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::U16Vec3::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -15830,10 +14642,10 @@ impl bevy::math::U16Vec3 { } /// Computes the cross product of `self` and `rhs`. fn cross( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec3::cross( + _self: Val<::glam::U16Vec3>, + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::cross( _self.into_inner(), rhs.into_inner(), ) @@ -15841,44 +14653,44 @@ impl bevy::math::U16Vec3 { output } fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Div< + &::glam::U16Vec3, >>::div(_self.into_inner(), &rhs) .into(); output } fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Div< + ::glam::U16Vec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: u16) -> Val { - let output: Val = , rhs: u16) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Div< u16, >>::div(_self.into_inner(), rhs) .into(); output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> u16 { - let output: u16 = bevy::math::U16Vec3::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::U16Vec3>, rhs: Val<::glam::U16Vec3>) -> u16 { + let output: u16 = ::glam::U16Vec3::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec3::dot_into_vec( + _self: Val<::glam::U16Vec3>, + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -15887,50 +14699,46 @@ impl bevy::math::U16Vec3 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> u16 { - let output: u16 = bevy::math::U16Vec3::element_product(_self.into_inner()) - .into(); + fn element_product(_self: Val<::glam::U16Vec3>) -> u16 { + let output: u16 = ::glam::U16Vec3::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> u16 { - let output: u16 = bevy::math::U16Vec3::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::U16Vec3>) -> u16 { + let output: u16 = ::glam::U16Vec3::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::U16Vec3>) -> bool { + let output: bool = <::glam::U16Vec3 as ::core::cmp::PartialEq< + ::glam::U16Vec3, >>::eq(&_self, &other) .into(); output } /// Creates a 4D vector from `self` and the given `w` value. - fn extend(_self: Val, w: u16) -> Val { - let output: Val = bevy::math::U16Vec3::extend( - _self.into_inner(), - w, - ) + fn extend(_self: Val<::glam::U16Vec3>, w: u16) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U16Vec3::extend(_self.into_inner(), w) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [u16; 3]) -> Val { - let output: Val = bevy::math::U16Vec3::from_array(a).into(); + fn from_array(a: [u16; 3]) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::from_array(a).into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> u16 { - let output: u16 = bevy::math::U16Vec3::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::U16Vec3>) -> u16 { + let output: u16 = ::glam::U16Vec3::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec3::max( + _self: Val<::glam::U16Vec3>, + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::max( _self.into_inner(), rhs.into_inner(), ) @@ -15939,17 +14747,17 @@ impl bevy::math::U16Vec3 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> u16 { - let output: u16 = bevy::math::U16Vec3::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::U16Vec3>) -> u16 { + let output: u16 = ::glam::U16Vec3::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec3::min( + _self: Val<::glam::U16Vec3>, + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::min( _self.into_inner(), rhs.into_inner(), ) @@ -15958,64 +14766,64 @@ impl bevy::math::U16Vec3 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> u16 { - let output: u16 = bevy::math::U16Vec3::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::U16Vec3>) -> u16 { + let output: u16 = ::glam::U16Vec3::min_element(_self.into_inner()).into(); output } fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Mul< + &::glam::U16Vec3, >>::mul(_self.into_inner(), &rhs) .into(); output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Mul< + ::glam::U16Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: u16) -> Val { - let output: Val = , rhs: u16) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Mul< u16, >>::mul(_self.into_inner(), rhs) .into(); output } /// Creates a new vector. - fn new(x: u16, y: u16, z: u16) -> Val { - let output: Val = bevy::math::U16Vec3::new(x, y, z).into(); + fn new(x: u16, y: u16, z: u16) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::new(x, y, z).into(); output } fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Rem< + &::glam::U16Vec3, >>::rem(_self.into_inner(), &rhs) .into(); output } fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Rem< + ::glam::U16Vec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: u16) -> Val { - let output: Val = , rhs: u16) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Rem< u16, >>::rem(_self.into_inner(), rhs) .into(); @@ -16024,10 +14832,10 @@ impl bevy::math::U16Vec3 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec3::saturating_add( + _self: Val<::glam::U16Vec3>, + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -16037,10 +14845,10 @@ impl bevy::math::U16Vec3 { /// Returns a vector containing the saturating addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.saturating_add_signed(rhs.x), self.y.saturating_add_signed(rhs.y), ..]`. fn saturating_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec3::saturating_add_signed( + _self: Val<::glam::U16Vec3>, + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::saturating_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -16050,10 +14858,10 @@ impl bevy::math::U16Vec3 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec3::saturating_div( + _self: Val<::glam::U16Vec3>, + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -16063,10 +14871,10 @@ impl bevy::math::U16Vec3 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec3::saturating_mul( + _self: Val<::glam::U16Vec3>, + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -16076,10 +14884,10 @@ impl bevy::math::U16Vec3 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec3::saturating_sub( + _self: Val<::glam::U16Vec3>, + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -16091,11 +14899,11 @@ impl bevy::math::U16Vec3 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec3::select( + mask: Val<::glam::BVec3>, + if_true: Val<::glam::U16Vec3>, + if_false: Val<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -16104,85 +14912,74 @@ impl bevy::math::U16Vec3 { output } /// Creates a vector with all elements set to `v`. - fn splat(v: u16) -> Val { - let output: Val = bevy::math::U16Vec3::splat(v).into(); + fn splat(v: u16) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::splat(v).into(); output } fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Sub< + &::glam::U16Vec3, >>::sub(_self.into_inner(), &rhs) .into(); output } fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Sub< + ::glam::U16Vec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: u16) -> Val { - let output: Val = , rhs: u16) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = <::glam::U16Vec3 as ::core::ops::Sub< u16, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y, z]` - fn to_array(_self: Ref) -> [u16; 3] { - let output: [u16; 3] = bevy::math::U16Vec3::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::U16Vec3>) -> [u16; 3] { + let output: [u16; 3] = ::glam::U16Vec3::to_array(&_self).into(); output } /// Creates a 2D vector from the `x` and `y` elements of `self`, discarding `z`. /// Truncation may also be performed by using [`self.xy()`][crate::swizzles::Vec3Swizzles::xy()]. - fn truncate(_self: Val) -> Val { - let output: Val = bevy::math::U16Vec3::truncate( - _self.into_inner(), - ) + fn truncate(_self: Val<::glam::U16Vec3>) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::U16Vec3::truncate(_self.into_inner()) .into(); output } /// Creates a 3D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: u16) -> Val { - let output: Val = bevy::math::U16Vec3::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::U16Vec3>, x: u16) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::with_x(_self.into_inner(), x) .into(); output } /// Creates a 3D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: u16) -> Val { - let output: Val = bevy::math::U16Vec3::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::U16Vec3>, y: u16) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::with_y(_self.into_inner(), y) .into(); output } /// Creates a 3D vector from `self` with the given value of `z`. - fn with_z(_self: Val, z: u16) -> Val { - let output: Val = bevy::math::U16Vec3::with_z( - _self.into_inner(), - z, - ) + fn with_z(_self: Val<::glam::U16Vec3>, z: u16) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::with_z(_self.into_inner(), z) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec3::wrapping_add( + _self: Val<::glam::U16Vec3>, + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -16192,10 +14989,10 @@ impl bevy::math::U16Vec3 { /// Returns a vector containing the wrapping addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.wrapping_add_signed(rhs.x), self.y.wrapping_add_signed(rhs.y), ..]`. fn wrapping_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec3::wrapping_add_signed( + _self: Val<::glam::U16Vec3>, + rhs: Val<::glam::I16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::wrapping_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -16205,10 +15002,10 @@ impl bevy::math::U16Vec3 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec3::wrapping_div( + _self: Val<::glam::U16Vec3>, + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -16218,10 +15015,10 @@ impl bevy::math::U16Vec3 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec3::wrapping_mul( + _self: Val<::glam::U16Vec3>, + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -16231,10 +15028,10 @@ impl bevy::math::U16Vec3 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec3::wrapping_sub( + _self: Val<::glam::U16Vec3>, + rhs: Val<::glam::U16Vec3>, + ) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec3::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -16248,89 +15045,81 @@ impl bevy::math::U16Vec3 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::U16Vec4 { +impl ::glam::U16Vec4 { fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Add< + &::glam::U16Vec4, >>::add(_self.into_inner(), &rhs) .into(); output } fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Add< + ::glam::U16Vec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: u16) -> Val { - let output: Val = , rhs: u16) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Add< u16, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec4(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec4::as_dvec4(&_self) - .into(); + fn as_dvec4(_self: Ref<::glam::U16Vec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::U16Vec4::as_dvec4(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec4(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec4::as_i16vec4(&_self) - .into(); + fn as_i16vec4(_self: Ref<::glam::U16Vec4>) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::U16Vec4::as_i16vec4(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec4(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec4::as_i64vec4(&_self) - .into(); + fn as_i64vec4(_self: Ref<::glam::U16Vec4>) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::U16Vec4::as_i64vec4(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec4(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec4::as_i8vec4(&_self) - .into(); + fn as_i8vec4(_self: Ref<::glam::U16Vec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::U16Vec4::as_i8vec4(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec4(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec4::as_ivec4(&_self) - .into(); + fn as_ivec4(_self: Ref<::glam::U16Vec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::U16Vec4::as_ivec4(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec4(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec4::as_u64vec4(&_self) - .into(); + fn as_u64vec4(_self: Ref<::glam::U16Vec4>) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U16Vec4::as_u64vec4(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec4(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec4::as_u8vec4(&_self) - .into(); + fn as_u8vec4(_self: Ref<::glam::U16Vec4>) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U16Vec4::as_u8vec4(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec4(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec4::as_uvec4(&_self) - .into(); + fn as_uvec4(_self: Ref<::glam::U16Vec4>) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::U16Vec4::as_uvec4(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec4(_self: Ref) -> Val { - let output: Val = bevy::math::U16Vec4::as_vec4(&_self).into(); + fn as_vec4(_self: Ref<::glam::U16Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::U16Vec4::as_vec4(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::U16Vec4>) -> () { + let output: () = <::glam::U16Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -16341,11 +15130,11 @@ impl bevy::math::U16Vec4 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec4::clamp( + _self: Val<::glam::U16Vec4>, + min: Val<::glam::U16Vec4>, + max: Val<::glam::U16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -16353,8 +15142,8 @@ impl bevy::math::U16Vec4 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::U16Vec4>) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -16365,10 +15154,10 @@ impl bevy::math::U16Vec4 { /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec4::cmpeq( + _self: Val<::glam::U16Vec4>, + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::U16Vec4::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -16380,10 +15169,10 @@ impl bevy::math::U16Vec4 { /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec4::cmpge( + _self: Val<::glam::U16Vec4>, + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::U16Vec4::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -16395,10 +15184,10 @@ impl bevy::math::U16Vec4 { /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec4::cmpgt( + _self: Val<::glam::U16Vec4>, + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::U16Vec4::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -16410,10 +15199,10 @@ impl bevy::math::U16Vec4 { /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec4::cmple( + _self: Val<::glam::U16Vec4>, + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::U16Vec4::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -16425,10 +15214,10 @@ impl bevy::math::U16Vec4 { /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec4::cmplt( + _self: Val<::glam::U16Vec4>, + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::U16Vec4::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -16440,10 +15229,10 @@ impl bevy::math::U16Vec4 { /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec4::cmpne( + _self: Val<::glam::U16Vec4>, + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::U16Vec4::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -16451,44 +15240,44 @@ impl bevy::math::U16Vec4 { output } fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Div< + &::glam::U16Vec4, >>::div(_self.into_inner(), &rhs) .into(); output } fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Div< + ::glam::U16Vec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: u16) -> Val { - let output: Val = , rhs: u16) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Div< u16, >>::div(_self.into_inner(), rhs) .into(); output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> u16 { - let output: u16 = bevy::math::U16Vec4::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::U16Vec4>, rhs: Val<::glam::U16Vec4>) -> u16 { + let output: u16 = ::glam::U16Vec4::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec4::dot_into_vec( + _self: Val<::glam::U16Vec4>, + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -16497,41 +15286,40 @@ impl bevy::math::U16Vec4 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> u16 { - let output: u16 = bevy::math::U16Vec4::element_product(_self.into_inner()) - .into(); + fn element_product(_self: Val<::glam::U16Vec4>) -> u16 { + let output: u16 = ::glam::U16Vec4::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> u16 { - let output: u16 = bevy::math::U16Vec4::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::U16Vec4>) -> u16 { + let output: u16 = ::glam::U16Vec4::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::U16Vec4>) -> bool { + let output: bool = <::glam::U16Vec4 as ::core::cmp::PartialEq< + ::glam::U16Vec4, >>::eq(&_self, &other) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [u16; 4]) -> Val { - let output: Val = bevy::math::U16Vec4::from_array(a).into(); + fn from_array(a: [u16; 4]) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::from_array(a).into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> u16 { - let output: u16 = bevy::math::U16Vec4::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::U16Vec4>) -> u16 { + let output: u16 = ::glam::U16Vec4::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec4::max( + _self: Val<::glam::U16Vec4>, + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::max( _self.into_inner(), rhs.into_inner(), ) @@ -16540,17 +15328,17 @@ impl bevy::math::U16Vec4 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> u16 { - let output: u16 = bevy::math::U16Vec4::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::U16Vec4>) -> u16 { + let output: u16 = ::glam::U16Vec4::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec4::min( + _self: Val<::glam::U16Vec4>, + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::min( _self.into_inner(), rhs.into_inner(), ) @@ -16559,65 +15347,64 @@ impl bevy::math::U16Vec4 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> u16 { - let output: u16 = bevy::math::U16Vec4::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::U16Vec4>) -> u16 { + let output: u16 = ::glam::U16Vec4::min_element(_self.into_inner()).into(); output } fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Mul< + &::glam::U16Vec4, >>::mul(_self.into_inner(), &rhs) .into(); output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Mul< + ::glam::U16Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: u16) -> Val { - let output: Val = , rhs: u16) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Mul< u16, >>::mul(_self.into_inner(), rhs) .into(); output } /// Creates a new vector. - fn new(x: u16, y: u16, z: u16, w: u16) -> Val { - let output: Val = bevy::math::U16Vec4::new(x, y, z, w) - .into(); + fn new(x: u16, y: u16, z: u16, w: u16) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::new(x, y, z, w).into(); output } fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Rem< + &::glam::U16Vec4, >>::rem(_self.into_inner(), &rhs) .into(); output } fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Rem< + ::glam::U16Vec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: u16) -> Val { - let output: Val = , rhs: u16) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Rem< u16, >>::rem(_self.into_inner(), rhs) .into(); @@ -16626,10 +15413,10 @@ impl bevy::math::U16Vec4 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec4::saturating_add( + _self: Val<::glam::U16Vec4>, + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -16639,10 +15426,10 @@ impl bevy::math::U16Vec4 { /// Returns a vector containing the saturating addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.saturating_add_signed(rhs.x), self.y.saturating_add_signed(rhs.y), ..]`. fn saturating_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec4::saturating_add_signed( + _self: Val<::glam::U16Vec4>, + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::saturating_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -16652,10 +15439,10 @@ impl bevy::math::U16Vec4 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec4::saturating_div( + _self: Val<::glam::U16Vec4>, + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -16665,10 +15452,10 @@ impl bevy::math::U16Vec4 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec4::saturating_mul( + _self: Val<::glam::U16Vec4>, + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -16678,10 +15465,10 @@ impl bevy::math::U16Vec4 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec4::saturating_sub( + _self: Val<::glam::U16Vec4>, + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -16693,11 +15480,11 @@ impl bevy::math::U16Vec4 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec4::select( + mask: Val<::glam::BVec4>, + if_true: Val<::glam::U16Vec4>, + if_false: Val<::glam::U16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -16706,94 +15493,80 @@ impl bevy::math::U16Vec4 { output } /// Creates a vector with all elements set to `v`. - fn splat(v: u16) -> Val { - let output: Val = bevy::math::U16Vec4::splat(v).into(); + fn splat(v: u16) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::splat(v).into(); output } fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Sub< + &::glam::U16Vec4, >>::sub(_self.into_inner(), &rhs) .into(); output } fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Sub< + ::glam::U16Vec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: u16) -> Val { - let output: Val = , rhs: u16) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = <::glam::U16Vec4 as ::core::ops::Sub< u16, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y, z, w]` - fn to_array(_self: Ref) -> [u16; 4] { - let output: [u16; 4] = bevy::math::U16Vec4::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::U16Vec4>) -> [u16; 4] { + let output: [u16; 4] = ::glam::U16Vec4::to_array(&_self).into(); output } /// Creates a 3D vector from the `x`, `y` and `z` elements of `self`, discarding `w`. /// Truncation to [`U16Vec3`] may also be performed by using [`self.xyz()`][crate::swizzles::Vec4Swizzles::xyz()]. - fn truncate(_self: Val) -> Val { - let output: Val = bevy::math::U16Vec4::truncate( - _self.into_inner(), - ) + fn truncate(_self: Val<::glam::U16Vec4>) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U16Vec4::truncate(_self.into_inner()) .into(); output } /// Creates a 4D vector from `self` with the given value of `w`. - fn with_w(_self: Val, w: u16) -> Val { - let output: Val = bevy::math::U16Vec4::with_w( - _self.into_inner(), - w, - ) + fn with_w(_self: Val<::glam::U16Vec4>, w: u16) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::with_w(_self.into_inner(), w) .into(); output } /// Creates a 4D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: u16) -> Val { - let output: Val = bevy::math::U16Vec4::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::U16Vec4>, x: u16) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::with_x(_self.into_inner(), x) .into(); output } /// Creates a 4D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: u16) -> Val { - let output: Val = bevy::math::U16Vec4::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::U16Vec4>, y: u16) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::with_y(_self.into_inner(), y) .into(); output } /// Creates a 4D vector from `self` with the given value of `z`. - fn with_z(_self: Val, z: u16) -> Val { - let output: Val = bevy::math::U16Vec4::with_z( - _self.into_inner(), - z, - ) + fn with_z(_self: Val<::glam::U16Vec4>, z: u16) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::with_z(_self.into_inner(), z) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec4::wrapping_add( + _self: Val<::glam::U16Vec4>, + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -16803,10 +15576,10 @@ impl bevy::math::U16Vec4 { /// Returns a vector containing the wrapping addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.wrapping_add_signed(rhs.x), self.y.wrapping_add_signed(rhs.y), ..]`. fn wrapping_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec4::wrapping_add_signed( + _self: Val<::glam::U16Vec4>, + rhs: Val<::glam::I16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::wrapping_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -16816,10 +15589,10 @@ impl bevy::math::U16Vec4 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec4::wrapping_div( + _self: Val<::glam::U16Vec4>, + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -16829,10 +15602,10 @@ impl bevy::math::U16Vec4 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec4::wrapping_mul( + _self: Val<::glam::U16Vec4>, + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -16842,10 +15615,10 @@ impl bevy::math::U16Vec4 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U16Vec4::wrapping_sub( + _self: Val<::glam::U16Vec4>, + rhs: Val<::glam::U16Vec4>, + ) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U16Vec4::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -16859,89 +15632,81 @@ impl bevy::math::U16Vec4 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::U64Vec2 { +impl ::glam::U64Vec2 { fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Add< + &::glam::U64Vec2, >>::add(_self.into_inner(), &rhs) .into(); output } fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Add< + ::glam::U64Vec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: u64) -> Val { - let output: Val = , rhs: u64) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Add< u64, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec2(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec2::as_dvec2(&_self) - .into(); + fn as_dvec2(_self: Ref<::glam::U64Vec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::U64Vec2::as_dvec2(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec2(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec2::as_i16vec2(&_self) - .into(); + fn as_i16vec2(_self: Ref<::glam::U64Vec2>) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::U64Vec2::as_i16vec2(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec2(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec2::as_i64vec2(&_self) - .into(); + fn as_i64vec2(_self: Ref<::glam::U64Vec2>) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::U64Vec2::as_i64vec2(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec2(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec2::as_i8vec2(&_self) - .into(); + fn as_i8vec2(_self: Ref<::glam::U64Vec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::U64Vec2::as_i8vec2(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec2(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec2::as_ivec2(&_self) - .into(); + fn as_ivec2(_self: Ref<::glam::U64Vec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::U64Vec2::as_ivec2(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec2(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec2::as_u16vec2(&_self) - .into(); + fn as_u16vec2(_self: Ref<::glam::U64Vec2>) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::U64Vec2::as_u16vec2(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec2(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec2::as_u8vec2(&_self) - .into(); + fn as_u8vec2(_self: Ref<::glam::U64Vec2>) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::U64Vec2::as_u8vec2(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec2(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec2::as_uvec2(&_self) - .into(); + fn as_uvec2(_self: Ref<::glam::U64Vec2>) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::U64Vec2::as_uvec2(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec2(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec2::as_vec2(&_self).into(); + fn as_vec2(_self: Ref<::glam::U64Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::U64Vec2::as_vec2(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::U64Vec2>) -> () { + let output: () = <::glam::U64Vec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -16952,11 +15717,11 @@ impl bevy::math::U64Vec2 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec2::clamp( + _self: Val<::glam::U64Vec2>, + min: Val<::glam::U64Vec2>, + max: Val<::glam::U64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -16964,8 +15729,8 @@ impl bevy::math::U64Vec2 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::U64Vec2>) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -16976,10 +15741,10 @@ impl bevy::math::U64Vec2 { /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec2::cmpeq( + _self: Val<::glam::U64Vec2>, + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::U64Vec2::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -16991,10 +15756,10 @@ impl bevy::math::U64Vec2 { /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec2::cmpge( + _self: Val<::glam::U64Vec2>, + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::U64Vec2::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -17006,10 +15771,10 @@ impl bevy::math::U64Vec2 { /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec2::cmpgt( + _self: Val<::glam::U64Vec2>, + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::U64Vec2::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -17021,10 +15786,10 @@ impl bevy::math::U64Vec2 { /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec2::cmple( + _self: Val<::glam::U64Vec2>, + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::U64Vec2::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -17036,10 +15801,10 @@ impl bevy::math::U64Vec2 { /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec2::cmplt( + _self: Val<::glam::U64Vec2>, + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::U64Vec2::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -17051,10 +15816,10 @@ impl bevy::math::U64Vec2 { /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec2::cmpne( + _self: Val<::glam::U64Vec2>, + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::U64Vec2::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -17062,44 +15827,44 @@ impl bevy::math::U64Vec2 { output } fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Div< + &::glam::U64Vec2, >>::div(_self.into_inner(), &rhs) .into(); output } fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Div< + ::glam::U64Vec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: u64) -> Val { - let output: Val = , rhs: u64) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Div< u64, >>::div(_self.into_inner(), rhs) .into(); output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> u64 { - let output: u64 = bevy::math::U64Vec2::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::U64Vec2>, rhs: Val<::glam::U64Vec2>) -> u64 { + let output: u64 = ::glam::U64Vec2::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec2::dot_into_vec( + _self: Val<::glam::U64Vec2>, + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -17108,50 +15873,46 @@ impl bevy::math::U64Vec2 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> u64 { - let output: u64 = bevy::math::U64Vec2::element_product(_self.into_inner()) - .into(); + fn element_product(_self: Val<::glam::U64Vec2>) -> u64 { + let output: u64 = ::glam::U64Vec2::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> u64 { - let output: u64 = bevy::math::U64Vec2::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::U64Vec2>) -> u64 { + let output: u64 = ::glam::U64Vec2::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::U64Vec2>) -> bool { + let output: bool = <::glam::U64Vec2 as ::core::cmp::PartialEq< + ::glam::U64Vec2, >>::eq(&_self, &other) .into(); output } /// Creates a 3D vector from `self` and the given `z` value. - fn extend(_self: Val, z: u64) -> Val { - let output: Val = bevy::math::U64Vec2::extend( - _self.into_inner(), - z, - ) + fn extend(_self: Val<::glam::U64Vec2>, z: u64) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec2::extend(_self.into_inner(), z) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [u64; 2]) -> Val { - let output: Val = bevy::math::U64Vec2::from_array(a).into(); + fn from_array(a: [u64; 2]) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::from_array(a).into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> u64 { - let output: u64 = bevy::math::U64Vec2::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::U64Vec2>) -> u64 { + let output: u64 = ::glam::U64Vec2::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec2::max( + _self: Val<::glam::U64Vec2>, + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::max( _self.into_inner(), rhs.into_inner(), ) @@ -17160,17 +15921,17 @@ impl bevy::math::U64Vec2 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> u64 { - let output: u64 = bevy::math::U64Vec2::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::U64Vec2>) -> u64 { + let output: u64 = ::glam::U64Vec2::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec2::min( + _self: Val<::glam::U64Vec2>, + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::min( _self.into_inner(), rhs.into_inner(), ) @@ -17179,64 +15940,64 @@ impl bevy::math::U64Vec2 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> u64 { - let output: u64 = bevy::math::U64Vec2::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::U64Vec2>) -> u64 { + let output: u64 = ::glam::U64Vec2::min_element(_self.into_inner()).into(); output } fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Mul< + &::glam::U64Vec2, >>::mul(_self.into_inner(), &rhs) .into(); output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Mul< + ::glam::U64Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: u64) -> Val { - let output: Val = , rhs: u64) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Mul< u64, >>::mul(_self.into_inner(), rhs) .into(); output } /// Creates a new vector. - fn new(x: u64, y: u64) -> Val { - let output: Val = bevy::math::U64Vec2::new(x, y).into(); + fn new(x: u64, y: u64) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::new(x, y).into(); output } fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Rem< + &::glam::U64Vec2, >>::rem(_self.into_inner(), &rhs) .into(); output } fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Rem< + ::glam::U64Vec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: u64) -> Val { - let output: Val = , rhs: u64) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Rem< u64, >>::rem(_self.into_inner(), rhs) .into(); @@ -17245,10 +16006,10 @@ impl bevy::math::U64Vec2 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec2::saturating_add( + _self: Val<::glam::U64Vec2>, + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -17258,10 +16019,10 @@ impl bevy::math::U64Vec2 { /// Returns a vector containing the saturating addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.saturating_add_signed(rhs.x), self.y.saturating_add_signed(rhs.y), ..]`. fn saturating_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec2::saturating_add_signed( + _self: Val<::glam::U64Vec2>, + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::saturating_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -17271,10 +16032,10 @@ impl bevy::math::U64Vec2 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec2::saturating_div( + _self: Val<::glam::U64Vec2>, + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -17284,10 +16045,10 @@ impl bevy::math::U64Vec2 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec2::saturating_mul( + _self: Val<::glam::U64Vec2>, + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -17297,10 +16058,10 @@ impl bevy::math::U64Vec2 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec2::saturating_sub( + _self: Val<::glam::U64Vec2>, + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -17312,11 +16073,11 @@ impl bevy::math::U64Vec2 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec2::select( + mask: Val<::glam::BVec2>, + if_true: Val<::glam::U64Vec2>, + if_false: Val<::glam::U64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -17325,67 +16086,61 @@ impl bevy::math::U64Vec2 { output } /// Creates a vector with all elements set to `v`. - fn splat(v: u64) -> Val { - let output: Val = bevy::math::U64Vec2::splat(v).into(); + fn splat(v: u64) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::splat(v).into(); output } fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Sub< + &::glam::U64Vec2, >>::sub(_self.into_inner(), &rhs) .into(); output } fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Sub< + ::glam::U64Vec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: u64) -> Val { - let output: Val = , rhs: u64) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = <::glam::U64Vec2 as ::core::ops::Sub< u64, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y]` - fn to_array(_self: Ref) -> [u64; 2] { - let output: [u64; 2] = bevy::math::U64Vec2::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::U64Vec2>) -> [u64; 2] { + let output: [u64; 2] = ::glam::U64Vec2::to_array(&_self).into(); output } /// Creates a 2D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: u64) -> Val { - let output: Val = bevy::math::U64Vec2::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::U64Vec2>, x: u64) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::with_x(_self.into_inner(), x) .into(); output } /// Creates a 2D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: u64) -> Val { - let output: Val = bevy::math::U64Vec2::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::U64Vec2>, y: u64) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::with_y(_self.into_inner(), y) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec2::wrapping_add( + _self: Val<::glam::U64Vec2>, + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -17395,10 +16150,10 @@ impl bevy::math::U64Vec2 { /// Returns a vector containing the wrapping addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.wrapping_add_signed(rhs.x), self.y.wrapping_add_signed(rhs.y), ..]`. fn wrapping_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec2::wrapping_add_signed( + _self: Val<::glam::U64Vec2>, + rhs: Val<::glam::I64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::wrapping_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -17408,10 +16163,10 @@ impl bevy::math::U64Vec2 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec2::wrapping_div( + _self: Val<::glam::U64Vec2>, + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -17421,10 +16176,10 @@ impl bevy::math::U64Vec2 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec2::wrapping_mul( + _self: Val<::glam::U64Vec2>, + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -17434,10 +16189,10 @@ impl bevy::math::U64Vec2 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec2::wrapping_sub( + _self: Val<::glam::U64Vec2>, + rhs: Val<::glam::U64Vec2>, + ) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::U64Vec2::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -17451,95 +16206,86 @@ impl bevy::math::U64Vec2 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::U64Vec3 { +impl ::glam::U64Vec3 { fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Add< + &::glam::U64Vec3, >>::add(_self.into_inner(), &rhs) .into(); output } fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Add< + ::glam::U64Vec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: u64) -> Val { - let output: Val = , rhs: u64) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Add< u64, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec3(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec3::as_dvec3(&_self) - .into(); + fn as_dvec3(_self: Ref<::glam::U64Vec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::U64Vec3::as_dvec3(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec3(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec3::as_i16vec3(&_self) - .into(); + fn as_i16vec3(_self: Ref<::glam::U64Vec3>) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::U64Vec3::as_i16vec3(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec3(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec3::as_i64vec3(&_self) - .into(); + fn as_i64vec3(_self: Ref<::glam::U64Vec3>) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::U64Vec3::as_i64vec3(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec3(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec3::as_i8vec3(&_self) - .into(); + fn as_i8vec3(_self: Ref<::glam::U64Vec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::U64Vec3::as_i8vec3(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec3(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec3::as_ivec3(&_self) - .into(); + fn as_ivec3(_self: Ref<::glam::U64Vec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::U64Vec3::as_ivec3(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec3(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec3::as_u16vec3(&_self) - .into(); + fn as_u16vec3(_self: Ref<::glam::U64Vec3>) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::U64Vec3::as_u16vec3(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec3(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec3::as_u8vec3(&_self) - .into(); + fn as_u8vec3(_self: Ref<::glam::U64Vec3>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::U64Vec3::as_u8vec3(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec3(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec3::as_uvec3(&_self) - .into(); + fn as_uvec3(_self: Ref<::glam::U64Vec3>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::U64Vec3::as_uvec3(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec3(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec3::as_vec3(&_self).into(); + fn as_vec3(_self: Ref<::glam::U64Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::U64Vec3::as_vec3(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec3a(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec3::as_vec3a(&_self) - .into(); + fn as_vec3a(_self: Ref<::glam::U64Vec3>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::U64Vec3::as_vec3a(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::U64Vec3>) -> () { + let output: () = <::glam::U64Vec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -17550,11 +16296,11 @@ impl bevy::math::U64Vec3 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec3::clamp( + _self: Val<::glam::U64Vec3>, + min: Val<::glam::U64Vec3>, + max: Val<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -17562,8 +16308,8 @@ impl bevy::math::U64Vec3 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::U64Vec3>) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -17574,10 +16320,10 @@ impl bevy::math::U64Vec3 { /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec3::cmpeq( + _self: Val<::glam::U64Vec3>, + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::U64Vec3::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -17589,10 +16335,10 @@ impl bevy::math::U64Vec3 { /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec3::cmpge( + _self: Val<::glam::U64Vec3>, + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::U64Vec3::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -17604,10 +16350,10 @@ impl bevy::math::U64Vec3 { /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec3::cmpgt( + _self: Val<::glam::U64Vec3>, + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::U64Vec3::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -17619,10 +16365,10 @@ impl bevy::math::U64Vec3 { /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec3::cmple( + _self: Val<::glam::U64Vec3>, + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::U64Vec3::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -17634,10 +16380,10 @@ impl bevy::math::U64Vec3 { /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec3::cmplt( + _self: Val<::glam::U64Vec3>, + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::U64Vec3::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -17649,10 +16395,10 @@ impl bevy::math::U64Vec3 { /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec3::cmpne( + _self: Val<::glam::U64Vec3>, + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::U64Vec3::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -17661,10 +16407,10 @@ impl bevy::math::U64Vec3 { } /// Computes the cross product of `self` and `rhs`. fn cross( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec3::cross( + _self: Val<::glam::U64Vec3>, + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::cross( _self.into_inner(), rhs.into_inner(), ) @@ -17672,44 +16418,44 @@ impl bevy::math::U64Vec3 { output } fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Div< + &::glam::U64Vec3, >>::div(_self.into_inner(), &rhs) .into(); output } fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Div< + ::glam::U64Vec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: u64) -> Val { - let output: Val = , rhs: u64) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Div< u64, >>::div(_self.into_inner(), rhs) .into(); output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> u64 { - let output: u64 = bevy::math::U64Vec3::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::U64Vec3>, rhs: Val<::glam::U64Vec3>) -> u64 { + let output: u64 = ::glam::U64Vec3::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec3::dot_into_vec( + _self: Val<::glam::U64Vec3>, + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -17718,50 +16464,46 @@ impl bevy::math::U64Vec3 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> u64 { - let output: u64 = bevy::math::U64Vec3::element_product(_self.into_inner()) - .into(); + fn element_product(_self: Val<::glam::U64Vec3>) -> u64 { + let output: u64 = ::glam::U64Vec3::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> u64 { - let output: u64 = bevy::math::U64Vec3::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::U64Vec3>) -> u64 { + let output: u64 = ::glam::U64Vec3::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::U64Vec3>) -> bool { + let output: bool = <::glam::U64Vec3 as ::core::cmp::PartialEq< + ::glam::U64Vec3, >>::eq(&_self, &other) .into(); output } /// Creates a 4D vector from `self` and the given `w` value. - fn extend(_self: Val, w: u64) -> Val { - let output: Val = bevy::math::U64Vec3::extend( - _self.into_inner(), - w, - ) + fn extend(_self: Val<::glam::U64Vec3>, w: u64) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U64Vec3::extend(_self.into_inner(), w) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [u64; 3]) -> Val { - let output: Val = bevy::math::U64Vec3::from_array(a).into(); + fn from_array(a: [u64; 3]) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::from_array(a).into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> u64 { - let output: u64 = bevy::math::U64Vec3::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::U64Vec3>) -> u64 { + let output: u64 = ::glam::U64Vec3::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec3::max( + _self: Val<::glam::U64Vec3>, + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::max( _self.into_inner(), rhs.into_inner(), ) @@ -17770,17 +16512,17 @@ impl bevy::math::U64Vec3 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> u64 { - let output: u64 = bevy::math::U64Vec3::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::U64Vec3>) -> u64 { + let output: u64 = ::glam::U64Vec3::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec3::min( + _self: Val<::glam::U64Vec3>, + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::min( _self.into_inner(), rhs.into_inner(), ) @@ -17789,64 +16531,64 @@ impl bevy::math::U64Vec3 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> u64 { - let output: u64 = bevy::math::U64Vec3::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::U64Vec3>) -> u64 { + let output: u64 = ::glam::U64Vec3::min_element(_self.into_inner()).into(); output } fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Mul< + &::glam::U64Vec3, >>::mul(_self.into_inner(), &rhs) .into(); output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Mul< + ::glam::U64Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: u64) -> Val { - let output: Val = , rhs: u64) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Mul< u64, >>::mul(_self.into_inner(), rhs) .into(); output } /// Creates a new vector. - fn new(x: u64, y: u64, z: u64) -> Val { - let output: Val = bevy::math::U64Vec3::new(x, y, z).into(); + fn new(x: u64, y: u64, z: u64) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::new(x, y, z).into(); output } fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Rem< + &::glam::U64Vec3, >>::rem(_self.into_inner(), &rhs) .into(); output } fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Rem< + ::glam::U64Vec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: u64) -> Val { - let output: Val = , rhs: u64) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Rem< u64, >>::rem(_self.into_inner(), rhs) .into(); @@ -17855,10 +16597,10 @@ impl bevy::math::U64Vec3 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec3::saturating_add( + _self: Val<::glam::U64Vec3>, + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -17868,10 +16610,10 @@ impl bevy::math::U64Vec3 { /// Returns a vector containing the saturating addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.saturating_add_signed(rhs.x), self.y.saturating_add_signed(rhs.y), ..]`. fn saturating_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec3::saturating_add_signed( + _self: Val<::glam::U64Vec3>, + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::saturating_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -17881,10 +16623,10 @@ impl bevy::math::U64Vec3 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec3::saturating_div( + _self: Val<::glam::U64Vec3>, + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -17894,10 +16636,10 @@ impl bevy::math::U64Vec3 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec3::saturating_mul( + _self: Val<::glam::U64Vec3>, + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -17907,10 +16649,10 @@ impl bevy::math::U64Vec3 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec3::saturating_sub( + _self: Val<::glam::U64Vec3>, + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -17922,11 +16664,11 @@ impl bevy::math::U64Vec3 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec3::select( + mask: Val<::glam::BVec3>, + if_true: Val<::glam::U64Vec3>, + if_false: Val<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -17935,85 +16677,74 @@ impl bevy::math::U64Vec3 { output } /// Creates a vector with all elements set to `v`. - fn splat(v: u64) -> Val { - let output: Val = bevy::math::U64Vec3::splat(v).into(); + fn splat(v: u64) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::splat(v).into(); output } fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Sub< + &::glam::U64Vec3, >>::sub(_self.into_inner(), &rhs) .into(); output } fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Sub< + ::glam::U64Vec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: u64) -> Val { - let output: Val = , rhs: u64) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = <::glam::U64Vec3 as ::core::ops::Sub< u64, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y, z]` - fn to_array(_self: Ref) -> [u64; 3] { - let output: [u64; 3] = bevy::math::U64Vec3::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::U64Vec3>) -> [u64; 3] { + let output: [u64; 3] = ::glam::U64Vec3::to_array(&_self).into(); output } /// Creates a 2D vector from the `x` and `y` elements of `self`, discarding `z`. /// Truncation may also be performed by using [`self.xy()`][crate::swizzles::Vec3Swizzles::xy()]. - fn truncate(_self: Val) -> Val { - let output: Val = bevy::math::U64Vec3::truncate( - _self.into_inner(), - ) + fn truncate(_self: Val<::glam::U64Vec3>) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::U64Vec3::truncate(_self.into_inner()) .into(); output } /// Creates a 3D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: u64) -> Val { - let output: Val = bevy::math::U64Vec3::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::U64Vec3>, x: u64) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::with_x(_self.into_inner(), x) .into(); output } /// Creates a 3D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: u64) -> Val { - let output: Val = bevy::math::U64Vec3::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::U64Vec3>, y: u64) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::with_y(_self.into_inner(), y) .into(); output } /// Creates a 3D vector from `self` with the given value of `z`. - fn with_z(_self: Val, z: u64) -> Val { - let output: Val = bevy::math::U64Vec3::with_z( - _self.into_inner(), - z, - ) + fn with_z(_self: Val<::glam::U64Vec3>, z: u64) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::with_z(_self.into_inner(), z) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec3::wrapping_add( + _self: Val<::glam::U64Vec3>, + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -18023,10 +16754,10 @@ impl bevy::math::U64Vec3 { /// Returns a vector containing the wrapping addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.wrapping_add_signed(rhs.x), self.y.wrapping_add_signed(rhs.y), ..]`. fn wrapping_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec3::wrapping_add_signed( + _self: Val<::glam::U64Vec3>, + rhs: Val<::glam::I64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::wrapping_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -18036,10 +16767,10 @@ impl bevy::math::U64Vec3 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec3::wrapping_div( + _self: Val<::glam::U64Vec3>, + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -18049,10 +16780,10 @@ impl bevy::math::U64Vec3 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec3::wrapping_mul( + _self: Val<::glam::U64Vec3>, + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -18062,10 +16793,10 @@ impl bevy::math::U64Vec3 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec3::wrapping_sub( + _self: Val<::glam::U64Vec3>, + rhs: Val<::glam::U64Vec3>, + ) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec3::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -18079,89 +16810,81 @@ impl bevy::math::U64Vec3 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::U64Vec4 { +impl ::glam::U64Vec4 { fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Add< + &::glam::U64Vec4, >>::add(_self.into_inner(), &rhs) .into(); output } fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Add< + ::glam::U64Vec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: u64) -> Val { - let output: Val = , rhs: u64) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Add< u64, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec4(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec4::as_dvec4(&_self) - .into(); + fn as_dvec4(_self: Ref<::glam::U64Vec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::U64Vec4::as_dvec4(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec4(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec4::as_i16vec4(&_self) - .into(); + fn as_i16vec4(_self: Ref<::glam::U64Vec4>) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::U64Vec4::as_i16vec4(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec4(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec4::as_i64vec4(&_self) - .into(); + fn as_i64vec4(_self: Ref<::glam::U64Vec4>) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::U64Vec4::as_i64vec4(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec4(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec4::as_i8vec4(&_self) - .into(); + fn as_i8vec4(_self: Ref<::glam::U64Vec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::U64Vec4::as_i8vec4(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec4(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec4::as_ivec4(&_self) - .into(); + fn as_ivec4(_self: Ref<::glam::U64Vec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::U64Vec4::as_ivec4(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec4(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec4::as_u16vec4(&_self) - .into(); + fn as_u16vec4(_self: Ref<::glam::U64Vec4>) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::U64Vec4::as_u16vec4(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec4(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec4::as_u8vec4(&_self) - .into(); + fn as_u8vec4(_self: Ref<::glam::U64Vec4>) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::U64Vec4::as_u8vec4(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec4(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec4::as_uvec4(&_self) - .into(); + fn as_uvec4(_self: Ref<::glam::U64Vec4>) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::U64Vec4::as_uvec4(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec4(_self: Ref) -> Val { - let output: Val = bevy::math::U64Vec4::as_vec4(&_self).into(); + fn as_vec4(_self: Ref<::glam::U64Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::U64Vec4::as_vec4(&_self).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::U64Vec4>) -> () { + let output: () = <::glam::U64Vec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -18172,11 +16895,11 @@ impl bevy::math::U64Vec4 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec4::clamp( + _self: Val<::glam::U64Vec4>, + min: Val<::glam::U64Vec4>, + max: Val<::glam::U64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -18184,8 +16907,8 @@ impl bevy::math::U64Vec4 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::U64Vec4>) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -18196,10 +16919,10 @@ impl bevy::math::U64Vec4 { /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec4::cmpeq( + _self: Val<::glam::U64Vec4>, + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::U64Vec4::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -18211,10 +16934,10 @@ impl bevy::math::U64Vec4 { /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec4::cmpge( + _self: Val<::glam::U64Vec4>, + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::U64Vec4::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -18226,10 +16949,10 @@ impl bevy::math::U64Vec4 { /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec4::cmpgt( + _self: Val<::glam::U64Vec4>, + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::U64Vec4::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -18241,10 +16964,10 @@ impl bevy::math::U64Vec4 { /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec4::cmple( + _self: Val<::glam::U64Vec4>, + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::U64Vec4::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -18256,10 +16979,10 @@ impl bevy::math::U64Vec4 { /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec4::cmplt( + _self: Val<::glam::U64Vec4>, + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::U64Vec4::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -18271,10 +16994,10 @@ impl bevy::math::U64Vec4 { /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec4::cmpne( + _self: Val<::glam::U64Vec4>, + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::U64Vec4::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -18282,44 +17005,44 @@ impl bevy::math::U64Vec4 { output } fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Div< + &::glam::U64Vec4, >>::div(_self.into_inner(), &rhs) .into(); output } fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Div< + ::glam::U64Vec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: u64) -> Val { - let output: Val = , rhs: u64) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Div< u64, >>::div(_self.into_inner(), rhs) .into(); output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> u64 { - let output: u64 = bevy::math::U64Vec4::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::U64Vec4>, rhs: Val<::glam::U64Vec4>) -> u64 { + let output: u64 = ::glam::U64Vec4::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec4::dot_into_vec( + _self: Val<::glam::U64Vec4>, + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -18328,41 +17051,40 @@ impl bevy::math::U64Vec4 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> u64 { - let output: u64 = bevy::math::U64Vec4::element_product(_self.into_inner()) - .into(); + fn element_product(_self: Val<::glam::U64Vec4>) -> u64 { + let output: u64 = ::glam::U64Vec4::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> u64 { - let output: u64 = bevy::math::U64Vec4::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::U64Vec4>) -> u64 { + let output: u64 = ::glam::U64Vec4::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::U64Vec4>) -> bool { + let output: bool = <::glam::U64Vec4 as ::core::cmp::PartialEq< + ::glam::U64Vec4, >>::eq(&_self, &other) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [u64; 4]) -> Val { - let output: Val = bevy::math::U64Vec4::from_array(a).into(); + fn from_array(a: [u64; 4]) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::from_array(a).into(); output } /// Computes the squared length of `self`. - fn length_squared(_self: Val) -> u64 { - let output: u64 = bevy::math::U64Vec4::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::U64Vec4>) -> u64 { + let output: u64 = ::glam::U64Vec4::length_squared(_self.into_inner()).into(); output } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec4::max( + _self: Val<::glam::U64Vec4>, + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::max( _self.into_inner(), rhs.into_inner(), ) @@ -18371,17 +17093,17 @@ impl bevy::math::U64Vec4 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> u64 { - let output: u64 = bevy::math::U64Vec4::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::U64Vec4>) -> u64 { + let output: u64 = ::glam::U64Vec4::max_element(_self.into_inner()).into(); output } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec4::min( + _self: Val<::glam::U64Vec4>, + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::min( _self.into_inner(), rhs.into_inner(), ) @@ -18390,65 +17112,64 @@ impl bevy::math::U64Vec4 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> u64 { - let output: u64 = bevy::math::U64Vec4::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::U64Vec4>) -> u64 { + let output: u64 = ::glam::U64Vec4::min_element(_self.into_inner()).into(); output } fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Mul< + &::glam::U64Vec4, >>::mul(_self.into_inner(), &rhs) .into(); output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Mul< + ::glam::U64Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: u64) -> Val { - let output: Val = , rhs: u64) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Mul< u64, >>::mul(_self.into_inner(), rhs) .into(); output } /// Creates a new vector. - fn new(x: u64, y: u64, z: u64, w: u64) -> Val { - let output: Val = bevy::math::U64Vec4::new(x, y, z, w) - .into(); + fn new(x: u64, y: u64, z: u64, w: u64) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::new(x, y, z, w).into(); output } fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Rem< + &::glam::U64Vec4, >>::rem(_self.into_inner(), &rhs) .into(); output } fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Rem< + ::glam::U64Vec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: u64) -> Val { - let output: Val = , rhs: u64) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Rem< u64, >>::rem(_self.into_inner(), rhs) .into(); @@ -18457,10 +17178,10 @@ impl bevy::math::U64Vec4 { /// Returns a vector containing the saturating addition of `self` and `rhs`. /// In other words this computes `[self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..]`. fn saturating_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec4::saturating_add( + _self: Val<::glam::U64Vec4>, + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::saturating_add( _self.into_inner(), rhs.into_inner(), ) @@ -18470,10 +17191,10 @@ impl bevy::math::U64Vec4 { /// Returns a vector containing the saturating addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.saturating_add_signed(rhs.x), self.y.saturating_add_signed(rhs.y), ..]`. fn saturating_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec4::saturating_add_signed( + _self: Val<::glam::U64Vec4>, + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::saturating_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -18483,10 +17204,10 @@ impl bevy::math::U64Vec4 { /// Returns a vector containing the saturating division of `self` and `rhs`. /// In other words this computes `[self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..]`. fn saturating_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec4::saturating_div( + _self: Val<::glam::U64Vec4>, + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::saturating_div( _self.into_inner(), rhs.into_inner(), ) @@ -18496,10 +17217,10 @@ impl bevy::math::U64Vec4 { /// Returns a vector containing the saturating multiplication of `self` and `rhs`. /// In other words this computes `[self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..]`. fn saturating_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec4::saturating_mul( + _self: Val<::glam::U64Vec4>, + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::saturating_mul( _self.into_inner(), rhs.into_inner(), ) @@ -18509,10 +17230,10 @@ impl bevy::math::U64Vec4 { /// Returns a vector containing the saturating subtraction of `self` and `rhs`. /// In other words this computes `[self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..]`. fn saturating_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec4::saturating_sub( + _self: Val<::glam::U64Vec4>, + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::saturating_sub( _self.into_inner(), rhs.into_inner(), ) @@ -18524,11 +17245,11 @@ impl bevy::math::U64Vec4 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec4::select( + mask: Val<::glam::BVec4>, + if_true: Val<::glam::U64Vec4>, + if_false: Val<::glam::U64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -18537,94 +17258,80 @@ impl bevy::math::U64Vec4 { output } /// Creates a vector with all elements set to `v`. - fn splat(v: u64) -> Val { - let output: Val = bevy::math::U64Vec4::splat(v).into(); + fn splat(v: u64) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::splat(v).into(); output } fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , + rhs: Ref<::glam::U64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Sub< + &::glam::U64Vec4, >>::sub(_self.into_inner(), &rhs) .into(); output } fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Sub< + ::glam::U64Vec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: u64) -> Val { - let output: Val = , rhs: u64) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = <::glam::U64Vec4 as ::core::ops::Sub< u64, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y, z, w]` - fn to_array(_self: Ref) -> [u64; 4] { - let output: [u64; 4] = bevy::math::U64Vec4::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::U64Vec4>) -> [u64; 4] { + let output: [u64; 4] = ::glam::U64Vec4::to_array(&_self).into(); output } /// Creates a 3D vector from the `x`, `y` and `z` elements of `self`, discarding `w`. /// Truncation to [`U64Vec3`] may also be performed by using [`self.xyz()`][crate::swizzles::Vec4Swizzles::xyz()]. - fn truncate(_self: Val) -> Val { - let output: Val = bevy::math::U64Vec4::truncate( - _self.into_inner(), - ) + fn truncate(_self: Val<::glam::U64Vec4>) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::U64Vec4::truncate(_self.into_inner()) .into(); output } /// Creates a 4D vector from `self` with the given value of `w`. - fn with_w(_self: Val, w: u64) -> Val { - let output: Val = bevy::math::U64Vec4::with_w( - _self.into_inner(), - w, - ) + fn with_w(_self: Val<::glam::U64Vec4>, w: u64) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::with_w(_self.into_inner(), w) .into(); output } /// Creates a 4D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: u64) -> Val { - let output: Val = bevy::math::U64Vec4::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::U64Vec4>, x: u64) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::with_x(_self.into_inner(), x) .into(); output } /// Creates a 4D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: u64) -> Val { - let output: Val = bevy::math::U64Vec4::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::U64Vec4>, y: u64) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::with_y(_self.into_inner(), y) .into(); output } /// Creates a 4D vector from `self` with the given value of `z`. - fn with_z(_self: Val, z: u64) -> Val { - let output: Val = bevy::math::U64Vec4::with_z( - _self.into_inner(), - z, - ) + fn with_z(_self: Val<::glam::U64Vec4>, z: u64) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::with_z(_self.into_inner(), z) .into(); output } /// Returns a vector containing the wrapping addition of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..]`. fn wrapping_add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec4::wrapping_add( + _self: Val<::glam::U64Vec4>, + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::wrapping_add( _self.into_inner(), rhs.into_inner(), ) @@ -18634,10 +17341,10 @@ impl bevy::math::U64Vec4 { /// Returns a vector containing the wrapping addition of `self` and signed vector `rhs`. /// In other words this computes `[self.x.wrapping_add_signed(rhs.x), self.y.wrapping_add_signed(rhs.y), ..]`. fn wrapping_add_signed( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec4::wrapping_add_signed( + _self: Val<::glam::U64Vec4>, + rhs: Val<::glam::I64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::wrapping_add_signed( _self.into_inner(), rhs.into_inner(), ) @@ -18647,10 +17354,10 @@ impl bevy::math::U64Vec4 { /// Returns a vector containing the wrapping division of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..]`. fn wrapping_div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec4::wrapping_div( + _self: Val<::glam::U64Vec4>, + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::wrapping_div( _self.into_inner(), rhs.into_inner(), ) @@ -18660,10 +17367,10 @@ impl bevy::math::U64Vec4 { /// Returns a vector containing the wrapping multiplication of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..]`. fn wrapping_mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec4::wrapping_mul( + _self: Val<::glam::U64Vec4>, + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::wrapping_mul( _self.into_inner(), rhs.into_inner(), ) @@ -18673,10 +17380,10 @@ impl bevy::math::U64Vec4 { /// Returns a vector containing the wrapping subtraction of `self` and `rhs`. /// In other words this computes `[self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..]`. fn wrapping_sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::U64Vec4::wrapping_sub( + _self: Val<::glam::U64Vec4>, + rhs: Val<::glam::U64Vec4>, + ) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::U64Vec4::wrapping_sub( _self.into_inner(), rhs.into_inner(), ) @@ -18690,11 +17397,10 @@ impl bevy::math::U64Vec4 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::Vec2 { +impl ::glam::Vec2 { /// Returns a vector containing the absolute value of each element of `self`. - fn abs(_self: Val) -> Val { - let output: Val = bevy::math::Vec2::abs(_self.into_inner()) - .into(); + fn abs(_self: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::abs(_self.into_inner()).into(); output } /// Returns true if the absolute difference of all elements between `self` and `rhs` is @@ -18705,11 +17411,11 @@ impl bevy::math::Vec2 { /// For more see /// [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/). fn abs_diff_eq( - _self: Val, - rhs: Val, + _self: Val<::glam::Vec2>, + rhs: Val<::glam::Vec2>, max_abs_diff: f32, ) -> bool { - let output: bool = bevy::math::Vec2::abs_diff_eq( + let output: bool = ::glam::Vec2::abs_diff_eq( _self.into_inner(), rhs.into_inner(), max_abs_diff, @@ -18717,35 +17423,29 @@ impl bevy::math::Vec2 { .into(); output } - fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Add< + &::glam::Vec2, >>::add(_self.into_inner(), &rhs) .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Add< + ::glam::Vec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Add< f32, >>::add(_self.into_inner(), rhs) .into(); output } - fn angle_between(_self: Val, rhs: Val) -> f32 { - let output: f32 = bevy::math::Vec2::angle_between( + fn angle_between(_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>) -> f32 { + let output: f32 = ::glam::Vec2::angle_between( _self.into_inner(), rhs.into_inner(), ) @@ -18754,68 +17454,60 @@ impl bevy::math::Vec2 { } /// Returns the angle of rotation (in radians) from `self` to `rhs` in the range `[-π, +π]`. /// The inputs do not need to be unit vectors however they must be non-zero. - fn angle_to(_self: Val, rhs: Val) -> f32 { - let output: f32 = bevy::math::Vec2::angle_to( - _self.into_inner(), - rhs.into_inner(), - ) + fn angle_to(_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>) -> f32 { + let output: f32 = ::glam::Vec2::angle_to(_self.into_inner(), rhs.into_inner()) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec2(_self: Ref) -> Val { - let output: Val = bevy::math::Vec2::as_dvec2(&_self).into(); + fn as_dvec2(_self: Ref<::glam::Vec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::Vec2::as_dvec2(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec2(_self: Ref) -> Val { - let output: Val = bevy::math::Vec2::as_i16vec2(&_self) - .into(); + fn as_i16vec2(_self: Ref<::glam::Vec2>) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::Vec2::as_i16vec2(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec2(_self: Ref) -> Val { - let output: Val = bevy::math::Vec2::as_i64vec2(&_self) - .into(); + fn as_i64vec2(_self: Ref<::glam::Vec2>) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::Vec2::as_i64vec2(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec2(_self: Ref) -> Val { - let output: Val = bevy::math::Vec2::as_i8vec2(&_self).into(); + fn as_i8vec2(_self: Ref<::glam::Vec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::Vec2::as_i8vec2(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec2(_self: Ref) -> Val { - let output: Val = bevy::math::Vec2::as_ivec2(&_self).into(); + fn as_ivec2(_self: Ref<::glam::Vec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::Vec2::as_ivec2(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec2(_self: Ref) -> Val { - let output: Val = bevy::math::Vec2::as_u16vec2(&_self) - .into(); + fn as_u16vec2(_self: Ref<::glam::Vec2>) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::Vec2::as_u16vec2(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec2(_self: Ref) -> Val { - let output: Val = bevy::math::Vec2::as_u64vec2(&_self) - .into(); + fn as_u64vec2(_self: Ref<::glam::Vec2>) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::Vec2::as_u64vec2(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec2(_self: Ref) -> Val { - let output: Val = bevy::math::Vec2::as_u8vec2(&_self).into(); + fn as_u8vec2(_self: Ref<::glam::Vec2>) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::Vec2::as_u8vec2(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec2(_self: Ref) -> Val { - let output: Val = bevy::math::Vec2::as_uvec2(&_self).into(); + fn as_uvec2(_self: Ref<::glam::Vec2>) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::Vec2::as_uvec2(&_self).into(); output } /// Returns a vector containing the smallest integer greater than or equal to a number for /// each element of `self`. - fn ceil(_self: Val) -> Val { - let output: Val = bevy::math::Vec2::ceil(_self.into_inner()) - .into(); + fn ceil(_self: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::ceil(_self.into_inner()).into(); output } /// Component-wise clamping of values, similar to [`f32::clamp`]. @@ -18823,11 +17515,11 @@ impl bevy::math::Vec2 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::Vec2::clamp( + _self: Val<::glam::Vec2>, + min: Val<::glam::Vec2>, + max: Val<::glam::Vec2>, + ) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -18838,12 +17530,8 @@ impl bevy::math::Vec2 { /// Returns a vector with a length no less than `min` and no more than `max`. /// # Panics /// Will panic if `min` is greater than `max`, or if either `min` or `max` is negative, when `glam_assert` is enabled. - fn clamp_length( - _self: Val, - min: f32, - max: f32, - ) -> Val { - let output: Val = bevy::math::Vec2::clamp_length( + fn clamp_length(_self: Val<::glam::Vec2>, min: f32, max: f32) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::clamp_length( _self.into_inner(), min, max, @@ -18854,11 +17542,8 @@ impl bevy::math::Vec2 { /// Returns a vector with a length no more than `max`. /// # Panics /// Will panic if `max` is negative when `glam_assert` is enabled. - fn clamp_length_max( - _self: Val, - max: f32, - ) -> Val { - let output: Val = bevy::math::Vec2::clamp_length_max( + fn clamp_length_max(_self: Val<::glam::Vec2>, max: f32) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::clamp_length_max( _self.into_inner(), max, ) @@ -18868,19 +17553,16 @@ impl bevy::math::Vec2 { /// Returns a vector with a length no less than `min`. /// # Panics /// Will panic if `min` is negative when `glam_assert` is enabled. - fn clamp_length_min( - _self: Val, - min: f32, - ) -> Val { - let output: Val = bevy::math::Vec2::clamp_length_min( + fn clamp_length_min(_self: Val<::glam::Vec2>, min: f32) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::clamp_length_min( _self.into_inner(), min, ) .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -18890,11 +17572,8 @@ impl bevy::math::Vec2 { /// `self` and `rhs`. /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. - fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec2::cmpeq( + fn cmpeq(_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::Vec2::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -18905,11 +17584,8 @@ impl bevy::math::Vec2 { /// `self` and `rhs`. /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. - fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec2::cmpge( + fn cmpge(_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::Vec2::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -18920,11 +17596,8 @@ impl bevy::math::Vec2 { /// `self` and `rhs`. /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. - fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec2::cmpgt( + fn cmpgt(_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::Vec2::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -18935,11 +17608,8 @@ impl bevy::math::Vec2 { /// `self` and `rhs`. /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. - fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec2::cmple( + fn cmple(_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::Vec2::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -18950,11 +17620,8 @@ impl bevy::math::Vec2 { /// `self` and `rhs`. /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. - fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec2::cmplt( + fn cmplt(_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::Vec2::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -18965,11 +17632,8 @@ impl bevy::math::Vec2 { /// `self` and `rhs`. /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. - fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec2::cmpne( + fn cmpne(_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::Vec2::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -18977,11 +17641,8 @@ impl bevy::math::Vec2 { output } /// Returns a vector with signs of `rhs` and the magnitudes of `self`. - fn copysign( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec2::copysign( + fn copysign(_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::copysign( _self.into_inner(), rhs.into_inner(), ) @@ -18989,48 +17650,36 @@ impl bevy::math::Vec2 { output } /// Computes the Euclidean distance between two points in space. - fn distance(_self: Val, rhs: Val) -> f32 { - let output: f32 = bevy::math::Vec2::distance( - _self.into_inner(), - rhs.into_inner(), - ) + fn distance(_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>) -> f32 { + let output: f32 = ::glam::Vec2::distance(_self.into_inner(), rhs.into_inner()) .into(); output } /// Compute the squared euclidean distance between two points in space. - fn distance_squared( - _self: Val, - rhs: Val, - ) -> f32 { - let output: f32 = bevy::math::Vec2::distance_squared( + fn distance_squared(_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>) -> f32 { + let output: f32 = ::glam::Vec2::distance_squared( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Div< + &::glam::Vec2, >>::div(_self.into_inner(), &rhs) .into(); output } - fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Div< + ::glam::Vec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -19038,10 +17687,10 @@ impl bevy::math::Vec2 { } /// Returns the element-wise quotient of [Euclidean division] of `self` by `rhs`. fn div_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec2::div_euclid( + _self: Val<::glam::Vec2>, + rhs: Val<::glam::Vec2>, + ) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -19049,17 +17698,16 @@ impl bevy::math::Vec2 { output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> f32 { - let output: f32 = bevy::math::Vec2::dot(_self.into_inner(), rhs.into_inner()) - .into(); + fn dot(_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>) -> f32 { + let output: f32 = ::glam::Vec2::dot(_self.into_inner(), rhs.into_inner()).into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec2::dot_into_vec( + _self: Val<::glam::Vec2>, + rhs: Val<::glam::Vec2>, + ) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -19068,63 +17716,55 @@ impl bevy::math::Vec2 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec2::element_product(_self.into_inner()).into(); + fn element_product(_self: Val<::glam::Vec2>) -> f32 { + let output: f32 = ::glam::Vec2::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec2::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::Vec2>) -> f32 { + let output: f32 = ::glam::Vec2::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::Vec2>) -> bool { + let output: bool = <::glam::Vec2 as ::core::cmp::PartialEq< + ::glam::Vec2, >>::eq(&_self, &other) .into(); output } /// Returns a vector containing `e^self` (the exponential function) for each element of /// `self`. - fn exp(_self: Val) -> Val { - let output: Val = bevy::math::Vec2::exp(_self.into_inner()) - .into(); + fn exp(_self: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::exp(_self.into_inner()).into(); output } /// Creates a 3D vector from `self` and the given `z` value. - fn extend(_self: Val, z: f32) -> Val { - let output: Val = bevy::math::Vec2::extend( - _self.into_inner(), - z, - ) + fn extend(_self: Val<::glam::Vec2>, z: f32) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec2::extend(_self.into_inner(), z) .into(); output } /// Returns a vector containing the largest integer less than or equal to a number for each /// element of `self`. - fn floor(_self: Val) -> Val { - let output: Val = bevy::math::Vec2::floor(_self.into_inner()) - .into(); + fn floor(_self: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::floor(_self.into_inner()).into(); output } /// Returns a vector containing the fractional part of the vector as `self - self.trunc()`. /// Note that this differs from the GLSL implementation of `fract` which returns /// `self - self.floor()`. /// Note that this is fast but not precise for large numbers. - fn fract(_self: Val) -> Val { - let output: Val = bevy::math::Vec2::fract(_self.into_inner()) - .into(); + fn fract(_self: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::fract(_self.into_inner()).into(); output } /// Returns a vector containing the fractional part of the vector as `self - self.floor()`. /// Note that this differs from the Rust implementation of `fract` which returns /// `self - self.trunc()`. /// Note that this is fast but not precise for large numbers. - fn fract_gl(_self: Val) -> Val { - let output: Val = bevy::math::Vec2::fract_gl( - _self.into_inner(), - ) + fn fract_gl(_self: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::fract_gl(_self.into_inner()) .into(); output } @@ -19132,73 +17772,68 @@ impl bevy::math::Vec2 { /// conjunction with the [`rotate()`][Self::rotate()] method, e.g. /// `Vec2::from_angle(PI).rotate(Vec2::Y)` will create the vector `[-1, 0]` /// and rotate [`Vec2::Y`] around it returning `-Vec2::Y`. - fn from_angle(angle: f32) -> Val { - let output: Val = bevy::math::Vec2::from_angle(angle).into(); + fn from_angle(angle: f32) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::from_angle(angle).into(); output } /// Creates a new vector from an array. - fn from_array(a: [f32; 2]) -> Val { - let output: Val = bevy::math::Vec2::from_array(a).into(); + fn from_array(a: [f32; 2]) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::from_array(a).into(); output } /// Returns `true` if, and only if, all elements are finite. If any element is either /// `NaN`, positive or negative infinity, this will return `false`. - fn is_finite(_self: Val) -> bool { - let output: bool = bevy::math::Vec2::is_finite(_self.into_inner()).into(); + fn is_finite(_self: Val<::glam::Vec2>) -> bool { + let output: bool = ::glam::Vec2::is_finite(_self.into_inner()).into(); output } /// Performs `is_finite` on each element of self, returning a vector mask of the results. /// In other words, this computes `[x.is_finite(), y.is_finite(), ...]`. - fn is_finite_mask(_self: Val) -> Val { - let output: Val = bevy::math::Vec2::is_finite_mask( - _self.into_inner(), - ) + fn is_finite_mask(_self: Val<::glam::Vec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::Vec2::is_finite_mask(_self.into_inner()) .into(); output } /// Returns `true` if any elements are `NaN`. - fn is_nan(_self: Val) -> bool { - let output: bool = bevy::math::Vec2::is_nan(_self.into_inner()).into(); + fn is_nan(_self: Val<::glam::Vec2>) -> bool { + let output: bool = ::glam::Vec2::is_nan(_self.into_inner()).into(); output } /// Performs `is_nan` on each element of self, returning a vector mask of the results. /// In other words, this computes `[x.is_nan(), y.is_nan(), ...]`. - fn is_nan_mask(_self: Val) -> Val { - let output: Val = bevy::math::Vec2::is_nan_mask( - _self.into_inner(), - ) + fn is_nan_mask(_self: Val<::glam::Vec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::Vec2::is_nan_mask(_self.into_inner()) .into(); output } /// Returns a bitmask with the lowest 2 bits set to the sign bits from the elements of `self`. /// A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn is_negative_bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::Vec2::is_negative_bitmask(_self.into_inner()) - .into(); + fn is_negative_bitmask(_self: Val<::glam::Vec2>) -> u32 { + let output: u32 = ::glam::Vec2::is_negative_bitmask(_self.into_inner()).into(); output } /// Returns whether `self` is length `1.0` or not. /// Uses a precision threshold of approximately `1e-4`. - fn is_normalized(_self: Val) -> bool { - let output: bool = bevy::math::Vec2::is_normalized(_self.into_inner()).into(); + fn is_normalized(_self: Val<::glam::Vec2>) -> bool { + let output: bool = ::glam::Vec2::is_normalized(_self.into_inner()).into(); output } /// Computes the length of `self`. - fn length(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec2::length(_self.into_inner()).into(); + fn length(_self: Val<::glam::Vec2>) -> f32 { + let output: f32 = ::glam::Vec2::length(_self.into_inner()).into(); output } /// Computes `1.0 / length()`. /// For valid results, `self` must _not_ be of length zero. - fn length_recip(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec2::length_recip(_self.into_inner()).into(); + fn length_recip(_self: Val<::glam::Vec2>) -> f32 { + let output: f32 = ::glam::Vec2::length_recip(_self.into_inner()).into(); output } /// Computes the squared length of `self`. /// This is faster than `length()` as it avoids a square root operation. - fn length_squared(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec2::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::Vec2>) -> f32 { + let output: f32 = ::glam::Vec2::length_squared(_self.into_inner()).into(); output } /// Performs a linear interpolation between `self` and `rhs` based on the value `s`. @@ -19206,11 +17841,11 @@ impl bevy::math::Vec2 { /// will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly /// extrapolated. fn lerp( - _self: Val, - rhs: Val, + _self: Val<::glam::Vec2>, + rhs: Val<::glam::Vec2>, s: f32, - ) -> Val { - let output: Val = bevy::math::Vec2::lerp( + ) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::lerp( _self.into_inner(), rhs.into_inner(), s, @@ -19220,11 +17855,8 @@ impl bevy::math::Vec2 { } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. - fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec2::max( + fn max(_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::max( _self.into_inner(), rhs.into_inner(), ) @@ -19233,19 +17865,16 @@ impl bevy::math::Vec2 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec2::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::Vec2>) -> f32 { + let output: f32 = ::glam::Vec2::max_element(_self.into_inner()).into(); output } /// Calculates the midpoint between `self` and `rhs`. /// The midpoint is the average of, or halfway point between, two vectors. /// `a.midpoint(b)` should yield the same result as `a.lerp(b, 0.5)` /// while being slightly cheaper to compute. - fn midpoint( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec2::midpoint( + fn midpoint(_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::midpoint( _self.into_inner(), rhs.into_inner(), ) @@ -19254,11 +17883,8 @@ impl bevy::math::Vec2 { } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. - fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec2::min( + fn min(_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::min( _self.into_inner(), rhs.into_inner(), ) @@ -19267,19 +17893,19 @@ impl bevy::math::Vec2 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec2::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::Vec2>) -> f32 { + let output: f32 = ::glam::Vec2::min_element(_self.into_inner()).into(); output } /// Moves towards `rhs` based on the value `d`. /// When `d` is `0.0`, the result will be equal to `self`. When `d` is equal to /// `self.distance(rhs)`, the result will be equal to `rhs`. Will not go past `rhs`. fn move_towards( - _self: Ref, - rhs: Val, + _self: Ref<::glam::Vec2>, + rhs: Val<::glam::Vec2>, d: f32, - ) -> Val { - let output: Val = bevy::math::Vec2::move_towards( + ) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::move_towards( &_self, rhs.into_inner(), d, @@ -19287,28 +17913,22 @@ impl bevy::math::Vec2 { .into(); output } - fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Mul< + &::glam::Vec2, >>::mul(_self.into_inner(), &rhs) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Mul< + ::glam::Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -19321,11 +17941,11 @@ impl bevy::math::Vec2 { /// and will be heavily dependant on designing algorithms with specific target hardware in /// mind. fn mul_add( - _self: Val, - a: Val, - b: Val, - ) -> Val { - let output: Val = bevy::math::Vec2::mul_add( + _self: Val<::glam::Vec2>, + a: Val<::glam::Vec2>, + b: Val<::glam::Vec2>, + ) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::mul_add( _self.into_inner(), a.into_inner(), b.into_inner(), @@ -19333,16 +17953,16 @@ impl bevy::math::Vec2 { .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); output } /// Creates a new vector. - fn new(x: f32, y: f32) -> Val { - let output: Val = bevy::math::Vec2::new(x, y).into(); + fn new(x: f32, y: f32) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::new(x, y).into(); output } /// Returns `self` normalized to length 1.0. @@ -19350,10 +17970,8 @@ impl bevy::math::Vec2 { /// See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`]. /// Panics /// Will panic if the resulting normalized vector is not finite when `glam_assert` is enabled. - fn normalize(_self: Val) -> Val { - let output: Val = bevy::math::Vec2::normalize( - _self.into_inner(), - ) + fn normalize(_self: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::normalize(_self.into_inner()) .into(); output } @@ -19363,10 +17981,10 @@ impl bevy::math::Vec2 { /// the result of this operation will be the fallback value. /// See also [`Self::try_normalize()`]. fn normalize_or( - _self: Val, - fallback: Val, - ) -> Val { - let output: Val = bevy::math::Vec2::normalize_or( + _self: Val<::glam::Vec2>, + fallback: Val<::glam::Vec2>, + ) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::normalize_or( _self.into_inner(), fallback.into_inner(), ) @@ -19377,33 +17995,28 @@ impl bevy::math::Vec2 { /// In particular, if the input is zero (or very close to zero), or non-finite, /// the result of this operation will be zero. /// See also [`Self::try_normalize()`]. - fn normalize_or_zero(_self: Val) -> Val { - let output: Val = bevy::math::Vec2::normalize_or_zero( + fn normalize_or_zero(_self: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::normalize_or_zero( _self.into_inner(), ) .into(); output } /// Returns a vector that is equal to `self` rotated by 90 degrees. - fn perp(_self: Val) -> Val { - let output: Val = bevy::math::Vec2::perp(_self.into_inner()) - .into(); + fn perp(_self: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::perp(_self.into_inner()).into(); output } /// The perpendicular dot product of `self` and `rhs`. /// Also known as the wedge product, 2D cross product, and determinant. - fn perp_dot(_self: Val, rhs: Val) -> f32 { - let output: f32 = bevy::math::Vec2::perp_dot( - _self.into_inner(), - rhs.into_inner(), - ) + fn perp_dot(_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>) -> f32 { + let output: f32 = ::glam::Vec2::perp_dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector containing each element of `self` raised to the power of `n`. - fn powf(_self: Val, n: f32) -> Val { - let output: Val = bevy::math::Vec2::powf(_self.into_inner(), n) - .into(); + fn powf(_self: Val<::glam::Vec2>, n: f32) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::powf(_self.into_inner(), n).into(); output } /// Returns the vector projection of `self` onto `rhs`. @@ -19411,10 +18024,10 @@ impl bevy::math::Vec2 { /// # Panics /// Will panic if `rhs` is zero length when `glam_assert` is enabled. fn project_onto( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec2::project_onto( + _self: Val<::glam::Vec2>, + rhs: Val<::glam::Vec2>, + ) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::project_onto( _self.into_inner(), rhs.into_inner(), ) @@ -19426,10 +18039,10 @@ impl bevy::math::Vec2 { /// # Panics /// Will panic if `rhs` is not normalized when `glam_assert` is enabled. fn project_onto_normalized( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec2::project_onto_normalized( + _self: Val<::glam::Vec2>, + rhs: Val<::glam::Vec2>, + ) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::project_onto_normalized( _self.into_inner(), rhs.into_inner(), ) @@ -19437,9 +18050,8 @@ impl bevy::math::Vec2 { output } /// Returns a vector containing the reciprocal `1.0/n` of each element of `self`. - fn recip(_self: Val) -> Val { - let output: Val = bevy::math::Vec2::recip(_self.into_inner()) - .into(); + fn recip(_self: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::recip(_self.into_inner()).into(); output } /// Returns the reflection vector for a given incident vector `self` and surface normal @@ -19448,10 +18060,10 @@ impl bevy::math::Vec2 { /// # Panics /// Will panic if `normal` is not normalized when `glam_assert` is enabled. fn reflect( - _self: Val, - normal: Val, - ) -> Val { - let output: Val = bevy::math::Vec2::reflect( + _self: Val<::glam::Vec2>, + normal: Val<::glam::Vec2>, + ) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::reflect( _self.into_inner(), normal.into_inner(), ) @@ -19465,11 +18077,11 @@ impl bevy::math::Vec2 { /// # Panics /// Will panic if `self` or `normal` is not normalized when `glam_assert` is enabled. fn refract( - _self: Val, - normal: Val, + _self: Val<::glam::Vec2>, + normal: Val<::glam::Vec2>, eta: f32, - ) -> Val { - let output: Val = bevy::math::Vec2::refract( + ) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::refract( _self.into_inner(), normal.into_inner(), eta, @@ -19484,10 +18096,10 @@ impl bevy::math::Vec2 { /// # Panics /// Will panic if `rhs` has a length of zero when `glam_assert` is enabled. fn reject_from( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec2::reject_from( + _self: Val<::glam::Vec2>, + rhs: Val<::glam::Vec2>, + ) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::reject_from( _self.into_inner(), rhs.into_inner(), ) @@ -19501,38 +18113,32 @@ impl bevy::math::Vec2 { /// # Panics /// Will panic if `rhs` is not normalized when `glam_assert` is enabled. fn reject_from_normalized( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec2::reject_from_normalized( + _self: Val<::glam::Vec2>, + rhs: Val<::glam::Vec2>, + ) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::reject_from_normalized( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Rem< + &::glam::Vec2, >>::rem(_self.into_inner(), &rhs) .into(); output } - fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Rem< + ::glam::Vec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Rem< f32, >>::rem(_self.into_inner(), rhs) .into(); @@ -19541,10 +18147,10 @@ impl bevy::math::Vec2 { /// Returns the element-wise remainder of [Euclidean division] of `self` by `rhs`. /// [Euclidean division]: f32::rem_euclid fn rem_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec2::rem_euclid( + _self: Val<::glam::Vec2>, + rhs: Val<::glam::Vec2>, + ) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::rem_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -19554,11 +18160,8 @@ impl bevy::math::Vec2 { /// Returns `rhs` rotated by the angle of `self`. If `self` is normalized, /// then this just rotation. This is what you usually want. Otherwise, /// it will be like a rotation with a multiplication by `self`'s length. - fn rotate( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec2::rotate( + fn rotate(_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::rotate( _self.into_inner(), rhs.into_inner(), ) @@ -19570,11 +18173,11 @@ impl bevy::math::Vec2 { /// `self.angle_between(rhs)`, the result will be equal to `rhs`. If `max_angle` is negative, /// rotates towards the exact opposite of `rhs`. Will not go past the target. fn rotate_towards( - _self: Ref, - rhs: Val, + _self: Ref<::glam::Vec2>, + rhs: Val<::glam::Vec2>, max_angle: f32, - ) -> Val { - let output: Val = bevy::math::Vec2::rotate_towards( + ) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::rotate_towards( &_self, rhs.into_inner(), max_angle, @@ -19584,9 +18187,8 @@ impl bevy::math::Vec2 { } /// Returns a vector containing the nearest integer to a number for each element of `self`. /// Round half-way cases away from 0.0. - fn round(_self: Val) -> Val { - let output: Val = bevy::math::Vec2::round(_self.into_inner()) - .into(); + fn round(_self: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::round(_self.into_inner()).into(); output } /// Creates a vector from the elements in `if_true` and `if_false`, selecting which to use @@ -19594,11 +18196,11 @@ impl bevy::math::Vec2 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::Vec2::select( + mask: Val<::glam::BVec2>, + if_true: Val<::glam::Vec2>, + if_false: Val<::glam::Vec2>, + ) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -19610,38 +18212,31 @@ impl bevy::math::Vec2 { /// - `1.0` if the number is positive, `+0.0` or `INFINITY` /// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY` /// - `NAN` if the number is `NAN` - fn signum(_self: Val) -> Val { - let output: Val = bevy::math::Vec2::signum(_self.into_inner()) - .into(); + fn signum(_self: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::signum(_self.into_inner()).into(); output } /// Creates a vector with all elements set to `v`. - fn splat(v: f32) -> Val { - let output: Val = bevy::math::Vec2::splat(v).into(); + fn splat(v: f32) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::splat(v).into(); output } - fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Sub< + &::glam::Vec2, >>::sub(_self.into_inner(), &rhs) .into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Sub< + ::glam::Vec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = <::glam::Vec2 as ::core::ops::Sub< f32, >>::sub(_self.into_inner(), rhs) .into(); @@ -19649,37 +18244,30 @@ impl bevy::math::Vec2 { } /// Returns the angle (in radians) of this vector in the range `[-π, +π]`. /// The input does not need to be a unit vector however it must be non-zero. - fn to_angle(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec2::to_angle(_self.into_inner()).into(); + fn to_angle(_self: Val<::glam::Vec2>) -> f32 { + let output: f32 = ::glam::Vec2::to_angle(_self.into_inner()).into(); output } /// `[x, y]` - fn to_array(_self: Ref) -> [f32; 2] { - let output: [f32; 2] = bevy::math::Vec2::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::Vec2>) -> [f32; 2] { + let output: [f32; 2] = ::glam::Vec2::to_array(&_self).into(); output } /// Returns a vector containing the integer part each element of `self`. This means numbers are /// always truncated towards zero. - fn trunc(_self: Val) -> Val { - let output: Val = bevy::math::Vec2::trunc(_self.into_inner()) - .into(); + fn trunc(_self: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::trunc(_self.into_inner()).into(); output } /// Creates a 2D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: f32) -> Val { - let output: Val = bevy::math::Vec2::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::Vec2>, x: f32) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::with_x(_self.into_inner(), x) .into(); output } /// Creates a 2D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: f32) -> Val { - let output: Val = bevy::math::Vec2::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::Vec2>, y: f32) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec2::with_y(_self.into_inner(), y) .into(); output } @@ -19690,11 +18278,10 @@ impl bevy::math::Vec2 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::Vec3A { +impl ::glam::Vec3A { /// Returns a vector containing the absolute value of each element of `self`. - fn abs(_self: Val) -> Val { - let output: Val = bevy::math::Vec3A::abs(_self.into_inner()) - .into(); + fn abs(_self: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::abs(_self.into_inner()).into(); output } /// Returns true if the absolute difference of all elements between `self` and `rhs` is @@ -19705,11 +18292,11 @@ impl bevy::math::Vec3A { /// For more see /// [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/). fn abs_diff_eq( - _self: Val, - rhs: Val, + _self: Val<::glam::Vec3A>, + rhs: Val<::glam::Vec3A>, max_abs_diff: f32, ) -> bool { - let output: bool = bevy::math::Vec3A::abs_diff_eq( + let output: bool = ::glam::Vec3A::abs_diff_eq( _self.into_inner(), rhs.into_inner(), max_abs_diff, @@ -19717,28 +18304,22 @@ impl bevy::math::Vec3A { .into(); output } - fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Add< + &::glam::Vec3A, >>::add(_self.into_inner(), &rhs) .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Add< + ::glam::Vec3A, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Add< f32, >>::add(_self.into_inner(), rhs) .into(); @@ -19746,8 +18327,8 @@ impl bevy::math::Vec3A { } /// Returns the angle (in radians) between two vectors in the range `[0, +π]`. /// The inputs do not need to be unit vectors however they must be non-zero. - fn angle_between(_self: Val, rhs: Val) -> f32 { - let output: f32 = bevy::math::Vec3A::angle_between( + fn angle_between(_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>) -> f32 { + let output: f32 = ::glam::Vec3A::angle_between( _self.into_inner(), rhs.into_inner(), ) @@ -19758,10 +18339,8 @@ impl bevy::math::Vec3A { /// The input vector must be finite and non-zero. /// The output vector is not necessarily unit length. For that use /// [`Self::any_orthonormal_vector()`] instead. - fn any_orthogonal_vector(_self: Ref) -> Val { - let output: Val = bevy::math::Vec3A::any_orthogonal_vector( - &_self, - ) + fn any_orthogonal_vector(_self: Ref<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::any_orthogonal_vector(&_self) .into(); output } @@ -19769,69 +18348,60 @@ impl bevy::math::Vec3A { /// The input vector must be unit length. /// # Panics /// Will panic if `self` is not normalized when `glam_assert` is enabled. - fn any_orthonormal_vector(_self: Ref) -> Val { - let output: Val = bevy::math::Vec3A::any_orthonormal_vector( - &_self, - ) + fn any_orthonormal_vector(_self: Ref<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::any_orthonormal_vector(&_self) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec3(_self: Ref) -> Val { - let output: Val = bevy::math::Vec3A::as_dvec3(&_self).into(); + fn as_dvec3(_self: Ref<::glam::Vec3A>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::Vec3A::as_dvec3(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec3(_self: Ref) -> Val { - let output: Val = bevy::math::Vec3A::as_i16vec3(&_self) - .into(); + fn as_i16vec3(_self: Ref<::glam::Vec3A>) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::Vec3A::as_i16vec3(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec3(_self: Ref) -> Val { - let output: Val = bevy::math::Vec3A::as_i64vec3(&_self) - .into(); + fn as_i64vec3(_self: Ref<::glam::Vec3A>) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::Vec3A::as_i64vec3(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec3(_self: Ref) -> Val { - let output: Val = bevy::math::Vec3A::as_i8vec3(&_self) - .into(); + fn as_i8vec3(_self: Ref<::glam::Vec3A>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::Vec3A::as_i8vec3(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec3(_self: Ref) -> Val { - let output: Val = bevy::math::Vec3A::as_ivec3(&_self).into(); + fn as_ivec3(_self: Ref<::glam::Vec3A>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::Vec3A::as_ivec3(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec3(_self: Ref) -> Val { - let output: Val = bevy::math::Vec3A::as_u16vec3(&_self) - .into(); + fn as_u16vec3(_self: Ref<::glam::Vec3A>) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::Vec3A::as_u16vec3(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec3(_self: Ref) -> Val { - let output: Val = bevy::math::Vec3A::as_u64vec3(&_self) - .into(); + fn as_u64vec3(_self: Ref<::glam::Vec3A>) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::Vec3A::as_u64vec3(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec3(_self: Ref) -> Val { - let output: Val = bevy::math::Vec3A::as_u8vec3(&_self) - .into(); + fn as_u8vec3(_self: Ref<::glam::Vec3A>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::Vec3A::as_u8vec3(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec3(_self: Ref) -> Val { - let output: Val = bevy::math::Vec3A::as_uvec3(&_self).into(); + fn as_uvec3(_self: Ref<::glam::Vec3A>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::Vec3A::as_uvec3(&_self).into(); output } /// Returns a vector containing the smallest integer greater than or equal to a number for /// each element of `self`. - fn ceil(_self: Val) -> Val { - let output: Val = bevy::math::Vec3A::ceil(_self.into_inner()) - .into(); + fn ceil(_self: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::ceil(_self.into_inner()).into(); output } /// Component-wise clamping of values, similar to [`f32::clamp`]. @@ -19839,11 +18409,11 @@ impl bevy::math::Vec3A { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::Vec3A::clamp( + _self: Val<::glam::Vec3A>, + min: Val<::glam::Vec3A>, + max: Val<::glam::Vec3A>, + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -19855,11 +18425,11 @@ impl bevy::math::Vec3A { /// # Panics /// Will panic if `min` is greater than `max`, or if either `min` or `max` is negative, when `glam_assert` is enabled. fn clamp_length( - _self: Val, + _self: Val<::glam::Vec3A>, min: f32, max: f32, - ) -> Val { - let output: Val = bevy::math::Vec3A::clamp_length( + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::clamp_length( _self.into_inner(), min, max, @@ -19870,11 +18440,8 @@ impl bevy::math::Vec3A { /// Returns a vector with a length no more than `max`. /// # Panics /// Will panic if `max` is negative when `glam_assert` is enabled. - fn clamp_length_max( - _self: Val, - max: f32, - ) -> Val { - let output: Val = bevy::math::Vec3A::clamp_length_max( + fn clamp_length_max(_self: Val<::glam::Vec3A>, max: f32) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::clamp_length_max( _self.into_inner(), max, ) @@ -19884,19 +18451,16 @@ impl bevy::math::Vec3A { /// Returns a vector with a length no less than `min`. /// # Panics /// Will panic if `min` is negative when `glam_assert` is enabled. - fn clamp_length_min( - _self: Val, - min: f32, - ) -> Val { - let output: Val = bevy::math::Vec3A::clamp_length_min( + fn clamp_length_min(_self: Val<::glam::Vec3A>, min: f32) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::clamp_length_min( _self.into_inner(), min, ) .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -19906,11 +18470,8 @@ impl bevy::math::Vec3A { /// `self` and `rhs`. /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. - fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3A::cmpeq( + fn cmpeq(_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>) -> Val<::glam::BVec3A> { + let output: Val<::glam::BVec3A> = ::glam::Vec3A::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -19921,11 +18482,8 @@ impl bevy::math::Vec3A { /// `self` and `rhs`. /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. - fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3A::cmpge( + fn cmpge(_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>) -> Val<::glam::BVec3A> { + let output: Val<::glam::BVec3A> = ::glam::Vec3A::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -19936,11 +18494,8 @@ impl bevy::math::Vec3A { /// `self` and `rhs`. /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. - fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3A::cmpgt( + fn cmpgt(_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>) -> Val<::glam::BVec3A> { + let output: Val<::glam::BVec3A> = ::glam::Vec3A::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -19951,11 +18506,8 @@ impl bevy::math::Vec3A { /// `self` and `rhs`. /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. - fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3A::cmple( + fn cmple(_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>) -> Val<::glam::BVec3A> { + let output: Val<::glam::BVec3A> = ::glam::Vec3A::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -19966,11 +18518,8 @@ impl bevy::math::Vec3A { /// `self` and `rhs`. /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. - fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3A::cmplt( + fn cmplt(_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>) -> Val<::glam::BVec3A> { + let output: Val<::glam::BVec3A> = ::glam::Vec3A::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -19981,11 +18530,8 @@ impl bevy::math::Vec3A { /// `self` and `rhs`. /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. - fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3A::cmpne( + fn cmpne(_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>) -> Val<::glam::BVec3A> { + let output: Val<::glam::BVec3A> = ::glam::Vec3A::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -19994,10 +18540,10 @@ impl bevy::math::Vec3A { } /// Returns a vector with signs of `rhs` and the magnitudes of `self`. fn copysign( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3A::copysign( + _self: Val<::glam::Vec3A>, + rhs: Val<::glam::Vec3A>, + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::copysign( _self.into_inner(), rhs.into_inner(), ) @@ -20005,11 +18551,8 @@ impl bevy::math::Vec3A { output } /// Computes the cross product of `self` and `rhs`. - fn cross( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3A::cross( + fn cross(_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::cross( _self.into_inner(), rhs.into_inner(), ) @@ -20017,48 +18560,36 @@ impl bevy::math::Vec3A { output } /// Computes the Euclidean distance between two points in space. - fn distance(_self: Val, rhs: Val) -> f32 { - let output: f32 = bevy::math::Vec3A::distance( - _self.into_inner(), - rhs.into_inner(), - ) + fn distance(_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>) -> f32 { + let output: f32 = ::glam::Vec3A::distance(_self.into_inner(), rhs.into_inner()) .into(); output } /// Compute the squared euclidean distance between two points in space. - fn distance_squared( - _self: Val, - rhs: Val, - ) -> f32 { - let output: f32 = bevy::math::Vec3A::distance_squared( + fn distance_squared(_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>) -> f32 { + let output: f32 = ::glam::Vec3A::distance_squared( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Div< + &::glam::Vec3A, >>::div(_self.into_inner(), &rhs) .into(); output } - fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Div< + ::glam::Vec3A, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -20066,10 +18597,10 @@ impl bevy::math::Vec3A { } /// Returns the element-wise quotient of [Euclidean division] of `self` by `rhs`. fn div_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3A::div_euclid( + _self: Val<::glam::Vec3A>, + rhs: Val<::glam::Vec3A>, + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -20077,17 +18608,17 @@ impl bevy::math::Vec3A { output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> f32 { - let output: f32 = bevy::math::Vec3A::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>) -> f32 { + let output: f32 = ::glam::Vec3A::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3A::dot_into_vec( + _self: Val<::glam::Vec3A>, + rhs: Val<::glam::Vec3A>, + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -20096,136 +18627,124 @@ impl bevy::math::Vec3A { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec3A::element_product(_self.into_inner()).into(); + fn element_product(_self: Val<::glam::Vec3A>) -> f32 { + let output: f32 = ::glam::Vec3A::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec3A::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::Vec3A>) -> f32 { + let output: f32 = ::glam::Vec3A::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, rhs: Ref) -> bool { - let output: bool = , rhs: Ref<::glam::Vec3A>) -> bool { + let output: bool = <::glam::Vec3A as ::core::cmp::PartialEq< + ::glam::Vec3A, >>::eq(&_self, &rhs) .into(); output } /// Returns a vector containing `e^self` (the exponential function) for each element of /// `self`. - fn exp(_self: Val) -> Val { - let output: Val = bevy::math::Vec3A::exp(_self.into_inner()) - .into(); + fn exp(_self: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::exp(_self.into_inner()).into(); output } /// Creates a 4D vector from `self` and the given `w` value. - fn extend(_self: Val, w: f32) -> Val { - let output: Val = bevy::math::Vec3A::extend( - _self.into_inner(), - w, - ) + fn extend(_self: Val<::glam::Vec3A>, w: f32) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec3A::extend(_self.into_inner(), w) .into(); output } /// Returns a vector containing the largest integer less than or equal to a number for each /// element of `self`. - fn floor(_self: Val) -> Val { - let output: Val = bevy::math::Vec3A::floor(_self.into_inner()) - .into(); + fn floor(_self: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::floor(_self.into_inner()).into(); output } /// Returns a vector containing the fractional part of the vector as `self - self.trunc()`. /// Note that this differs from the GLSL implementation of `fract` which returns /// `self - self.floor()`. /// Note that this is fast but not precise for large numbers. - fn fract(_self: Val) -> Val { - let output: Val = bevy::math::Vec3A::fract(_self.into_inner()) - .into(); + fn fract(_self: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::fract(_self.into_inner()).into(); output } /// Returns a vector containing the fractional part of the vector as `self - self.floor()`. /// Note that this differs from the Rust implementation of `fract` which returns /// `self - self.trunc()`. /// Note that this is fast but not precise for large numbers. - fn fract_gl(_self: Val) -> Val { - let output: Val = bevy::math::Vec3A::fract_gl( - _self.into_inner(), - ) + fn fract_gl(_self: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::fract_gl(_self.into_inner()) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [f32; 3]) -> Val { - let output: Val = bevy::math::Vec3A::from_array(a).into(); + fn from_array(a: [f32; 3]) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::from_array(a).into(); output } /// Creates a [`Vec3A`] from the `x`, `y` and `z` elements of `self` discarding `w`. /// On architectures where SIMD is supported such as SSE2 on `x86_64` this conversion is a noop. - fn from_vec4(v: Val) -> Val { - let output: Val = bevy::math::Vec3A::from_vec4(v.into_inner()) - .into(); + fn from_vec4(v: Val<::glam::Vec4>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::from_vec4(v.into_inner()).into(); output } /// Returns `true` if, and only if, all elements are finite. If any element is either /// `NaN`, positive or negative infinity, this will return `false`. - fn is_finite(_self: Val) -> bool { - let output: bool = bevy::math::Vec3A::is_finite(_self.into_inner()).into(); + fn is_finite(_self: Val<::glam::Vec3A>) -> bool { + let output: bool = ::glam::Vec3A::is_finite(_self.into_inner()).into(); output } /// Performs `is_finite` on each element of self, returning a vector mask of the results. /// In other words, this computes `[x.is_finite(), y.is_finite(), ...]`. - fn is_finite_mask(_self: Val) -> Val { - let output: Val = bevy::math::Vec3A::is_finite_mask( + fn is_finite_mask(_self: Val<::glam::Vec3A>) -> Val<::glam::BVec3A> { + let output: Val<::glam::BVec3A> = ::glam::Vec3A::is_finite_mask( _self.into_inner(), ) .into(); output } /// Returns `true` if any elements are `NaN`. - fn is_nan(_self: Val) -> bool { - let output: bool = bevy::math::Vec3A::is_nan(_self.into_inner()).into(); + fn is_nan(_self: Val<::glam::Vec3A>) -> bool { + let output: bool = ::glam::Vec3A::is_nan(_self.into_inner()).into(); output } /// Performs `is_nan` on each element of self, returning a vector mask of the results. /// In other words, this computes `[x.is_nan(), y.is_nan(), ...]`. - fn is_nan_mask(_self: Val) -> Val { - let output: Val = bevy::math::Vec3A::is_nan_mask( - _self.into_inner(), - ) + fn is_nan_mask(_self: Val<::glam::Vec3A>) -> Val<::glam::BVec3A> { + let output: Val<::glam::BVec3A> = ::glam::Vec3A::is_nan_mask(_self.into_inner()) .into(); output } /// Returns a bitmask with the lowest 3 bits set to the sign bits from the elements of `self`. /// A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn is_negative_bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::Vec3A::is_negative_bitmask(_self.into_inner()) - .into(); + fn is_negative_bitmask(_self: Val<::glam::Vec3A>) -> u32 { + let output: u32 = ::glam::Vec3A::is_negative_bitmask(_self.into_inner()).into(); output } /// Returns whether `self` is length `1.0` or not. /// Uses a precision threshold of approximately `1e-4`. - fn is_normalized(_self: Val) -> bool { - let output: bool = bevy::math::Vec3A::is_normalized(_self.into_inner()).into(); + fn is_normalized(_self: Val<::glam::Vec3A>) -> bool { + let output: bool = ::glam::Vec3A::is_normalized(_self.into_inner()).into(); output } /// Computes the length of `self`. - fn length(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec3A::length(_self.into_inner()).into(); + fn length(_self: Val<::glam::Vec3A>) -> f32 { + let output: f32 = ::glam::Vec3A::length(_self.into_inner()).into(); output } /// Computes `1.0 / length()`. /// For valid results, `self` must _not_ be of length zero. - fn length_recip(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec3A::length_recip(_self.into_inner()).into(); + fn length_recip(_self: Val<::glam::Vec3A>) -> f32 { + let output: f32 = ::glam::Vec3A::length_recip(_self.into_inner()).into(); output } /// Computes the squared length of `self`. /// This is faster than `length()` as it avoids a square root operation. - fn length_squared(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec3A::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::Vec3A>) -> f32 { + let output: f32 = ::glam::Vec3A::length_squared(_self.into_inner()).into(); output } /// Performs a linear interpolation between `self` and `rhs` based on the value `s`. @@ -20233,11 +18752,11 @@ impl bevy::math::Vec3A { /// will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly /// extrapolated. fn lerp( - _self: Val, - rhs: Val, + _self: Val<::glam::Vec3A>, + rhs: Val<::glam::Vec3A>, s: f32, - ) -> Val { - let output: Val = bevy::math::Vec3A::lerp( + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::lerp( _self.into_inner(), rhs.into_inner(), s, @@ -20247,11 +18766,8 @@ impl bevy::math::Vec3A { } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. - fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3A::max( + fn max(_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::max( _self.into_inner(), rhs.into_inner(), ) @@ -20260,8 +18776,8 @@ impl bevy::math::Vec3A { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec3A::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::Vec3A>) -> f32 { + let output: f32 = ::glam::Vec3A::max_element(_self.into_inner()).into(); output } /// Calculates the midpoint between `self` and `rhs`. @@ -20269,10 +18785,10 @@ impl bevy::math::Vec3A { /// `a.midpoint(b)` should yield the same result as `a.lerp(b, 0.5)` /// while being slightly cheaper to compute. fn midpoint( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3A::midpoint( + _self: Val<::glam::Vec3A>, + rhs: Val<::glam::Vec3A>, + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::midpoint( _self.into_inner(), rhs.into_inner(), ) @@ -20281,11 +18797,8 @@ impl bevy::math::Vec3A { } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. - fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3A::min( + fn min(_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::min( _self.into_inner(), rhs.into_inner(), ) @@ -20294,19 +18807,19 @@ impl bevy::math::Vec3A { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec3A::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::Vec3A>) -> f32 { + let output: f32 = ::glam::Vec3A::min_element(_self.into_inner()).into(); output } /// Moves towards `rhs` based on the value `d`. /// When `d` is `0.0`, the result will be equal to `self`. When `d` is equal to /// `self.distance(rhs)`, the result will be equal to `rhs`. Will not go past `rhs`. fn move_towards( - _self: Ref, - rhs: Val, + _self: Ref<::glam::Vec3A>, + rhs: Val<::glam::Vec3A>, d: f32, - ) -> Val { - let output: Val = bevy::math::Vec3A::move_towards( + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::move_towards( &_self, rhs.into_inner(), d, @@ -20314,28 +18827,22 @@ impl bevy::math::Vec3A { .into(); output } - fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Mul< + &::glam::Vec3A, >>::mul(_self.into_inner(), &rhs) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Mul< + ::glam::Vec3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -20348,11 +18855,11 @@ impl bevy::math::Vec3A { /// and will be heavily dependant on designing algorithms with specific target hardware in /// mind. fn mul_add( - _self: Val, - a: Val, - b: Val, - ) -> Val { - let output: Val = bevy::math::Vec3A::mul_add( + _self: Val<::glam::Vec3A>, + a: Val<::glam::Vec3A>, + b: Val<::glam::Vec3A>, + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::mul_add( _self.into_inner(), a.into_inner(), b.into_inner(), @@ -20360,16 +18867,16 @@ impl bevy::math::Vec3A { .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); output } /// Creates a new vector. - fn new(x: f32, y: f32, z: f32) -> Val { - let output: Val = bevy::math::Vec3A::new(x, y, z).into(); + fn new(x: f32, y: f32, z: f32) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::new(x, y, z).into(); output } /// Returns `self` normalized to length 1.0. @@ -20377,10 +18884,8 @@ impl bevy::math::Vec3A { /// See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`]. /// Panics /// Will panic if the resulting normalized vector is not finite when `glam_assert` is enabled. - fn normalize(_self: Val) -> Val { - let output: Val = bevy::math::Vec3A::normalize( - _self.into_inner(), - ) + fn normalize(_self: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::normalize(_self.into_inner()) .into(); output } @@ -20390,10 +18895,10 @@ impl bevy::math::Vec3A { /// the result of this operation will be the fallback value. /// See also [`Self::try_normalize()`]. fn normalize_or( - _self: Val, - fallback: Val, - ) -> Val { - let output: Val = bevy::math::Vec3A::normalize_or( + _self: Val<::glam::Vec3A>, + fallback: Val<::glam::Vec3A>, + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::normalize_or( _self.into_inner(), fallback.into_inner(), ) @@ -20404,19 +18909,16 @@ impl bevy::math::Vec3A { /// In particular, if the input is zero (or very close to zero), or non-finite, /// the result of this operation will be zero. /// See also [`Self::try_normalize()`]. - fn normalize_or_zero(_self: Val) -> Val { - let output: Val = bevy::math::Vec3A::normalize_or_zero( + fn normalize_or_zero(_self: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::normalize_or_zero( _self.into_inner(), ) .into(); output } /// Returns a vector containing each element of `self` raised to the power of `n`. - fn powf(_self: Val, n: f32) -> Val { - let output: Val = bevy::math::Vec3A::powf( - _self.into_inner(), - n, - ) + fn powf(_self: Val<::glam::Vec3A>, n: f32) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::powf(_self.into_inner(), n) .into(); output } @@ -20425,10 +18927,10 @@ impl bevy::math::Vec3A { /// # Panics /// Will panic if `rhs` is zero length when `glam_assert` is enabled. fn project_onto( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3A::project_onto( + _self: Val<::glam::Vec3A>, + rhs: Val<::glam::Vec3A>, + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::project_onto( _self.into_inner(), rhs.into_inner(), ) @@ -20440,10 +18942,10 @@ impl bevy::math::Vec3A { /// # Panics /// Will panic if `rhs` is not normalized when `glam_assert` is enabled. fn project_onto_normalized( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3A::project_onto_normalized( + _self: Val<::glam::Vec3A>, + rhs: Val<::glam::Vec3A>, + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::project_onto_normalized( _self.into_inner(), rhs.into_inner(), ) @@ -20451,9 +18953,8 @@ impl bevy::math::Vec3A { output } /// Returns a vector containing the reciprocal `1.0/n` of each element of `self`. - fn recip(_self: Val) -> Val { - let output: Val = bevy::math::Vec3A::recip(_self.into_inner()) - .into(); + fn recip(_self: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::recip(_self.into_inner()).into(); output } /// Returns the reflection vector for a given incident vector `self` and surface normal @@ -20462,10 +18963,10 @@ impl bevy::math::Vec3A { /// # Panics /// Will panic if `normal` is not normalized when `glam_assert` is enabled. fn reflect( - _self: Val, - normal: Val, - ) -> Val { - let output: Val = bevy::math::Vec3A::reflect( + _self: Val<::glam::Vec3A>, + normal: Val<::glam::Vec3A>, + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::reflect( _self.into_inner(), normal.into_inner(), ) @@ -20479,11 +18980,11 @@ impl bevy::math::Vec3A { /// # Panics /// Will panic if `self` or `normal` is not normalized when `glam_assert` is enabled. fn refract( - _self: Val, - normal: Val, + _self: Val<::glam::Vec3A>, + normal: Val<::glam::Vec3A>, eta: f32, - ) -> Val { - let output: Val = bevy::math::Vec3A::refract( + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::refract( _self.into_inner(), normal.into_inner(), eta, @@ -20498,10 +18999,10 @@ impl bevy::math::Vec3A { /// # Panics /// Will panic if `rhs` has a length of zero when `glam_assert` is enabled. fn reject_from( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3A::reject_from( + _self: Val<::glam::Vec3A>, + rhs: Val<::glam::Vec3A>, + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::reject_from( _self.into_inner(), rhs.into_inner(), ) @@ -20515,38 +19016,32 @@ impl bevy::math::Vec3A { /// # Panics /// Will panic if `rhs` is not normalized when `glam_assert` is enabled. fn reject_from_normalized( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3A::reject_from_normalized( + _self: Val<::glam::Vec3A>, + rhs: Val<::glam::Vec3A>, + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::reject_from_normalized( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Rem< + &::glam::Vec3A, >>::rem(_self.into_inner(), &rhs) .into(); output } - fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Rem< + ::glam::Vec3A, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Rem< f32, >>::rem(_self.into_inner(), rhs) .into(); @@ -20555,10 +19050,10 @@ impl bevy::math::Vec3A { /// Returns the element-wise remainder of [Euclidean division] of `self` by `rhs`. /// [Euclidean division]: f32::rem_euclid fn rem_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec3A::rem_euclid( + _self: Val<::glam::Vec3A>, + rhs: Val<::glam::Vec3A>, + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::rem_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -20567,9 +19062,8 @@ impl bevy::math::Vec3A { } /// Returns a vector containing the nearest integer to a number for each element of `self`. /// Round half-way cases away from 0.0. - fn round(_self: Val) -> Val { - let output: Val = bevy::math::Vec3A::round(_self.into_inner()) - .into(); + fn round(_self: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::round(_self.into_inner()).into(); output } /// Creates a vector from the elements in `if_true` and `if_false`, selecting which to use @@ -20577,11 +19071,11 @@ impl bevy::math::Vec3A { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::Vec3A::select( + mask: Val<::glam::BVec3A>, + if_true: Val<::glam::Vec3A>, + if_false: Val<::glam::Vec3A>, + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -20593,90 +19087,70 @@ impl bevy::math::Vec3A { /// - `1.0` if the number is positive, `+0.0` or `INFINITY` /// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY` /// - `NAN` if the number is `NAN` - fn signum(_self: Val) -> Val { - let output: Val = bevy::math::Vec3A::signum( - _self.into_inner(), - ) + fn signum(_self: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::signum(_self.into_inner()) .into(); output } /// Creates a vector with all elements set to `v`. - fn splat(v: f32) -> Val { - let output: Val = bevy::math::Vec3A::splat(v).into(); + fn splat(v: f32) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::splat(v).into(); output } - fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Sub< + &::glam::Vec3A, >>::sub(_self.into_inner(), &rhs) .into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Sub< + ::glam::Vec3A, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = <::glam::Vec3A as ::core::ops::Sub< f32, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y, z]` - fn to_array(_self: Ref) -> [f32; 3] { - let output: [f32; 3] = bevy::math::Vec3A::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::Vec3A>) -> [f32; 3] { + let output: [f32; 3] = ::glam::Vec3A::to_array(&_self).into(); output } /// Returns a vector containing the integer part each element of `self`. This means numbers are /// always truncated towards zero. - fn trunc(_self: Val) -> Val { - let output: Val = bevy::math::Vec3A::trunc(_self.into_inner()) - .into(); + fn trunc(_self: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::trunc(_self.into_inner()).into(); output } /// Creates a 2D vector from the `x` and `y` elements of `self`, discarding `z`. /// Truncation may also be performed by using [`self.xy()`][crate::swizzles::Vec3Swizzles::xy()]. - fn truncate(_self: Val) -> Val { - let output: Val = bevy::math::Vec3A::truncate( - _self.into_inner(), - ) + fn truncate(_self: Val<::glam::Vec3A>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Vec3A::truncate(_self.into_inner()) .into(); output } /// Creates a 3D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: f32) -> Val { - let output: Val = bevy::math::Vec3A::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::Vec3A>, x: f32) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::with_x(_self.into_inner(), x) .into(); output } /// Creates a 3D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: f32) -> Val { - let output: Val = bevy::math::Vec3A::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::Vec3A>, y: f32) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::with_y(_self.into_inner(), y) .into(); output } /// Creates a 3D vector from `self` with the given value of `z`. - fn with_z(_self: Val, z: f32) -> Val { - let output: Val = bevy::math::Vec3A::with_z( - _self.into_inner(), - z, - ) + fn with_z(_self: Val<::glam::Vec3A>, z: f32) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Vec3A::with_z(_self.into_inner(), z) .into(); output } @@ -20687,11 +19161,10 @@ impl bevy::math::Vec3A { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::Vec4 { +impl ::glam::Vec4 { /// Returns a vector containing the absolute value of each element of `self`. - fn abs(_self: Val) -> Val { - let output: Val = bevy::math::Vec4::abs(_self.into_inner()) - .into(); + fn abs(_self: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::abs(_self.into_inner()).into(); output } /// Returns true if the absolute difference of all elements between `self` and `rhs` is @@ -20702,11 +19175,11 @@ impl bevy::math::Vec4 { /// For more see /// [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/). fn abs_diff_eq( - _self: Val, - rhs: Val, + _self: Val<::glam::Vec4>, + rhs: Val<::glam::Vec4>, max_abs_diff: f32, ) -> bool { - let output: bool = bevy::math::Vec4::abs_diff_eq( + let output: bool = ::glam::Vec4::abs_diff_eq( _self.into_inner(), rhs.into_inner(), max_abs_diff, @@ -20714,87 +19187,76 @@ impl bevy::math::Vec4 { .into(); output } - fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Add< + &::glam::Vec4, >>::add(_self.into_inner(), &rhs) .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Add< + ::glam::Vec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Add< f32, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `f64`. - fn as_dvec4(_self: Ref) -> Val { - let output: Val = bevy::math::Vec4::as_dvec4(&_self).into(); + fn as_dvec4(_self: Ref<::glam::Vec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::Vec4::as_dvec4(&_self).into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec4(_self: Ref) -> Val { - let output: Val = bevy::math::Vec4::as_i16vec4(&_self) - .into(); + fn as_i16vec4(_self: Ref<::glam::Vec4>) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::Vec4::as_i16vec4(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec4(_self: Ref) -> Val { - let output: Val = bevy::math::Vec4::as_i64vec4(&_self) - .into(); + fn as_i64vec4(_self: Ref<::glam::Vec4>) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::Vec4::as_i64vec4(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec4(_self: Ref) -> Val { - let output: Val = bevy::math::Vec4::as_i8vec4(&_self).into(); + fn as_i8vec4(_self: Ref<::glam::Vec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::Vec4::as_i8vec4(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec4(_self: Ref) -> Val { - let output: Val = bevy::math::Vec4::as_ivec4(&_self).into(); + fn as_ivec4(_self: Ref<::glam::Vec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::Vec4::as_ivec4(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec4(_self: Ref) -> Val { - let output: Val = bevy::math::Vec4::as_u16vec4(&_self) - .into(); + fn as_u16vec4(_self: Ref<::glam::Vec4>) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::Vec4::as_u16vec4(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec4(_self: Ref) -> Val { - let output: Val = bevy::math::Vec4::as_u64vec4(&_self) - .into(); + fn as_u64vec4(_self: Ref<::glam::Vec4>) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::Vec4::as_u64vec4(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec4(_self: Ref) -> Val { - let output: Val = bevy::math::Vec4::as_u8vec4(&_self).into(); + fn as_u8vec4(_self: Ref<::glam::Vec4>) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::Vec4::as_u8vec4(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec4(_self: Ref) -> Val { - let output: Val = bevy::math::Vec4::as_uvec4(&_self).into(); + fn as_uvec4(_self: Ref<::glam::Vec4>) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::Vec4::as_uvec4(&_self).into(); output } /// Returns a vector containing the smallest integer greater than or equal to a number for /// each element of `self`. - fn ceil(_self: Val) -> Val { - let output: Val = bevy::math::Vec4::ceil(_self.into_inner()) - .into(); + fn ceil(_self: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::ceil(_self.into_inner()).into(); output } /// Component-wise clamping of values, similar to [`f32::clamp`]. @@ -20802,11 +19264,11 @@ impl bevy::math::Vec4 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::Vec4::clamp( + _self: Val<::glam::Vec4>, + min: Val<::glam::Vec4>, + max: Val<::glam::Vec4>, + ) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -20817,12 +19279,8 @@ impl bevy::math::Vec4 { /// Returns a vector with a length no less than `min` and no more than `max`. /// # Panics /// Will panic if `min` is greater than `max`, or if either `min` or `max` is negative, when `glam_assert` is enabled. - fn clamp_length( - _self: Val, - min: f32, - max: f32, - ) -> Val { - let output: Val = bevy::math::Vec4::clamp_length( + fn clamp_length(_self: Val<::glam::Vec4>, min: f32, max: f32) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::clamp_length( _self.into_inner(), min, max, @@ -20833,11 +19291,8 @@ impl bevy::math::Vec4 { /// Returns a vector with a length no more than `max`. /// # Panics /// Will panic if `max` is negative when `glam_assert` is enabled. - fn clamp_length_max( - _self: Val, - max: f32, - ) -> Val { - let output: Val = bevy::math::Vec4::clamp_length_max( + fn clamp_length_max(_self: Val<::glam::Vec4>, max: f32) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::clamp_length_max( _self.into_inner(), max, ) @@ -20847,19 +19302,16 @@ impl bevy::math::Vec4 { /// Returns a vector with a length no less than `min`. /// # Panics /// Will panic if `min` is negative when `glam_assert` is enabled. - fn clamp_length_min( - _self: Val, - min: f32, - ) -> Val { - let output: Val = bevy::math::Vec4::clamp_length_min( + fn clamp_length_min(_self: Val<::glam::Vec4>, min: f32) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::clamp_length_min( _self.into_inner(), min, ) .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -20869,11 +19321,8 @@ impl bevy::math::Vec4 { /// `self` and `rhs`. /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. - fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec4::cmpeq( + fn cmpeq(_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>) -> Val<::glam::BVec4A> { + let output: Val<::glam::BVec4A> = ::glam::Vec4::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -20884,11 +19333,8 @@ impl bevy::math::Vec4 { /// `self` and `rhs`. /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. - fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec4::cmpge( + fn cmpge(_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>) -> Val<::glam::BVec4A> { + let output: Val<::glam::BVec4A> = ::glam::Vec4::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -20899,11 +19345,8 @@ impl bevy::math::Vec4 { /// `self` and `rhs`. /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. - fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec4::cmpgt( + fn cmpgt(_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>) -> Val<::glam::BVec4A> { + let output: Val<::glam::BVec4A> = ::glam::Vec4::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -20914,11 +19357,8 @@ impl bevy::math::Vec4 { /// `self` and `rhs`. /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. - fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec4::cmple( + fn cmple(_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>) -> Val<::glam::BVec4A> { + let output: Val<::glam::BVec4A> = ::glam::Vec4::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -20929,11 +19369,8 @@ impl bevy::math::Vec4 { /// `self` and `rhs`. /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. - fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec4::cmplt( + fn cmplt(_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>) -> Val<::glam::BVec4A> { + let output: Val<::glam::BVec4A> = ::glam::Vec4::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -20944,11 +19381,8 @@ impl bevy::math::Vec4 { /// `self` and `rhs`. /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. - fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec4::cmpne( + fn cmpne(_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>) -> Val<::glam::BVec4A> { + let output: Val<::glam::BVec4A> = ::glam::Vec4::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -20956,11 +19390,8 @@ impl bevy::math::Vec4 { output } /// Returns a vector with signs of `rhs` and the magnitudes of `self`. - fn copysign( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec4::copysign( + fn copysign(_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::copysign( _self.into_inner(), rhs.into_inner(), ) @@ -20968,48 +19399,36 @@ impl bevy::math::Vec4 { output } /// Computes the Euclidean distance between two points in space. - fn distance(_self: Val, rhs: Val) -> f32 { - let output: f32 = bevy::math::Vec4::distance( - _self.into_inner(), - rhs.into_inner(), - ) + fn distance(_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>) -> f32 { + let output: f32 = ::glam::Vec4::distance(_self.into_inner(), rhs.into_inner()) .into(); output } /// Compute the squared euclidean distance between two points in space. - fn distance_squared( - _self: Val, - rhs: Val, - ) -> f32 { - let output: f32 = bevy::math::Vec4::distance_squared( + fn distance_squared(_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>) -> f32 { + let output: f32 = ::glam::Vec4::distance_squared( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Div< + &::glam::Vec4, >>::div(_self.into_inner(), &rhs) .into(); output } - fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Div< + ::glam::Vec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); @@ -21017,10 +19436,10 @@ impl bevy::math::Vec4 { } /// Returns the element-wise quotient of [Euclidean division] of `self` by `rhs`. fn div_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec4::div_euclid( + _self: Val<::glam::Vec4>, + rhs: Val<::glam::Vec4>, + ) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -21028,17 +19447,16 @@ impl bevy::math::Vec4 { output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> f32 { - let output: f32 = bevy::math::Vec4::dot(_self.into_inner(), rhs.into_inner()) - .into(); + fn dot(_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>) -> f32 { + let output: f32 = ::glam::Vec4::dot(_self.into_inner(), rhs.into_inner()).into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec4::dot_into_vec( + _self: Val<::glam::Vec4>, + rhs: Val<::glam::Vec4>, + ) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -21047,120 +19465,112 @@ impl bevy::math::Vec4 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec4::element_product(_self.into_inner()).into(); + fn element_product(_self: Val<::glam::Vec4>) -> f32 { + let output: f32 = ::glam::Vec4::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec4::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::Vec4>) -> f32 { + let output: f32 = ::glam::Vec4::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, rhs: Ref) -> bool { - let output: bool = , rhs: Ref<::glam::Vec4>) -> bool { + let output: bool = <::glam::Vec4 as ::core::cmp::PartialEq< + ::glam::Vec4, >>::eq(&_self, &rhs) .into(); output } /// Returns a vector containing `e^self` (the exponential function) for each element of /// `self`. - fn exp(_self: Val) -> Val { - let output: Val = bevy::math::Vec4::exp(_self.into_inner()) - .into(); + fn exp(_self: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::exp(_self.into_inner()).into(); output } /// Returns a vector containing the largest integer less than or equal to a number for each /// element of `self`. - fn floor(_self: Val) -> Val { - let output: Val = bevy::math::Vec4::floor(_self.into_inner()) - .into(); + fn floor(_self: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::floor(_self.into_inner()).into(); output } /// Returns a vector containing the fractional part of the vector as `self - self.trunc()`. /// Note that this differs from the GLSL implementation of `fract` which returns /// `self - self.floor()`. /// Note that this is fast but not precise for large numbers. - fn fract(_self: Val) -> Val { - let output: Val = bevy::math::Vec4::fract(_self.into_inner()) - .into(); + fn fract(_self: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::fract(_self.into_inner()).into(); output } /// Returns a vector containing the fractional part of the vector as `self - self.floor()`. /// Note that this differs from the Rust implementation of `fract` which returns /// `self - self.trunc()`. /// Note that this is fast but not precise for large numbers. - fn fract_gl(_self: Val) -> Val { - let output: Val = bevy::math::Vec4::fract_gl( - _self.into_inner(), - ) + fn fract_gl(_self: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::fract_gl(_self.into_inner()) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [f32; 4]) -> Val { - let output: Val = bevy::math::Vec4::from_array(a).into(); + fn from_array(a: [f32; 4]) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::from_array(a).into(); output } /// Returns `true` if, and only if, all elements are finite. If any element is either /// `NaN`, positive or negative infinity, this will return `false`. - fn is_finite(_self: Val) -> bool { - let output: bool = bevy::math::Vec4::is_finite(_self.into_inner()).into(); + fn is_finite(_self: Val<::glam::Vec4>) -> bool { + let output: bool = ::glam::Vec4::is_finite(_self.into_inner()).into(); output } /// Performs `is_finite` on each element of self, returning a vector mask of the results. /// In other words, this computes `[x.is_finite(), y.is_finite(), ...]`. - fn is_finite_mask(_self: Val) -> Val { - let output: Val = bevy::math::Vec4::is_finite_mask( + fn is_finite_mask(_self: Val<::glam::Vec4>) -> Val<::glam::BVec4A> { + let output: Val<::glam::BVec4A> = ::glam::Vec4::is_finite_mask( _self.into_inner(), ) .into(); output } /// Returns `true` if any elements are `NaN`. - fn is_nan(_self: Val) -> bool { - let output: bool = bevy::math::Vec4::is_nan(_self.into_inner()).into(); + fn is_nan(_self: Val<::glam::Vec4>) -> bool { + let output: bool = ::glam::Vec4::is_nan(_self.into_inner()).into(); output } /// Performs `is_nan` on each element of self, returning a vector mask of the results. /// In other words, this computes `[x.is_nan(), y.is_nan(), ...]`. - fn is_nan_mask(_self: Val) -> Val { - let output: Val = bevy::math::Vec4::is_nan_mask( - _self.into_inner(), - ) + fn is_nan_mask(_self: Val<::glam::Vec4>) -> Val<::glam::BVec4A> { + let output: Val<::glam::BVec4A> = ::glam::Vec4::is_nan_mask(_self.into_inner()) .into(); output } /// Returns a bitmask with the lowest 4 bits set to the sign bits from the elements of `self`. /// A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn is_negative_bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::Vec4::is_negative_bitmask(_self.into_inner()) - .into(); + fn is_negative_bitmask(_self: Val<::glam::Vec4>) -> u32 { + let output: u32 = ::glam::Vec4::is_negative_bitmask(_self.into_inner()).into(); output } /// Returns whether `self` is length `1.0` or not. /// Uses a precision threshold of approximately `1e-4`. - fn is_normalized(_self: Val) -> bool { - let output: bool = bevy::math::Vec4::is_normalized(_self.into_inner()).into(); + fn is_normalized(_self: Val<::glam::Vec4>) -> bool { + let output: bool = ::glam::Vec4::is_normalized(_self.into_inner()).into(); output } /// Computes the length of `self`. - fn length(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec4::length(_self.into_inner()).into(); + fn length(_self: Val<::glam::Vec4>) -> f32 { + let output: f32 = ::glam::Vec4::length(_self.into_inner()).into(); output } /// Computes `1.0 / length()`. /// For valid results, `self` must _not_ be of length zero. - fn length_recip(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec4::length_recip(_self.into_inner()).into(); + fn length_recip(_self: Val<::glam::Vec4>) -> f32 { + let output: f32 = ::glam::Vec4::length_recip(_self.into_inner()).into(); output } /// Computes the squared length of `self`. /// This is faster than `length()` as it avoids a square root operation. - fn length_squared(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec4::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::Vec4>) -> f32 { + let output: f32 = ::glam::Vec4::length_squared(_self.into_inner()).into(); output } /// Performs a linear interpolation between `self` and `rhs` based on the value `s`. @@ -21168,11 +19578,11 @@ impl bevy::math::Vec4 { /// will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly /// extrapolated. fn lerp( - _self: Val, - rhs: Val, + _self: Val<::glam::Vec4>, + rhs: Val<::glam::Vec4>, s: f32, - ) -> Val { - let output: Val = bevy::math::Vec4::lerp( + ) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::lerp( _self.into_inner(), rhs.into_inner(), s, @@ -21182,11 +19592,8 @@ impl bevy::math::Vec4 { } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. - fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec4::max( + fn max(_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::max( _self.into_inner(), rhs.into_inner(), ) @@ -21195,19 +19602,16 @@ impl bevy::math::Vec4 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec4::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::Vec4>) -> f32 { + let output: f32 = ::glam::Vec4::max_element(_self.into_inner()).into(); output } /// Calculates the midpoint between `self` and `rhs`. /// The midpoint is the average of, or halfway point between, two vectors. /// `a.midpoint(b)` should yield the same result as `a.lerp(b, 0.5)` /// while being slightly cheaper to compute. - fn midpoint( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec4::midpoint( + fn midpoint(_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::midpoint( _self.into_inner(), rhs.into_inner(), ) @@ -21216,11 +19620,8 @@ impl bevy::math::Vec4 { } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. - fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec4::min( + fn min(_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::min( _self.into_inner(), rhs.into_inner(), ) @@ -21229,19 +19630,19 @@ impl bevy::math::Vec4 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> f32 { - let output: f32 = bevy::math::Vec4::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::Vec4>) -> f32 { + let output: f32 = ::glam::Vec4::min_element(_self.into_inner()).into(); output } /// Moves towards `rhs` based on the value `d`. /// When `d` is `0.0`, the result will be equal to `self`. When `d` is equal to /// `self.distance(rhs)`, the result will be equal to `rhs`. Will not go past `rhs`. fn move_towards( - _self: Ref, - rhs: Val, + _self: Ref<::glam::Vec4>, + rhs: Val<::glam::Vec4>, d: f32, - ) -> Val { - let output: Val = bevy::math::Vec4::move_towards( + ) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::move_towards( &_self, rhs.into_inner(), d, @@ -21249,28 +19650,22 @@ impl bevy::math::Vec4 { .into(); output } - fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Mul< + &::glam::Vec4, >>::mul(_self.into_inner(), &rhs) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Mul< + ::glam::Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -21283,11 +19678,11 @@ impl bevy::math::Vec4 { /// and will be heavily dependant on designing algorithms with specific target hardware in /// mind. fn mul_add( - _self: Val, - a: Val, - b: Val, - ) -> Val { - let output: Val = bevy::math::Vec4::mul_add( + _self: Val<::glam::Vec4>, + a: Val<::glam::Vec4>, + b: Val<::glam::Vec4>, + ) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::mul_add( _self.into_inner(), a.into_inner(), b.into_inner(), @@ -21295,16 +19690,16 @@ impl bevy::math::Vec4 { .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); output } /// Creates a new vector. - fn new(x: f32, y: f32, z: f32, w: f32) -> Val { - let output: Val = bevy::math::Vec4::new(x, y, z, w).into(); + fn new(x: f32, y: f32, z: f32, w: f32) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::new(x, y, z, w).into(); output } /// Returns `self` normalized to length 1.0. @@ -21312,10 +19707,8 @@ impl bevy::math::Vec4 { /// See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`]. /// Panics /// Will panic if the resulting normalized vector is not finite when `glam_assert` is enabled. - fn normalize(_self: Val) -> Val { - let output: Val = bevy::math::Vec4::normalize( - _self.into_inner(), - ) + fn normalize(_self: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::normalize(_self.into_inner()) .into(); output } @@ -21325,10 +19718,10 @@ impl bevy::math::Vec4 { /// the result of this operation will be the fallback value. /// See also [`Self::try_normalize()`]. fn normalize_or( - _self: Val, - fallback: Val, - ) -> Val { - let output: Val = bevy::math::Vec4::normalize_or( + _self: Val<::glam::Vec4>, + fallback: Val<::glam::Vec4>, + ) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::normalize_or( _self.into_inner(), fallback.into_inner(), ) @@ -21339,17 +19732,16 @@ impl bevy::math::Vec4 { /// In particular, if the input is zero (or very close to zero), or non-finite, /// the result of this operation will be zero. /// See also [`Self::try_normalize()`]. - fn normalize_or_zero(_self: Val) -> Val { - let output: Val = bevy::math::Vec4::normalize_or_zero( + fn normalize_or_zero(_self: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::normalize_or_zero( _self.into_inner(), ) .into(); output } /// Returns a vector containing each element of `self` raised to the power of `n`. - fn powf(_self: Val, n: f32) -> Val { - let output: Val = bevy::math::Vec4::powf(_self.into_inner(), n) - .into(); + fn powf(_self: Val<::glam::Vec4>, n: f32) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::powf(_self.into_inner(), n).into(); output } /// Returns the vector projection of `self` onto `rhs`. @@ -21357,10 +19749,10 @@ impl bevy::math::Vec4 { /// # Panics /// Will panic if `rhs` is zero length when `glam_assert` is enabled. fn project_onto( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec4::project_onto( + _self: Val<::glam::Vec4>, + rhs: Val<::glam::Vec4>, + ) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::project_onto( _self.into_inner(), rhs.into_inner(), ) @@ -21372,10 +19764,10 @@ impl bevy::math::Vec4 { /// # Panics /// Will panic if `rhs` is not normalized when `glam_assert` is enabled. fn project_onto_normalized( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec4::project_onto_normalized( + _self: Val<::glam::Vec4>, + rhs: Val<::glam::Vec4>, + ) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::project_onto_normalized( _self.into_inner(), rhs.into_inner(), ) @@ -21383,9 +19775,8 @@ impl bevy::math::Vec4 { output } /// Returns a vector containing the reciprocal `1.0/n` of each element of `self`. - fn recip(_self: Val) -> Val { - let output: Val = bevy::math::Vec4::recip(_self.into_inner()) - .into(); + fn recip(_self: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::recip(_self.into_inner()).into(); output } /// Returns the reflection vector for a given incident vector `self` and surface normal @@ -21394,10 +19785,10 @@ impl bevy::math::Vec4 { /// # Panics /// Will panic if `normal` is not normalized when `glam_assert` is enabled. fn reflect( - _self: Val, - normal: Val, - ) -> Val { - let output: Val = bevy::math::Vec4::reflect( + _self: Val<::glam::Vec4>, + normal: Val<::glam::Vec4>, + ) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::reflect( _self.into_inner(), normal.into_inner(), ) @@ -21411,11 +19802,11 @@ impl bevy::math::Vec4 { /// # Panics /// Will panic if `self` or `normal` is not normalized when `glam_assert` is enabled. fn refract( - _self: Val, - normal: Val, + _self: Val<::glam::Vec4>, + normal: Val<::glam::Vec4>, eta: f32, - ) -> Val { - let output: Val = bevy::math::Vec4::refract( + ) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::refract( _self.into_inner(), normal.into_inner(), eta, @@ -21430,10 +19821,10 @@ impl bevy::math::Vec4 { /// # Panics /// Will panic if `rhs` has a length of zero when `glam_assert` is enabled. fn reject_from( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec4::reject_from( + _self: Val<::glam::Vec4>, + rhs: Val<::glam::Vec4>, + ) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::reject_from( _self.into_inner(), rhs.into_inner(), ) @@ -21447,38 +19838,32 @@ impl bevy::math::Vec4 { /// # Panics /// Will panic if `rhs` is not normalized when `glam_assert` is enabled. fn reject_from_normalized( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec4::reject_from_normalized( + _self: Val<::glam::Vec4>, + rhs: Val<::glam::Vec4>, + ) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::reject_from_normalized( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Rem< + &::glam::Vec4, >>::rem(_self.into_inner(), &rhs) .into(); output } - fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Rem< + ::glam::Vec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Rem< f32, >>::rem(_self.into_inner(), rhs) .into(); @@ -21487,10 +19872,10 @@ impl bevy::math::Vec4 { /// Returns the element-wise remainder of [Euclidean division] of `self` by `rhs`. /// [Euclidean division]: f32::rem_euclid fn rem_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Vec4::rem_euclid( + _self: Val<::glam::Vec4>, + rhs: Val<::glam::Vec4>, + ) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::rem_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -21499,9 +19884,8 @@ impl bevy::math::Vec4 { } /// Returns a vector containing the nearest integer to a number for each element of `self`. /// Round half-way cases away from 0.0. - fn round(_self: Val) -> Val { - let output: Val = bevy::math::Vec4::round(_self.into_inner()) - .into(); + fn round(_self: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::round(_self.into_inner()).into(); output } /// Creates a vector from the elements in `if_true` and `if_false`, selecting which to use @@ -21509,11 +19893,11 @@ impl bevy::math::Vec4 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::Vec4::select( + mask: Val<::glam::BVec4A>, + if_true: Val<::glam::Vec4>, + if_false: Val<::glam::Vec4>, + ) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -21525,98 +19909,76 @@ impl bevy::math::Vec4 { /// - `1.0` if the number is positive, `+0.0` or `INFINITY` /// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY` /// - `NAN` if the number is `NAN` - fn signum(_self: Val) -> Val { - let output: Val = bevy::math::Vec4::signum(_self.into_inner()) - .into(); + fn signum(_self: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::signum(_self.into_inner()).into(); output } /// Creates a vector with all elements set to `v`. - fn splat(v: f32) -> Val { - let output: Val = bevy::math::Vec4::splat(v).into(); + fn splat(v: f32) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::splat(v).into(); output } - fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Sub< + &::glam::Vec4, >>::sub(_self.into_inner(), &rhs) .into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Sub< + ::glam::Vec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = <::glam::Vec4 as ::core::ops::Sub< f32, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y, z, w]` - fn to_array(_self: Ref) -> [f32; 4] { - let output: [f32; 4] = bevy::math::Vec4::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::Vec4>) -> [f32; 4] { + let output: [f32; 4] = ::glam::Vec4::to_array(&_self).into(); output } /// Returns a vector containing the integer part each element of `self`. This means numbers are /// always truncated towards zero. - fn trunc(_self: Val) -> Val { - let output: Val = bevy::math::Vec4::trunc(_self.into_inner()) - .into(); + fn trunc(_self: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::trunc(_self.into_inner()).into(); output } /// Creates a 3D vector from the `x`, `y` and `z` elements of `self`, discarding `w`. /// Truncation to [`Vec3`] may also be performed by using [`self.xyz()`][crate::swizzles::Vec4Swizzles::xyz()]. /// To truncate to [`Vec3A`] use [`Vec3A::from()`]. - fn truncate(_self: Val) -> Val { - let output: Val = bevy::math::Vec4::truncate( - _self.into_inner(), - ) + fn truncate(_self: Val<::glam::Vec4>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Vec4::truncate(_self.into_inner()) .into(); output } /// Creates a 4D vector from `self` with the given value of `w`. - fn with_w(_self: Val, w: f32) -> Val { - let output: Val = bevy::math::Vec4::with_w( - _self.into_inner(), - w, - ) + fn with_w(_self: Val<::glam::Vec4>, w: f32) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::with_w(_self.into_inner(), w) .into(); output } /// Creates a 4D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: f32) -> Val { - let output: Val = bevy::math::Vec4::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::Vec4>, x: f32) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::with_x(_self.into_inner(), x) .into(); output } /// Creates a 4D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: f32) -> Val { - let output: Val = bevy::math::Vec4::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::Vec4>, y: f32) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::with_y(_self.into_inner(), y) .into(); output } /// Creates a 4D vector from `self` with the given value of `z`. - fn with_z(_self: Val, z: f32) -> Val { - let output: Val = bevy::math::Vec4::with_z( - _self.into_inner(), - z, - ) + fn with_z(_self: Val<::glam::Vec4>, z: f32) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Vec4::with_z(_self.into_inner(), z) .into(); output } @@ -21627,19 +19989,19 @@ impl bevy::math::Vec4 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::BVec2 { +impl ::glam::BVec2 { /// Returns true if all the elements are true, false otherwise. - fn all(_self: Val) -> bool { - let output: bool = bevy::math::BVec2::all(_self.into_inner()).into(); + fn all(_self: Val<::glam::BVec2>) -> bool { + let output: bool = ::glam::BVec2::all(_self.into_inner()).into(); output } /// Returns true if any of the elements are true, false otherwise. - fn any(_self: Val) -> bool { - let output: bool = bevy::math::BVec2::any(_self.into_inner()).into(); + fn any(_self: Val<::glam::BVec2>) -> bool { + let output: bool = ::glam::BVec2::any(_self.into_inner()).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::BVec2>) -> () { + let output: () = <::glam::BVec2 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -21648,49 +20010,49 @@ impl bevy::math::BVec2 { /// Returns a bitmask with the lowest 2 bits set from the elements of `self`. /// A true element results in a `1` bit and a false element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::BVec2::bitmask(_self.into_inner()).into(); + fn bitmask(_self: Val<::glam::BVec2>) -> u32 { + let output: u32 = ::glam::BVec2::bitmask(_self.into_inner()).into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::BVec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = <::glam::BVec2 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::BVec2>) -> bool { + let output: bool = <::glam::BVec2 as ::core::cmp::PartialEq< + ::glam::BVec2, >>::eq(&_self, &other) .into(); output } /// Creates a new vector mask from a bool array. - fn from_array(a: [bool; 2]) -> Val { - let output: Val = bevy::math::BVec2::from_array(a).into(); + fn from_array(a: [bool; 2]) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::BVec2::from_array(a).into(); output } /// Creates a new vector mask. - fn new(x: bool, y: bool) -> Val { - let output: Val = bevy::math::BVec2::new(x, y).into(); + fn new(x: bool, y: bool) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::BVec2::new(x, y).into(); output } /// Sets the element at `index`. /// Panics if `index` is greater than 1. - fn set(mut _self: Mut, index: usize, value: bool) -> () { - let output: () = bevy::math::BVec2::set(&mut _self, index, value).into(); + fn set(mut _self: Mut<::glam::BVec2>, index: usize, value: bool) -> () { + let output: () = ::glam::BVec2::set(&mut _self, index, value).into(); output } /// Creates a vector mask with all elements set to `v`. - fn splat(v: bool) -> Val { - let output: Val = bevy::math::BVec2::splat(v).into(); + fn splat(v: bool) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::BVec2::splat(v).into(); output } /// Tests the value at `index`. /// Panics if `index` is greater than 1. - fn test(_self: Ref, index: usize) -> bool { - let output: bool = bevy::math::BVec2::test(&_self, index).into(); + fn test(_self: Ref<::glam::BVec2>, index: usize) -> bool { + let output: bool = ::glam::BVec2::test(&_self, index).into(); output } } @@ -21700,19 +20062,19 @@ impl bevy::math::BVec2 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::BVec3 { +impl ::glam::BVec3 { /// Returns true if all the elements are true, false otherwise. - fn all(_self: Val) -> bool { - let output: bool = bevy::math::BVec3::all(_self.into_inner()).into(); + fn all(_self: Val<::glam::BVec3>) -> bool { + let output: bool = ::glam::BVec3::all(_self.into_inner()).into(); output } /// Returns true if any of the elements are true, false otherwise. - fn any(_self: Val) -> bool { - let output: bool = bevy::math::BVec3::any(_self.into_inner()).into(); + fn any(_self: Val<::glam::BVec3>) -> bool { + let output: bool = ::glam::BVec3::any(_self.into_inner()).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::BVec3>) -> () { + let output: () = <::glam::BVec3 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -21721,49 +20083,49 @@ impl bevy::math::BVec3 { /// Returns a bitmask with the lowest 3 bits set from the elements of `self`. /// A true element results in a `1` bit and a false element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::BVec3::bitmask(_self.into_inner()).into(); + fn bitmask(_self: Val<::glam::BVec3>) -> u32 { + let output: u32 = ::glam::BVec3::bitmask(_self.into_inner()).into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::BVec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = <::glam::BVec3 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::BVec3>) -> bool { + let output: bool = <::glam::BVec3 as ::core::cmp::PartialEq< + ::glam::BVec3, >>::eq(&_self, &other) .into(); output } /// Creates a new vector mask from a bool array. - fn from_array(a: [bool; 3]) -> Val { - let output: Val = bevy::math::BVec3::from_array(a).into(); + fn from_array(a: [bool; 3]) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::BVec3::from_array(a).into(); output } /// Creates a new vector mask. - fn new(x: bool, y: bool, z: bool) -> Val { - let output: Val = bevy::math::BVec3::new(x, y, z).into(); + fn new(x: bool, y: bool, z: bool) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::BVec3::new(x, y, z).into(); output } /// Sets the element at `index`. /// Panics if `index` is greater than 2. - fn set(mut _self: Mut, index: usize, value: bool) -> () { - let output: () = bevy::math::BVec3::set(&mut _self, index, value).into(); + fn set(mut _self: Mut<::glam::BVec3>, index: usize, value: bool) -> () { + let output: () = ::glam::BVec3::set(&mut _self, index, value).into(); output } /// Creates a vector mask with all elements set to `v`. - fn splat(v: bool) -> Val { - let output: Val = bevy::math::BVec3::splat(v).into(); + fn splat(v: bool) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::BVec3::splat(v).into(); output } /// Tests the value at `index`. /// Panics if `index` is greater than 2. - fn test(_self: Ref, index: usize) -> bool { - let output: bool = bevy::math::BVec3::test(&_self, index).into(); + fn test(_self: Ref<::glam::BVec3>, index: usize) -> bool { + let output: bool = ::glam::BVec3::test(&_self, index).into(); output } } @@ -21773,19 +20135,19 @@ impl bevy::math::BVec3 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::BVec4 { +impl ::glam::BVec4 { /// Returns true if all the elements are true, false otherwise. - fn all(_self: Val) -> bool { - let output: bool = bevy::math::BVec4::all(_self.into_inner()).into(); + fn all(_self: Val<::glam::BVec4>) -> bool { + let output: bool = ::glam::BVec4::all(_self.into_inner()).into(); output } /// Returns true if any of the elements are true, false otherwise. - fn any(_self: Val) -> bool { - let output: bool = bevy::math::BVec4::any(_self.into_inner()).into(); + fn any(_self: Val<::glam::BVec4>) -> bool { + let output: bool = ::glam::BVec4::any(_self.into_inner()).into(); output } - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( + fn assert_receiver_is_total_eq(_self: Ref<::glam::BVec4>) -> () { + let output: () = <::glam::BVec4 as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); @@ -21794,49 +20156,49 @@ impl bevy::math::BVec4 { /// Returns a bitmask with the lowest 4 bits set from the elements of `self`. /// A true element results in a `1` bit and a false element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::BVec4::bitmask(_self.into_inner()).into(); + fn bitmask(_self: Val<::glam::BVec4>) -> u32 { + let output: u32 = ::glam::BVec4::bitmask(_self.into_inner()).into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::BVec4>) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = <::glam::BVec4 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::BVec4>) -> bool { + let output: bool = <::glam::BVec4 as ::core::cmp::PartialEq< + ::glam::BVec4, >>::eq(&_self, &other) .into(); output } /// Creates a new vector mask from a bool array. - fn from_array(a: [bool; 4]) -> Val { - let output: Val = bevy::math::BVec4::from_array(a).into(); + fn from_array(a: [bool; 4]) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::BVec4::from_array(a).into(); output } /// Creates a new vector mask. - fn new(x: bool, y: bool, z: bool, w: bool) -> Val { - let output: Val = bevy::math::BVec4::new(x, y, z, w).into(); + fn new(x: bool, y: bool, z: bool, w: bool) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::BVec4::new(x, y, z, w).into(); output } /// Sets the element at `index`. /// Panics if `index` is greater than 3. - fn set(mut _self: Mut, index: usize, value: bool) -> () { - let output: () = bevy::math::BVec4::set(&mut _self, index, value).into(); + fn set(mut _self: Mut<::glam::BVec4>, index: usize, value: bool) -> () { + let output: () = ::glam::BVec4::set(&mut _self, index, value).into(); output } /// Creates a vector mask with all elements set to `v`. - fn splat(v: bool) -> Val { - let output: Val = bevy::math::BVec4::splat(v).into(); + fn splat(v: bool) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::BVec4::splat(v).into(); output } /// Tests the value at `index`. /// Panics if `index` is greater than 3. - fn test(_self: Ref, index: usize) -> bool { - let output: bool = bevy::math::BVec4::test(&_self, index).into(); + fn test(_self: Ref<::glam::BVec4>, index: usize) -> bool { + let output: bool = ::glam::BVec4::test(&_self, index).into(); output } } @@ -21846,11 +20208,10 @@ impl bevy::math::BVec4 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::DVec2 { +impl ::glam::DVec2 { /// Returns a vector containing the absolute value of each element of `self`. - fn abs(_self: Val) -> Val { - let output: Val = bevy::math::DVec2::abs(_self.into_inner()) - .into(); + fn abs(_self: Val<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::abs(_self.into_inner()).into(); output } /// Returns true if the absolute difference of all elements between `self` and `rhs` is @@ -21861,11 +20222,11 @@ impl bevy::math::DVec2 { /// For more see /// [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/). fn abs_diff_eq( - _self: Val, - rhs: Val, + _self: Val<::glam::DVec2>, + rhs: Val<::glam::DVec2>, max_abs_diff: f64, ) -> bool { - let output: bool = bevy::math::DVec2::abs_diff_eq( + let output: bool = ::glam::DVec2::abs_diff_eq( _self.into_inner(), rhs.into_inner(), max_abs_diff, @@ -21873,35 +20234,29 @@ impl bevy::math::DVec2 { .into(); output } - fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Add< + &::glam::DVec2, >>::add(_self.into_inner(), &rhs) .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Add< + ::glam::DVec2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: f64) -> Val { - let output: Val = , rhs: f64) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Add< f64, >>::add(_self.into_inner(), rhs) .into(); output } - fn angle_between(_self: Val, rhs: Val) -> f64 { - let output: f64 = bevy::math::DVec2::angle_between( + fn angle_between(_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>) -> f64 { + let output: f64 = ::glam::DVec2::angle_between( _self.into_inner(), rhs.into_inner(), ) @@ -21910,70 +20265,60 @@ impl bevy::math::DVec2 { } /// Returns the angle of rotation (in radians) from `self` to `rhs` in the range `[-Ï€, +Ï€]`. /// The inputs do not need to be unit vectors however they must be non-zero. - fn angle_to(_self: Val, rhs: Val) -> f64 { - let output: f64 = bevy::math::DVec2::angle_to( - _self.into_inner(), - rhs.into_inner(), - ) + fn angle_to(_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>) -> f64 { + let output: f64 = ::glam::DVec2::angle_to(_self.into_inner(), rhs.into_inner()) .into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec2(_self: Ref) -> Val { - let output: Val = bevy::math::DVec2::as_i16vec2(&_self) - .into(); + fn as_i16vec2(_self: Ref<::glam::DVec2>) -> Val<::glam::I16Vec2> { + let output: Val<::glam::I16Vec2> = ::glam::DVec2::as_i16vec2(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec2(_self: Ref) -> Val { - let output: Val = bevy::math::DVec2::as_i64vec2(&_self) - .into(); + fn as_i64vec2(_self: Ref<::glam::DVec2>) -> Val<::glam::I64Vec2> { + let output: Val<::glam::I64Vec2> = ::glam::DVec2::as_i64vec2(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec2(_self: Ref) -> Val { - let output: Val = bevy::math::DVec2::as_i8vec2(&_self) - .into(); + fn as_i8vec2(_self: Ref<::glam::DVec2>) -> Val<::glam::I8Vec2> { + let output: Val<::glam::I8Vec2> = ::glam::DVec2::as_i8vec2(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec2(_self: Ref) -> Val { - let output: Val = bevy::math::DVec2::as_ivec2(&_self).into(); + fn as_ivec2(_self: Ref<::glam::DVec2>) -> Val<::glam::IVec2> { + let output: Val<::glam::IVec2> = ::glam::DVec2::as_ivec2(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec2(_self: Ref) -> Val { - let output: Val = bevy::math::DVec2::as_u16vec2(&_self) - .into(); + fn as_u16vec2(_self: Ref<::glam::DVec2>) -> Val<::glam::U16Vec2> { + let output: Val<::glam::U16Vec2> = ::glam::DVec2::as_u16vec2(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec2(_self: Ref) -> Val { - let output: Val = bevy::math::DVec2::as_u64vec2(&_self) - .into(); + fn as_u64vec2(_self: Ref<::glam::DVec2>) -> Val<::glam::U64Vec2> { + let output: Val<::glam::U64Vec2> = ::glam::DVec2::as_u64vec2(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec2(_self: Ref) -> Val { - let output: Val = bevy::math::DVec2::as_u8vec2(&_self) - .into(); + fn as_u8vec2(_self: Ref<::glam::DVec2>) -> Val<::glam::U8Vec2> { + let output: Val<::glam::U8Vec2> = ::glam::DVec2::as_u8vec2(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec2(_self: Ref) -> Val { - let output: Val = bevy::math::DVec2::as_uvec2(&_self).into(); + fn as_uvec2(_self: Ref<::glam::DVec2>) -> Val<::glam::UVec2> { + let output: Val<::glam::UVec2> = ::glam::DVec2::as_uvec2(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec2(_self: Ref) -> Val { - let output: Val = bevy::math::DVec2::as_vec2(&_self).into(); + fn as_vec2(_self: Ref<::glam::DVec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::DVec2::as_vec2(&_self).into(); output } /// Returns a vector containing the smallest integer greater than or equal to a number for /// each element of `self`. - fn ceil(_self: Val) -> Val { - let output: Val = bevy::math::DVec2::ceil(_self.into_inner()) - .into(); + fn ceil(_self: Val<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::ceil(_self.into_inner()).into(); output } /// Component-wise clamping of values, similar to [`f64::clamp`]. @@ -21981,11 +20326,11 @@ impl bevy::math::DVec2 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::DVec2::clamp( + _self: Val<::glam::DVec2>, + min: Val<::glam::DVec2>, + max: Val<::glam::DVec2>, + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -21997,11 +20342,11 @@ impl bevy::math::DVec2 { /// # Panics /// Will panic if `min` is greater than `max`, or if either `min` or `max` is negative, when `glam_assert` is enabled. fn clamp_length( - _self: Val, + _self: Val<::glam::DVec2>, min: f64, max: f64, - ) -> Val { - let output: Val = bevy::math::DVec2::clamp_length( + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::clamp_length( _self.into_inner(), min, max, @@ -22012,11 +20357,8 @@ impl bevy::math::DVec2 { /// Returns a vector with a length no more than `max`. /// # Panics /// Will panic if `max` is negative when `glam_assert` is enabled. - fn clamp_length_max( - _self: Val, - max: f64, - ) -> Val { - let output: Val = bevy::math::DVec2::clamp_length_max( + fn clamp_length_max(_self: Val<::glam::DVec2>, max: f64) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::clamp_length_max( _self.into_inner(), max, ) @@ -22026,19 +20368,16 @@ impl bevy::math::DVec2 { /// Returns a vector with a length no less than `min`. /// # Panics /// Will panic if `min` is negative when `glam_assert` is enabled. - fn clamp_length_min( - _self: Val, - min: f64, - ) -> Val { - let output: Val = bevy::math::DVec2::clamp_length_min( + fn clamp_length_min(_self: Val<::glam::DVec2>, min: f64) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::clamp_length_min( _self.into_inner(), min, ) .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -22048,11 +20387,8 @@ impl bevy::math::DVec2 { /// `self` and `rhs`. /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. - fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec2::cmpeq( + fn cmpeq(_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::DVec2::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -22063,11 +20399,8 @@ impl bevy::math::DVec2 { /// `self` and `rhs`. /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. - fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec2::cmpge( + fn cmpge(_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::DVec2::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -22078,11 +20411,8 @@ impl bevy::math::DVec2 { /// `self` and `rhs`. /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. - fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec2::cmpgt( + fn cmpgt(_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::DVec2::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -22093,11 +20423,8 @@ impl bevy::math::DVec2 { /// `self` and `rhs`. /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. - fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec2::cmple( + fn cmple(_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::DVec2::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -22108,11 +20435,8 @@ impl bevy::math::DVec2 { /// `self` and `rhs`. /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. - fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec2::cmplt( + fn cmplt(_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::DVec2::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -22123,11 +20447,8 @@ impl bevy::math::DVec2 { /// `self` and `rhs`. /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. - fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec2::cmpne( + fn cmpne(_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::DVec2::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -22136,10 +20457,10 @@ impl bevy::math::DVec2 { } /// Returns a vector with signs of `rhs` and the magnitudes of `self`. fn copysign( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec2::copysign( + _self: Val<::glam::DVec2>, + rhs: Val<::glam::DVec2>, + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::copysign( _self.into_inner(), rhs.into_inner(), ) @@ -22147,48 +20468,36 @@ impl bevy::math::DVec2 { output } /// Computes the Euclidean distance between two points in space. - fn distance(_self: Val, rhs: Val) -> f64 { - let output: f64 = bevy::math::DVec2::distance( - _self.into_inner(), - rhs.into_inner(), - ) + fn distance(_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>) -> f64 { + let output: f64 = ::glam::DVec2::distance(_self.into_inner(), rhs.into_inner()) .into(); output } /// Compute the squared euclidean distance between two points in space. - fn distance_squared( - _self: Val, - rhs: Val, - ) -> f64 { - let output: f64 = bevy::math::DVec2::distance_squared( + fn distance_squared(_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>) -> f64 { + let output: f64 = ::glam::DVec2::distance_squared( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Div< + &::glam::DVec2, >>::div(_self.into_inner(), &rhs) .into(); output } - fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Div< + ::glam::DVec2, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: f64) -> Val { - let output: Val = , rhs: f64) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Div< f64, >>::div(_self.into_inner(), rhs) .into(); @@ -22196,10 +20505,10 @@ impl bevy::math::DVec2 { } /// Returns the element-wise quotient of [Euclidean division] of `self` by `rhs`. fn div_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec2::div_euclid( + _self: Val<::glam::DVec2>, + rhs: Val<::glam::DVec2>, + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -22207,17 +20516,17 @@ impl bevy::math::DVec2 { output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> f64 { - let output: f64 = bevy::math::DVec2::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>) -> f64 { + let output: f64 = ::glam::DVec2::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec2::dot_into_vec( + _self: Val<::glam::DVec2>, + rhs: Val<::glam::DVec2>, + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -22226,63 +20535,55 @@ impl bevy::math::DVec2 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> f64 { - let output: f64 = bevy::math::DVec2::element_product(_self.into_inner()).into(); + fn element_product(_self: Val<::glam::DVec2>) -> f64 { + let output: f64 = ::glam::DVec2::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> f64 { - let output: f64 = bevy::math::DVec2::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::DVec2>) -> f64 { + let output: f64 = ::glam::DVec2::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::DVec2>) -> bool { + let output: bool = <::glam::DVec2 as ::core::cmp::PartialEq< + ::glam::DVec2, >>::eq(&_self, &other) .into(); output } /// Returns a vector containing `e^self` (the exponential function) for each element of /// `self`. - fn exp(_self: Val) -> Val { - let output: Val = bevy::math::DVec2::exp(_self.into_inner()) - .into(); + fn exp(_self: Val<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::exp(_self.into_inner()).into(); output } /// Creates a 3D vector from `self` and the given `z` value. - fn extend(_self: Val, z: f64) -> Val { - let output: Val = bevy::math::DVec2::extend( - _self.into_inner(), - z, - ) + fn extend(_self: Val<::glam::DVec2>, z: f64) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec2::extend(_self.into_inner(), z) .into(); output } /// Returns a vector containing the largest integer less than or equal to a number for each /// element of `self`. - fn floor(_self: Val) -> Val { - let output: Val = bevy::math::DVec2::floor(_self.into_inner()) - .into(); + fn floor(_self: Val<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::floor(_self.into_inner()).into(); output } /// Returns a vector containing the fractional part of the vector as `self - self.trunc()`. /// Note that this differs from the GLSL implementation of `fract` which returns /// `self - self.floor()`. /// Note that this is fast but not precise for large numbers. - fn fract(_self: Val) -> Val { - let output: Val = bevy::math::DVec2::fract(_self.into_inner()) - .into(); + fn fract(_self: Val<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::fract(_self.into_inner()).into(); output } /// Returns a vector containing the fractional part of the vector as `self - self.floor()`. /// Note that this differs from the Rust implementation of `fract` which returns /// `self - self.trunc()`. /// Note that this is fast but not precise for large numbers. - fn fract_gl(_self: Val) -> Val { - let output: Val = bevy::math::DVec2::fract_gl( - _self.into_inner(), - ) + fn fract_gl(_self: Val<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::fract_gl(_self.into_inner()) .into(); output } @@ -22290,73 +20591,70 @@ impl bevy::math::DVec2 { /// conjunction with the [`rotate()`][Self::rotate()] method, e.g. /// `DVec2::from_angle(PI).rotate(DVec2::Y)` will create the vector `[-1, 0]` /// and rotate [`DVec2::Y`] around it returning `-DVec2::Y`. - fn from_angle(angle: f64) -> Val { - let output: Val = bevy::math::DVec2::from_angle(angle).into(); + fn from_angle(angle: f64) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::from_angle(angle).into(); output } /// Creates a new vector from an array. - fn from_array(a: [f64; 2]) -> Val { - let output: Val = bevy::math::DVec2::from_array(a).into(); + fn from_array(a: [f64; 2]) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::from_array(a).into(); output } /// Returns `true` if, and only if, all elements are finite. If any element is either /// `NaN`, positive or negative infinity, this will return `false`. - fn is_finite(_self: Val) -> bool { - let output: bool = bevy::math::DVec2::is_finite(_self.into_inner()).into(); + fn is_finite(_self: Val<::glam::DVec2>) -> bool { + let output: bool = ::glam::DVec2::is_finite(_self.into_inner()).into(); output } /// Performs `is_finite` on each element of self, returning a vector mask of the results. /// In other words, this computes `[x.is_finite(), y.is_finite(), ...]`. - fn is_finite_mask(_self: Val) -> Val { - let output: Val = bevy::math::DVec2::is_finite_mask( + fn is_finite_mask(_self: Val<::glam::DVec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::DVec2::is_finite_mask( _self.into_inner(), ) .into(); output } /// Returns `true` if any elements are `NaN`. - fn is_nan(_self: Val) -> bool { - let output: bool = bevy::math::DVec2::is_nan(_self.into_inner()).into(); + fn is_nan(_self: Val<::glam::DVec2>) -> bool { + let output: bool = ::glam::DVec2::is_nan(_self.into_inner()).into(); output } /// Performs `is_nan` on each element of self, returning a vector mask of the results. /// In other words, this computes `[x.is_nan(), y.is_nan(), ...]`. - fn is_nan_mask(_self: Val) -> Val { - let output: Val = bevy::math::DVec2::is_nan_mask( - _self.into_inner(), - ) + fn is_nan_mask(_self: Val<::glam::DVec2>) -> Val<::glam::BVec2> { + let output: Val<::glam::BVec2> = ::glam::DVec2::is_nan_mask(_self.into_inner()) .into(); output } /// Returns a bitmask with the lowest 2 bits set to the sign bits from the elements of `self`. /// A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn is_negative_bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::DVec2::is_negative_bitmask(_self.into_inner()) - .into(); + fn is_negative_bitmask(_self: Val<::glam::DVec2>) -> u32 { + let output: u32 = ::glam::DVec2::is_negative_bitmask(_self.into_inner()).into(); output } /// Returns whether `self` is length `1.0` or not. /// Uses a precision threshold of approximately `1e-4`. - fn is_normalized(_self: Val) -> bool { - let output: bool = bevy::math::DVec2::is_normalized(_self.into_inner()).into(); + fn is_normalized(_self: Val<::glam::DVec2>) -> bool { + let output: bool = ::glam::DVec2::is_normalized(_self.into_inner()).into(); output } /// Computes the length of `self`. - fn length(_self: Val) -> f64 { - let output: f64 = bevy::math::DVec2::length(_self.into_inner()).into(); + fn length(_self: Val<::glam::DVec2>) -> f64 { + let output: f64 = ::glam::DVec2::length(_self.into_inner()).into(); output } /// Computes `1.0 / length()`. /// For valid results, `self` must _not_ be of length zero. - fn length_recip(_self: Val) -> f64 { - let output: f64 = bevy::math::DVec2::length_recip(_self.into_inner()).into(); + fn length_recip(_self: Val<::glam::DVec2>) -> f64 { + let output: f64 = ::glam::DVec2::length_recip(_self.into_inner()).into(); output } /// Computes the squared length of `self`. /// This is faster than `length()` as it avoids a square root operation. - fn length_squared(_self: Val) -> f64 { - let output: f64 = bevy::math::DVec2::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::DVec2>) -> f64 { + let output: f64 = ::glam::DVec2::length_squared(_self.into_inner()).into(); output } /// Performs a linear interpolation between `self` and `rhs` based on the value `s`. @@ -22364,11 +20662,11 @@ impl bevy::math::DVec2 { /// will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly /// extrapolated. fn lerp( - _self: Val, - rhs: Val, + _self: Val<::glam::DVec2>, + rhs: Val<::glam::DVec2>, s: f64, - ) -> Val { - let output: Val = bevy::math::DVec2::lerp( + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::lerp( _self.into_inner(), rhs.into_inner(), s, @@ -22378,11 +20676,8 @@ impl bevy::math::DVec2 { } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. - fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec2::max( + fn max(_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::max( _self.into_inner(), rhs.into_inner(), ) @@ -22391,8 +20686,8 @@ impl bevy::math::DVec2 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> f64 { - let output: f64 = bevy::math::DVec2::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::DVec2>) -> f64 { + let output: f64 = ::glam::DVec2::max_element(_self.into_inner()).into(); output } /// Calculates the midpoint between `self` and `rhs`. @@ -22400,10 +20695,10 @@ impl bevy::math::DVec2 { /// `a.midpoint(b)` should yield the same result as `a.lerp(b, 0.5)` /// while being slightly cheaper to compute. fn midpoint( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec2::midpoint( + _self: Val<::glam::DVec2>, + rhs: Val<::glam::DVec2>, + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::midpoint( _self.into_inner(), rhs.into_inner(), ) @@ -22412,11 +20707,8 @@ impl bevy::math::DVec2 { } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. - fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec2::min( + fn min(_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::min( _self.into_inner(), rhs.into_inner(), ) @@ -22425,19 +20717,19 @@ impl bevy::math::DVec2 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> f64 { - let output: f64 = bevy::math::DVec2::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::DVec2>) -> f64 { + let output: f64 = ::glam::DVec2::min_element(_self.into_inner()).into(); output } /// Moves towards `rhs` based on the value `d`. /// When `d` is `0.0`, the result will be equal to `self`. When `d` is equal to /// `self.distance(rhs)`, the result will be equal to `rhs`. Will not go past `rhs`. fn move_towards( - _self: Ref, - rhs: Val, + _self: Ref<::glam::DVec2>, + rhs: Val<::glam::DVec2>, d: f64, - ) -> Val { - let output: Val = bevy::math::DVec2::move_towards( + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::move_towards( &_self, rhs.into_inner(), d, @@ -22445,28 +20737,22 @@ impl bevy::math::DVec2 { .into(); output } - fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Mul< + &::glam::DVec2, >>::mul(_self.into_inner(), &rhs) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Mul< + ::glam::DVec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: f64) -> Val { - let output: Val = , rhs: f64) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Mul< f64, >>::mul(_self.into_inner(), rhs) .into(); @@ -22479,11 +20765,11 @@ impl bevy::math::DVec2 { /// and will be heavily dependant on designing algorithms with specific target hardware in /// mind. fn mul_add( - _self: Val, - a: Val, - b: Val, - ) -> Val { - let output: Val = bevy::math::DVec2::mul_add( + _self: Val<::glam::DVec2>, + a: Val<::glam::DVec2>, + b: Val<::glam::DVec2>, + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::mul_add( _self.into_inner(), a.into_inner(), b.into_inner(), @@ -22491,16 +20777,16 @@ impl bevy::math::DVec2 { .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); output } /// Creates a new vector. - fn new(x: f64, y: f64) -> Val { - let output: Val = bevy::math::DVec2::new(x, y).into(); + fn new(x: f64, y: f64) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::new(x, y).into(); output } /// Returns `self` normalized to length 1.0. @@ -22508,10 +20794,8 @@ impl bevy::math::DVec2 { /// See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`]. /// Panics /// Will panic if the resulting normalized vector is not finite when `glam_assert` is enabled. - fn normalize(_self: Val) -> Val { - let output: Val = bevy::math::DVec2::normalize( - _self.into_inner(), - ) + fn normalize(_self: Val<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::normalize(_self.into_inner()) .into(); output } @@ -22521,10 +20805,10 @@ impl bevy::math::DVec2 { /// the result of this operation will be the fallback value. /// See also [`Self::try_normalize()`]. fn normalize_or( - _self: Val, - fallback: Val, - ) -> Val { - let output: Val = bevy::math::DVec2::normalize_or( + _self: Val<::glam::DVec2>, + fallback: Val<::glam::DVec2>, + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::normalize_or( _self.into_inner(), fallback.into_inner(), ) @@ -22535,35 +20819,28 @@ impl bevy::math::DVec2 { /// In particular, if the input is zero (or very close to zero), or non-finite, /// the result of this operation will be zero. /// See also [`Self::try_normalize()`]. - fn normalize_or_zero(_self: Val) -> Val { - let output: Val = bevy::math::DVec2::normalize_or_zero( + fn normalize_or_zero(_self: Val<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::normalize_or_zero( _self.into_inner(), ) .into(); output } /// Returns a vector that is equal to `self` rotated by 90 degrees. - fn perp(_self: Val) -> Val { - let output: Val = bevy::math::DVec2::perp(_self.into_inner()) - .into(); + fn perp(_self: Val<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::perp(_self.into_inner()).into(); output } /// The perpendicular dot product of `self` and `rhs`. /// Also known as the wedge product, 2D cross product, and determinant. - fn perp_dot(_self: Val, rhs: Val) -> f64 { - let output: f64 = bevy::math::DVec2::perp_dot( - _self.into_inner(), - rhs.into_inner(), - ) + fn perp_dot(_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>) -> f64 { + let output: f64 = ::glam::DVec2::perp_dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector containing each element of `self` raised to the power of `n`. - fn powf(_self: Val, n: f64) -> Val { - let output: Val = bevy::math::DVec2::powf( - _self.into_inner(), - n, - ) + fn powf(_self: Val<::glam::DVec2>, n: f64) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::powf(_self.into_inner(), n) .into(); output } @@ -22572,10 +20849,10 @@ impl bevy::math::DVec2 { /// # Panics /// Will panic if `rhs` is zero length when `glam_assert` is enabled. fn project_onto( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec2::project_onto( + _self: Val<::glam::DVec2>, + rhs: Val<::glam::DVec2>, + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::project_onto( _self.into_inner(), rhs.into_inner(), ) @@ -22587,10 +20864,10 @@ impl bevy::math::DVec2 { /// # Panics /// Will panic if `rhs` is not normalized when `glam_assert` is enabled. fn project_onto_normalized( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec2::project_onto_normalized( + _self: Val<::glam::DVec2>, + rhs: Val<::glam::DVec2>, + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::project_onto_normalized( _self.into_inner(), rhs.into_inner(), ) @@ -22598,9 +20875,8 @@ impl bevy::math::DVec2 { output } /// Returns a vector containing the reciprocal `1.0/n` of each element of `self`. - fn recip(_self: Val) -> Val { - let output: Val = bevy::math::DVec2::recip(_self.into_inner()) - .into(); + fn recip(_self: Val<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::recip(_self.into_inner()).into(); output } /// Returns the reflection vector for a given incident vector `self` and surface normal @@ -22609,10 +20885,10 @@ impl bevy::math::DVec2 { /// # Panics /// Will panic if `normal` is not normalized when `glam_assert` is enabled. fn reflect( - _self: Val, - normal: Val, - ) -> Val { - let output: Val = bevy::math::DVec2::reflect( + _self: Val<::glam::DVec2>, + normal: Val<::glam::DVec2>, + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::reflect( _self.into_inner(), normal.into_inner(), ) @@ -22626,11 +20902,11 @@ impl bevy::math::DVec2 { /// # Panics /// Will panic if `self` or `normal` is not normalized when `glam_assert` is enabled. fn refract( - _self: Val, - normal: Val, + _self: Val<::glam::DVec2>, + normal: Val<::glam::DVec2>, eta: f64, - ) -> Val { - let output: Val = bevy::math::DVec2::refract( + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::refract( _self.into_inner(), normal.into_inner(), eta, @@ -22645,10 +20921,10 @@ impl bevy::math::DVec2 { /// # Panics /// Will panic if `rhs` has a length of zero when `glam_assert` is enabled. fn reject_from( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec2::reject_from( + _self: Val<::glam::DVec2>, + rhs: Val<::glam::DVec2>, + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::reject_from( _self.into_inner(), rhs.into_inner(), ) @@ -22662,38 +20938,32 @@ impl bevy::math::DVec2 { /// # Panics /// Will panic if `rhs` is not normalized when `glam_assert` is enabled. fn reject_from_normalized( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec2::reject_from_normalized( + _self: Val<::glam::DVec2>, + rhs: Val<::glam::DVec2>, + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::reject_from_normalized( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Rem< + &::glam::DVec2, >>::rem(_self.into_inner(), &rhs) .into(); output } - fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Rem< + ::glam::DVec2, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: f64) -> Val { - let output: Val = , rhs: f64) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Rem< f64, >>::rem(_self.into_inner(), rhs) .into(); @@ -22702,10 +20972,10 @@ impl bevy::math::DVec2 { /// Returns the element-wise remainder of [Euclidean division] of `self` by `rhs`. /// [Euclidean division]: f64::rem_euclid fn rem_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec2::rem_euclid( + _self: Val<::glam::DVec2>, + rhs: Val<::glam::DVec2>, + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::rem_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -22715,11 +20985,8 @@ impl bevy::math::DVec2 { /// Returns `rhs` rotated by the angle of `self`. If `self` is normalized, /// then this just rotation. This is what you usually want. Otherwise, /// it will be like a rotation with a multiplication by `self`'s length. - fn rotate( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec2::rotate( + fn rotate(_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::rotate( _self.into_inner(), rhs.into_inner(), ) @@ -22731,11 +20998,11 @@ impl bevy::math::DVec2 { /// `self.angle_between(rhs)`, the result will be equal to `rhs`. If `max_angle` is negative, /// rotates towards the exact opposite of `rhs`. Will not go past the target. fn rotate_towards( - _self: Ref, - rhs: Val, + _self: Ref<::glam::DVec2>, + rhs: Val<::glam::DVec2>, max_angle: f64, - ) -> Val { - let output: Val = bevy::math::DVec2::rotate_towards( + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::rotate_towards( &_self, rhs.into_inner(), max_angle, @@ -22745,9 +21012,8 @@ impl bevy::math::DVec2 { } /// Returns a vector containing the nearest integer to a number for each element of `self`. /// Round half-way cases away from 0.0. - fn round(_self: Val) -> Val { - let output: Val = bevy::math::DVec2::round(_self.into_inner()) - .into(); + fn round(_self: Val<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::round(_self.into_inner()).into(); output } /// Creates a vector from the elements in `if_true` and `if_false`, selecting which to use @@ -22755,11 +21021,11 @@ impl bevy::math::DVec2 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::DVec2::select( + mask: Val<::glam::BVec2>, + if_true: Val<::glam::DVec2>, + if_false: Val<::glam::DVec2>, + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -22771,40 +21037,32 @@ impl bevy::math::DVec2 { /// - `1.0` if the number is positive, `+0.0` or `INFINITY` /// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY` /// - `NAN` if the number is `NAN` - fn signum(_self: Val) -> Val { - let output: Val = bevy::math::DVec2::signum( - _self.into_inner(), - ) + fn signum(_self: Val<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::signum(_self.into_inner()) .into(); output } /// Creates a vector with all elements set to `v`. - fn splat(v: f64) -> Val { - let output: Val = bevy::math::DVec2::splat(v).into(); + fn splat(v: f64) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::splat(v).into(); output } - fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Sub< + &::glam::DVec2, >>::sub(_self.into_inner(), &rhs) .into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Sub< + ::glam::DVec2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: f64) -> Val { - let output: Val = , rhs: f64) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = <::glam::DVec2 as ::core::ops::Sub< f64, >>::sub(_self.into_inner(), rhs) .into(); @@ -22812,37 +21070,30 @@ impl bevy::math::DVec2 { } /// Returns the angle (in radians) of this vector in the range `[-Ï€, +Ï€]`. /// The input does not need to be a unit vector however it must be non-zero. - fn to_angle(_self: Val) -> f64 { - let output: f64 = bevy::math::DVec2::to_angle(_self.into_inner()).into(); + fn to_angle(_self: Val<::glam::DVec2>) -> f64 { + let output: f64 = ::glam::DVec2::to_angle(_self.into_inner()).into(); output } /// `[x, y]` - fn to_array(_self: Ref) -> [f64; 2] { - let output: [f64; 2] = bevy::math::DVec2::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::DVec2>) -> [f64; 2] { + let output: [f64; 2] = ::glam::DVec2::to_array(&_self).into(); output } /// Returns a vector containing the integer part each element of `self`. This means numbers are /// always truncated towards zero. - fn trunc(_self: Val) -> Val { - let output: Val = bevy::math::DVec2::trunc(_self.into_inner()) - .into(); + fn trunc(_self: Val<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::trunc(_self.into_inner()).into(); output } /// Creates a 2D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: f64) -> Val { - let output: Val = bevy::math::DVec2::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::DVec2>, x: f64) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::with_x(_self.into_inner(), x) .into(); output } /// Creates a 2D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: f64) -> Val { - let output: Val = bevy::math::DVec2::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::DVec2>, y: f64) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec2::with_y(_self.into_inner(), y) .into(); output } @@ -22853,11 +21104,10 @@ impl bevy::math::DVec2 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::DVec3 { +impl ::glam::DVec3 { /// Returns a vector containing the absolute value of each element of `self`. - fn abs(_self: Val) -> Val { - let output: Val = bevy::math::DVec3::abs(_self.into_inner()) - .into(); + fn abs(_self: Val<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::abs(_self.into_inner()).into(); output } /// Returns true if the absolute difference of all elements between `self` and `rhs` is @@ -22868,11 +21118,11 @@ impl bevy::math::DVec3 { /// For more see /// [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/). fn abs_diff_eq( - _self: Val, - rhs: Val, + _self: Val<::glam::DVec3>, + rhs: Val<::glam::DVec3>, max_abs_diff: f64, ) -> bool { - let output: bool = bevy::math::DVec3::abs_diff_eq( + let output: bool = ::glam::DVec3::abs_diff_eq( _self.into_inner(), rhs.into_inner(), max_abs_diff, @@ -22880,28 +21130,22 @@ impl bevy::math::DVec3 { .into(); output } - fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Add< + &::glam::DVec3, >>::add(_self.into_inner(), &rhs) .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Add< + ::glam::DVec3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: f64) -> Val { - let output: Val = , rhs: f64) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Add< f64, >>::add(_self.into_inner(), rhs) .into(); @@ -22909,8 +21153,8 @@ impl bevy::math::DVec3 { } /// Returns the angle (in radians) between two vectors in the range `[0, +Ï€]`. /// The inputs do not need to be unit vectors however they must be non-zero. - fn angle_between(_self: Val, rhs: Val) -> f64 { - let output: f64 = bevy::math::DVec3::angle_between( + fn angle_between(_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>) -> f64 { + let output: f64 = ::glam::DVec3::angle_between( _self.into_inner(), rhs.into_inner(), ) @@ -22921,10 +21165,8 @@ impl bevy::math::DVec3 { /// The input vector must be finite and non-zero. /// The output vector is not necessarily unit length. For that use /// [`Self::any_orthonormal_vector()`] instead. - fn any_orthogonal_vector(_self: Ref) -> Val { - let output: Val = bevy::math::DVec3::any_orthogonal_vector( - &_self, - ) + fn any_orthogonal_vector(_self: Ref<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::any_orthogonal_vector(&_self) .into(); output } @@ -22932,74 +21174,65 @@ impl bevy::math::DVec3 { /// The input vector must be unit length. /// # Panics /// Will panic if `self` is not normalized when `glam_assert` is enabled. - fn any_orthonormal_vector(_self: Ref) -> Val { - let output: Val = bevy::math::DVec3::any_orthonormal_vector( - &_self, - ) + fn any_orthonormal_vector(_self: Ref<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::any_orthonormal_vector(&_self) .into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec3(_self: Ref) -> Val { - let output: Val = bevy::math::DVec3::as_i16vec3(&_self) - .into(); + fn as_i16vec3(_self: Ref<::glam::DVec3>) -> Val<::glam::I16Vec3> { + let output: Val<::glam::I16Vec3> = ::glam::DVec3::as_i16vec3(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec3(_self: Ref) -> Val { - let output: Val = bevy::math::DVec3::as_i64vec3(&_self) - .into(); + fn as_i64vec3(_self: Ref<::glam::DVec3>) -> Val<::glam::I64Vec3> { + let output: Val<::glam::I64Vec3> = ::glam::DVec3::as_i64vec3(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec3(_self: Ref) -> Val { - let output: Val = bevy::math::DVec3::as_i8vec3(&_self) - .into(); + fn as_i8vec3(_self: Ref<::glam::DVec3>) -> Val<::glam::I8Vec3> { + let output: Val<::glam::I8Vec3> = ::glam::DVec3::as_i8vec3(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec3(_self: Ref) -> Val { - let output: Val = bevy::math::DVec3::as_ivec3(&_self).into(); + fn as_ivec3(_self: Ref<::glam::DVec3>) -> Val<::glam::IVec3> { + let output: Val<::glam::IVec3> = ::glam::DVec3::as_ivec3(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec3(_self: Ref) -> Val { - let output: Val = bevy::math::DVec3::as_u16vec3(&_self) - .into(); + fn as_u16vec3(_self: Ref<::glam::DVec3>) -> Val<::glam::U16Vec3> { + let output: Val<::glam::U16Vec3> = ::glam::DVec3::as_u16vec3(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec3(_self: Ref) -> Val { - let output: Val = bevy::math::DVec3::as_u64vec3(&_self) - .into(); + fn as_u64vec3(_self: Ref<::glam::DVec3>) -> Val<::glam::U64Vec3> { + let output: Val<::glam::U64Vec3> = ::glam::DVec3::as_u64vec3(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec3(_self: Ref) -> Val { - let output: Val = bevy::math::DVec3::as_u8vec3(&_self) - .into(); + fn as_u8vec3(_self: Ref<::glam::DVec3>) -> Val<::glam::U8Vec3> { + let output: Val<::glam::U8Vec3> = ::glam::DVec3::as_u8vec3(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec3(_self: Ref) -> Val { - let output: Val = bevy::math::DVec3::as_uvec3(&_self).into(); + fn as_uvec3(_self: Ref<::glam::DVec3>) -> Val<::glam::UVec3> { + let output: Val<::glam::UVec3> = ::glam::DVec3::as_uvec3(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec3(_self: Ref) -> Val { - let output: Val = bevy::math::DVec3::as_vec3(&_self).into(); + fn as_vec3(_self: Ref<::glam::DVec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::DVec3::as_vec3(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec3a(_self: Ref) -> Val { - let output: Val = bevy::math::DVec3::as_vec3a(&_self).into(); + fn as_vec3a(_self: Ref<::glam::DVec3>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::DVec3::as_vec3a(&_self).into(); output } /// Returns a vector containing the smallest integer greater than or equal to a number for /// each element of `self`. - fn ceil(_self: Val) -> Val { - let output: Val = bevy::math::DVec3::ceil(_self.into_inner()) - .into(); + fn ceil(_self: Val<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::ceil(_self.into_inner()).into(); output } /// Component-wise clamping of values, similar to [`f64::clamp`]. @@ -23007,11 +21240,11 @@ impl bevy::math::DVec3 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::DVec3::clamp( + _self: Val<::glam::DVec3>, + min: Val<::glam::DVec3>, + max: Val<::glam::DVec3>, + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -23023,11 +21256,11 @@ impl bevy::math::DVec3 { /// # Panics /// Will panic if `min` is greater than `max`, or if either `min` or `max` is negative, when `glam_assert` is enabled. fn clamp_length( - _self: Val, + _self: Val<::glam::DVec3>, min: f64, max: f64, - ) -> Val { - let output: Val = bevy::math::DVec3::clamp_length( + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::clamp_length( _self.into_inner(), min, max, @@ -23038,11 +21271,8 @@ impl bevy::math::DVec3 { /// Returns a vector with a length no more than `max`. /// # Panics /// Will panic if `max` is negative when `glam_assert` is enabled. - fn clamp_length_max( - _self: Val, - max: f64, - ) -> Val { - let output: Val = bevy::math::DVec3::clamp_length_max( + fn clamp_length_max(_self: Val<::glam::DVec3>, max: f64) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::clamp_length_max( _self.into_inner(), max, ) @@ -23052,19 +21282,16 @@ impl bevy::math::DVec3 { /// Returns a vector with a length no less than `min`. /// # Panics /// Will panic if `min` is negative when `glam_assert` is enabled. - fn clamp_length_min( - _self: Val, - min: f64, - ) -> Val { - let output: Val = bevy::math::DVec3::clamp_length_min( + fn clamp_length_min(_self: Val<::glam::DVec3>, min: f64) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::clamp_length_min( _self.into_inner(), min, ) .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -23074,11 +21301,8 @@ impl bevy::math::DVec3 { /// `self` and `rhs`. /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. - fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec3::cmpeq( + fn cmpeq(_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::DVec3::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -23089,11 +21313,8 @@ impl bevy::math::DVec3 { /// `self` and `rhs`. /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. - fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec3::cmpge( + fn cmpge(_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::DVec3::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -23104,11 +21325,8 @@ impl bevy::math::DVec3 { /// `self` and `rhs`. /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. - fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec3::cmpgt( + fn cmpgt(_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::DVec3::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -23119,11 +21337,8 @@ impl bevy::math::DVec3 { /// `self` and `rhs`. /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. - fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec3::cmple( + fn cmple(_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::DVec3::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -23134,11 +21349,8 @@ impl bevy::math::DVec3 { /// `self` and `rhs`. /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. - fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec3::cmplt( + fn cmplt(_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::DVec3::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -23149,11 +21361,8 @@ impl bevy::math::DVec3 { /// `self` and `rhs`. /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. - fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec3::cmpne( + fn cmpne(_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::DVec3::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -23162,10 +21371,10 @@ impl bevy::math::DVec3 { } /// Returns a vector with signs of `rhs` and the magnitudes of `self`. fn copysign( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec3::copysign( + _self: Val<::glam::DVec3>, + rhs: Val<::glam::DVec3>, + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::copysign( _self.into_inner(), rhs.into_inner(), ) @@ -23173,11 +21382,8 @@ impl bevy::math::DVec3 { output } /// Computes the cross product of `self` and `rhs`. - fn cross( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec3::cross( + fn cross(_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::cross( _self.into_inner(), rhs.into_inner(), ) @@ -23185,48 +21391,36 @@ impl bevy::math::DVec3 { output } /// Computes the Euclidean distance between two points in space. - fn distance(_self: Val, rhs: Val) -> f64 { - let output: f64 = bevy::math::DVec3::distance( - _self.into_inner(), - rhs.into_inner(), - ) + fn distance(_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>) -> f64 { + let output: f64 = ::glam::DVec3::distance(_self.into_inner(), rhs.into_inner()) .into(); output } /// Compute the squared euclidean distance between two points in space. - fn distance_squared( - _self: Val, - rhs: Val, - ) -> f64 { - let output: f64 = bevy::math::DVec3::distance_squared( + fn distance_squared(_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>) -> f64 { + let output: f64 = ::glam::DVec3::distance_squared( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Div< + &::glam::DVec3, >>::div(_self.into_inner(), &rhs) .into(); output } - fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Div< + ::glam::DVec3, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: f64) -> Val { - let output: Val = , rhs: f64) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Div< f64, >>::div(_self.into_inner(), rhs) .into(); @@ -23234,10 +21428,10 @@ impl bevy::math::DVec3 { } /// Returns the element-wise quotient of [Euclidean division] of `self` by `rhs`. fn div_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec3::div_euclid( + _self: Val<::glam::DVec3>, + rhs: Val<::glam::DVec3>, + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -23245,17 +21439,17 @@ impl bevy::math::DVec3 { output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> f64 { - let output: f64 = bevy::math::DVec3::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>) -> f64 { + let output: f64 = ::glam::DVec3::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec3::dot_into_vec( + _self: Val<::glam::DVec3>, + rhs: Val<::glam::DVec3>, + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -23264,129 +21458,118 @@ impl bevy::math::DVec3 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> f64 { - let output: f64 = bevy::math::DVec3::element_product(_self.into_inner()).into(); + fn element_product(_self: Val<::glam::DVec3>) -> f64 { + let output: f64 = ::glam::DVec3::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> f64 { - let output: f64 = bevy::math::DVec3::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::DVec3>) -> f64 { + let output: f64 = ::glam::DVec3::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::DVec3>) -> bool { + let output: bool = <::glam::DVec3 as ::core::cmp::PartialEq< + ::glam::DVec3, >>::eq(&_self, &other) .into(); output } /// Returns a vector containing `e^self` (the exponential function) for each element of /// `self`. - fn exp(_self: Val) -> Val { - let output: Val = bevy::math::DVec3::exp(_self.into_inner()) - .into(); + fn exp(_self: Val<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::exp(_self.into_inner()).into(); output } /// Creates a 4D vector from `self` and the given `w` value. - fn extend(_self: Val, w: f64) -> Val { - let output: Val = bevy::math::DVec3::extend( - _self.into_inner(), - w, - ) + fn extend(_self: Val<::glam::DVec3>, w: f64) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec3::extend(_self.into_inner(), w) .into(); output } /// Returns a vector containing the largest integer less than or equal to a number for each /// element of `self`. - fn floor(_self: Val) -> Val { - let output: Val = bevy::math::DVec3::floor(_self.into_inner()) - .into(); + fn floor(_self: Val<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::floor(_self.into_inner()).into(); output } /// Returns a vector containing the fractional part of the vector as `self - self.trunc()`. /// Note that this differs from the GLSL implementation of `fract` which returns /// `self - self.floor()`. /// Note that this is fast but not precise for large numbers. - fn fract(_self: Val) -> Val { - let output: Val = bevy::math::DVec3::fract(_self.into_inner()) - .into(); + fn fract(_self: Val<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::fract(_self.into_inner()).into(); output } /// Returns a vector containing the fractional part of the vector as `self - self.floor()`. /// Note that this differs from the Rust implementation of `fract` which returns /// `self - self.trunc()`. /// Note that this is fast but not precise for large numbers. - fn fract_gl(_self: Val) -> Val { - let output: Val = bevy::math::DVec3::fract_gl( - _self.into_inner(), - ) + fn fract_gl(_self: Val<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::fract_gl(_self.into_inner()) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [f64; 3]) -> Val { - let output: Val = bevy::math::DVec3::from_array(a).into(); + fn from_array(a: [f64; 3]) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::from_array(a).into(); output } /// Returns `true` if, and only if, all elements are finite. If any element is either /// `NaN`, positive or negative infinity, this will return `false`. - fn is_finite(_self: Val) -> bool { - let output: bool = bevy::math::DVec3::is_finite(_self.into_inner()).into(); + fn is_finite(_self: Val<::glam::DVec3>) -> bool { + let output: bool = ::glam::DVec3::is_finite(_self.into_inner()).into(); output } /// Performs `is_finite` on each element of self, returning a vector mask of the results. /// In other words, this computes `[x.is_finite(), y.is_finite(), ...]`. - fn is_finite_mask(_self: Val) -> Val { - let output: Val = bevy::math::DVec3::is_finite_mask( + fn is_finite_mask(_self: Val<::glam::DVec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::DVec3::is_finite_mask( _self.into_inner(), ) .into(); output } /// Returns `true` if any elements are `NaN`. - fn is_nan(_self: Val) -> bool { - let output: bool = bevy::math::DVec3::is_nan(_self.into_inner()).into(); + fn is_nan(_self: Val<::glam::DVec3>) -> bool { + let output: bool = ::glam::DVec3::is_nan(_self.into_inner()).into(); output } /// Performs `is_nan` on each element of self, returning a vector mask of the results. /// In other words, this computes `[x.is_nan(), y.is_nan(), ...]`. - fn is_nan_mask(_self: Val) -> Val { - let output: Val = bevy::math::DVec3::is_nan_mask( - _self.into_inner(), - ) + fn is_nan_mask(_self: Val<::glam::DVec3>) -> Val<::glam::BVec3> { + let output: Val<::glam::BVec3> = ::glam::DVec3::is_nan_mask(_self.into_inner()) .into(); output } /// Returns a bitmask with the lowest 3 bits set to the sign bits from the elements of `self`. /// A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn is_negative_bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::DVec3::is_negative_bitmask(_self.into_inner()) - .into(); + fn is_negative_bitmask(_self: Val<::glam::DVec3>) -> u32 { + let output: u32 = ::glam::DVec3::is_negative_bitmask(_self.into_inner()).into(); output } /// Returns whether `self` is length `1.0` or not. /// Uses a precision threshold of approximately `1e-4`. - fn is_normalized(_self: Val) -> bool { - let output: bool = bevy::math::DVec3::is_normalized(_self.into_inner()).into(); + fn is_normalized(_self: Val<::glam::DVec3>) -> bool { + let output: bool = ::glam::DVec3::is_normalized(_self.into_inner()).into(); output } /// Computes the length of `self`. - fn length(_self: Val) -> f64 { - let output: f64 = bevy::math::DVec3::length(_self.into_inner()).into(); + fn length(_self: Val<::glam::DVec3>) -> f64 { + let output: f64 = ::glam::DVec3::length(_self.into_inner()).into(); output } /// Computes `1.0 / length()`. /// For valid results, `self` must _not_ be of length zero. - fn length_recip(_self: Val) -> f64 { - let output: f64 = bevy::math::DVec3::length_recip(_self.into_inner()).into(); + fn length_recip(_self: Val<::glam::DVec3>) -> f64 { + let output: f64 = ::glam::DVec3::length_recip(_self.into_inner()).into(); output } /// Computes the squared length of `self`. /// This is faster than `length()` as it avoids a square root operation. - fn length_squared(_self: Val) -> f64 { - let output: f64 = bevy::math::DVec3::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::DVec3>) -> f64 { + let output: f64 = ::glam::DVec3::length_squared(_self.into_inner()).into(); output } /// Performs a linear interpolation between `self` and `rhs` based on the value `s`. @@ -23394,11 +21577,11 @@ impl bevy::math::DVec3 { /// will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly /// extrapolated. fn lerp( - _self: Val, - rhs: Val, + _self: Val<::glam::DVec3>, + rhs: Val<::glam::DVec3>, s: f64, - ) -> Val { - let output: Val = bevy::math::DVec3::lerp( + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::lerp( _self.into_inner(), rhs.into_inner(), s, @@ -23408,11 +21591,8 @@ impl bevy::math::DVec3 { } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. - fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec3::max( + fn max(_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::max( _self.into_inner(), rhs.into_inner(), ) @@ -23421,8 +21601,8 @@ impl bevy::math::DVec3 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> f64 { - let output: f64 = bevy::math::DVec3::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::DVec3>) -> f64 { + let output: f64 = ::glam::DVec3::max_element(_self.into_inner()).into(); output } /// Calculates the midpoint between `self` and `rhs`. @@ -23430,10 +21610,10 @@ impl bevy::math::DVec3 { /// `a.midpoint(b)` should yield the same result as `a.lerp(b, 0.5)` /// while being slightly cheaper to compute. fn midpoint( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec3::midpoint( + _self: Val<::glam::DVec3>, + rhs: Val<::glam::DVec3>, + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::midpoint( _self.into_inner(), rhs.into_inner(), ) @@ -23442,11 +21622,8 @@ impl bevy::math::DVec3 { } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. - fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec3::min( + fn min(_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::min( _self.into_inner(), rhs.into_inner(), ) @@ -23455,19 +21632,19 @@ impl bevy::math::DVec3 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> f64 { - let output: f64 = bevy::math::DVec3::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::DVec3>) -> f64 { + let output: f64 = ::glam::DVec3::min_element(_self.into_inner()).into(); output } /// Moves towards `rhs` based on the value `d`. /// When `d` is `0.0`, the result will be equal to `self`. When `d` is equal to /// `self.distance(rhs)`, the result will be equal to `rhs`. Will not go past `rhs`. fn move_towards( - _self: Ref, - rhs: Val, + _self: Ref<::glam::DVec3>, + rhs: Val<::glam::DVec3>, d: f64, - ) -> Val { - let output: Val = bevy::math::DVec3::move_towards( + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::move_towards( &_self, rhs.into_inner(), d, @@ -23475,28 +21652,22 @@ impl bevy::math::DVec3 { .into(); output } - fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Mul< + &::glam::DVec3, >>::mul(_self.into_inner(), &rhs) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Mul< + ::glam::DVec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: f64) -> Val { - let output: Val = , rhs: f64) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Mul< f64, >>::mul(_self.into_inner(), rhs) .into(); @@ -23509,11 +21680,11 @@ impl bevy::math::DVec3 { /// and will be heavily dependant on designing algorithms with specific target hardware in /// mind. fn mul_add( - _self: Val, - a: Val, - b: Val, - ) -> Val { - let output: Val = bevy::math::DVec3::mul_add( + _self: Val<::glam::DVec3>, + a: Val<::glam::DVec3>, + b: Val<::glam::DVec3>, + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::mul_add( _self.into_inner(), a.into_inner(), b.into_inner(), @@ -23521,16 +21692,16 @@ impl bevy::math::DVec3 { .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); output } /// Creates a new vector. - fn new(x: f64, y: f64, z: f64) -> Val { - let output: Val = bevy::math::DVec3::new(x, y, z).into(); + fn new(x: f64, y: f64, z: f64) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::new(x, y, z).into(); output } /// Returns `self` normalized to length 1.0. @@ -23538,10 +21709,8 @@ impl bevy::math::DVec3 { /// See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`]. /// Panics /// Will panic if the resulting normalized vector is not finite when `glam_assert` is enabled. - fn normalize(_self: Val) -> Val { - let output: Val = bevy::math::DVec3::normalize( - _self.into_inner(), - ) + fn normalize(_self: Val<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::normalize(_self.into_inner()) .into(); output } @@ -23551,10 +21720,10 @@ impl bevy::math::DVec3 { /// the result of this operation will be the fallback value. /// See also [`Self::try_normalize()`]. fn normalize_or( - _self: Val, - fallback: Val, - ) -> Val { - let output: Val = bevy::math::DVec3::normalize_or( + _self: Val<::glam::DVec3>, + fallback: Val<::glam::DVec3>, + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::normalize_or( _self.into_inner(), fallback.into_inner(), ) @@ -23565,19 +21734,16 @@ impl bevy::math::DVec3 { /// In particular, if the input is zero (or very close to zero), or non-finite, /// the result of this operation will be zero. /// See also [`Self::try_normalize()`]. - fn normalize_or_zero(_self: Val) -> Val { - let output: Val = bevy::math::DVec3::normalize_or_zero( + fn normalize_or_zero(_self: Val<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::normalize_or_zero( _self.into_inner(), ) .into(); output } /// Returns a vector containing each element of `self` raised to the power of `n`. - fn powf(_self: Val, n: f64) -> Val { - let output: Val = bevy::math::DVec3::powf( - _self.into_inner(), - n, - ) + fn powf(_self: Val<::glam::DVec3>, n: f64) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::powf(_self.into_inner(), n) .into(); output } @@ -23586,10 +21752,10 @@ impl bevy::math::DVec3 { /// # Panics /// Will panic if `rhs` is zero length when `glam_assert` is enabled. fn project_onto( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec3::project_onto( + _self: Val<::glam::DVec3>, + rhs: Val<::glam::DVec3>, + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::project_onto( _self.into_inner(), rhs.into_inner(), ) @@ -23601,10 +21767,10 @@ impl bevy::math::DVec3 { /// # Panics /// Will panic if `rhs` is not normalized when `glam_assert` is enabled. fn project_onto_normalized( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec3::project_onto_normalized( + _self: Val<::glam::DVec3>, + rhs: Val<::glam::DVec3>, + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::project_onto_normalized( _self.into_inner(), rhs.into_inner(), ) @@ -23612,9 +21778,8 @@ impl bevy::math::DVec3 { output } /// Returns a vector containing the reciprocal `1.0/n` of each element of `self`. - fn recip(_self: Val) -> Val { - let output: Val = bevy::math::DVec3::recip(_self.into_inner()) - .into(); + fn recip(_self: Val<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::recip(_self.into_inner()).into(); output } /// Returns the reflection vector for a given incident vector `self` and surface normal @@ -23623,10 +21788,10 @@ impl bevy::math::DVec3 { /// # Panics /// Will panic if `normal` is not normalized when `glam_assert` is enabled. fn reflect( - _self: Val, - normal: Val, - ) -> Val { - let output: Val = bevy::math::DVec3::reflect( + _self: Val<::glam::DVec3>, + normal: Val<::glam::DVec3>, + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::reflect( _self.into_inner(), normal.into_inner(), ) @@ -23640,11 +21805,11 @@ impl bevy::math::DVec3 { /// # Panics /// Will panic if `self` or `normal` is not normalized when `glam_assert` is enabled. fn refract( - _self: Val, - normal: Val, + _self: Val<::glam::DVec3>, + normal: Val<::glam::DVec3>, eta: f64, - ) -> Val { - let output: Val = bevy::math::DVec3::refract( + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::refract( _self.into_inner(), normal.into_inner(), eta, @@ -23659,10 +21824,10 @@ impl bevy::math::DVec3 { /// # Panics /// Will panic if `rhs` has a length of zero when `glam_assert` is enabled. fn reject_from( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec3::reject_from( + _self: Val<::glam::DVec3>, + rhs: Val<::glam::DVec3>, + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::reject_from( _self.into_inner(), rhs.into_inner(), ) @@ -23676,38 +21841,32 @@ impl bevy::math::DVec3 { /// # Panics /// Will panic if `rhs` is not normalized when `glam_assert` is enabled. fn reject_from_normalized( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec3::reject_from_normalized( + _self: Val<::glam::DVec3>, + rhs: Val<::glam::DVec3>, + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::reject_from_normalized( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Rem< + &::glam::DVec3, >>::rem(_self.into_inner(), &rhs) .into(); output } - fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Rem< + ::glam::DVec3, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: f64) -> Val { - let output: Val = , rhs: f64) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Rem< f64, >>::rem(_self.into_inner(), rhs) .into(); @@ -23716,10 +21875,10 @@ impl bevy::math::DVec3 { /// Returns the element-wise remainder of [Euclidean division] of `self` by `rhs`. /// [Euclidean division]: f64::rem_euclid fn rem_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec3::rem_euclid( + _self: Val<::glam::DVec3>, + rhs: Val<::glam::DVec3>, + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::rem_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -23728,9 +21887,8 @@ impl bevy::math::DVec3 { } /// Returns a vector containing the nearest integer to a number for each element of `self`. /// Round half-way cases away from 0.0. - fn round(_self: Val) -> Val { - let output: Val = bevy::math::DVec3::round(_self.into_inner()) - .into(); + fn round(_self: Val<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::round(_self.into_inner()).into(); output } /// Creates a vector from the elements in `if_true` and `if_false`, selecting which to use @@ -23738,11 +21896,11 @@ impl bevy::math::DVec3 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::DVec3::select( + mask: Val<::glam::BVec3>, + if_true: Val<::glam::DVec3>, + if_false: Val<::glam::DVec3>, + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -23754,90 +21912,70 @@ impl bevy::math::DVec3 { /// - `1.0` if the number is positive, `+0.0` or `INFINITY` /// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY` /// - `NAN` if the number is `NAN` - fn signum(_self: Val) -> Val { - let output: Val = bevy::math::DVec3::signum( - _self.into_inner(), - ) + fn signum(_self: Val<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::signum(_self.into_inner()) .into(); output } /// Creates a vector with all elements set to `v`. - fn splat(v: f64) -> Val { - let output: Val = bevy::math::DVec3::splat(v).into(); + fn splat(v: f64) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::splat(v).into(); output } - fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Sub< + &::glam::DVec3, >>::sub(_self.into_inner(), &rhs) .into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Sub< + ::glam::DVec3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: f64) -> Val { - let output: Val = , rhs: f64) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = <::glam::DVec3 as ::core::ops::Sub< f64, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y, z]` - fn to_array(_self: Ref) -> [f64; 3] { - let output: [f64; 3] = bevy::math::DVec3::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::DVec3>) -> [f64; 3] { + let output: [f64; 3] = ::glam::DVec3::to_array(&_self).into(); output } /// Returns a vector containing the integer part each element of `self`. This means numbers are /// always truncated towards zero. - fn trunc(_self: Val) -> Val { - let output: Val = bevy::math::DVec3::trunc(_self.into_inner()) - .into(); + fn trunc(_self: Val<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::trunc(_self.into_inner()).into(); output } /// Creates a 2D vector from the `x` and `y` elements of `self`, discarding `z`. /// Truncation may also be performed by using [`self.xy()`][crate::swizzles::Vec3Swizzles::xy()]. - fn truncate(_self: Val) -> Val { - let output: Val = bevy::math::DVec3::truncate( - _self.into_inner(), - ) + fn truncate(_self: Val<::glam::DVec3>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DVec3::truncate(_self.into_inner()) .into(); output } /// Creates a 3D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: f64) -> Val { - let output: Val = bevy::math::DVec3::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::DVec3>, x: f64) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::with_x(_self.into_inner(), x) .into(); output } /// Creates a 3D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: f64) -> Val { - let output: Val = bevy::math::DVec3::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::DVec3>, y: f64) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::with_y(_self.into_inner(), y) .into(); output } /// Creates a 3D vector from `self` with the given value of `z`. - fn with_z(_self: Val, z: f64) -> Val { - let output: Val = bevy::math::DVec3::with_z( - _self.into_inner(), - z, - ) + fn with_z(_self: Val<::glam::DVec3>, z: f64) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec3::with_z(_self.into_inner(), z) .into(); output } @@ -23848,11 +21986,10 @@ impl bevy::math::DVec3 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::DVec4 { +impl ::glam::DVec4 { /// Returns a vector containing the absolute value of each element of `self`. - fn abs(_self: Val) -> Val { - let output: Val = bevy::math::DVec4::abs(_self.into_inner()) - .into(); + fn abs(_self: Val<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::abs(_self.into_inner()).into(); output } /// Returns true if the absolute difference of all elements between `self` and `rhs` is @@ -23863,11 +22000,11 @@ impl bevy::math::DVec4 { /// For more see /// [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/). fn abs_diff_eq( - _self: Val, - rhs: Val, + _self: Val<::glam::DVec4>, + rhs: Val<::glam::DVec4>, max_abs_diff: f64, ) -> bool { - let output: bool = bevy::math::DVec4::abs_diff_eq( + let output: bool = ::glam::DVec4::abs_diff_eq( _self.into_inner(), rhs.into_inner(), max_abs_diff, @@ -23875,89 +22012,76 @@ impl bevy::math::DVec4 { .into(); output } - fn add( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Add< + &::glam::DVec4, >>::add(_self.into_inner(), &rhs) .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Add< + ::glam::DVec4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } - fn add(_self: Val, rhs: f64) -> Val { - let output: Val = , rhs: f64) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Add< f64, >>::add(_self.into_inner(), rhs) .into(); output } /// Casts all elements of `self` to `i16`. - fn as_i16vec4(_self: Ref) -> Val { - let output: Val = bevy::math::DVec4::as_i16vec4(&_self) - .into(); + fn as_i16vec4(_self: Ref<::glam::DVec4>) -> Val<::glam::I16Vec4> { + let output: Val<::glam::I16Vec4> = ::glam::DVec4::as_i16vec4(&_self).into(); output } /// Casts all elements of `self` to `i64`. - fn as_i64vec4(_self: Ref) -> Val { - let output: Val = bevy::math::DVec4::as_i64vec4(&_self) - .into(); + fn as_i64vec4(_self: Ref<::glam::DVec4>) -> Val<::glam::I64Vec4> { + let output: Val<::glam::I64Vec4> = ::glam::DVec4::as_i64vec4(&_self).into(); output } /// Casts all elements of `self` to `i8`. - fn as_i8vec4(_self: Ref) -> Val { - let output: Val = bevy::math::DVec4::as_i8vec4(&_self) - .into(); + fn as_i8vec4(_self: Ref<::glam::DVec4>) -> Val<::glam::I8Vec4> { + let output: Val<::glam::I8Vec4> = ::glam::DVec4::as_i8vec4(&_self).into(); output } /// Casts all elements of `self` to `i32`. - fn as_ivec4(_self: Ref) -> Val { - let output: Val = bevy::math::DVec4::as_ivec4(&_self).into(); + fn as_ivec4(_self: Ref<::glam::DVec4>) -> Val<::glam::IVec4> { + let output: Val<::glam::IVec4> = ::glam::DVec4::as_ivec4(&_self).into(); output } /// Casts all elements of `self` to `u16`. - fn as_u16vec4(_self: Ref) -> Val { - let output: Val = bevy::math::DVec4::as_u16vec4(&_self) - .into(); + fn as_u16vec4(_self: Ref<::glam::DVec4>) -> Val<::glam::U16Vec4> { + let output: Val<::glam::U16Vec4> = ::glam::DVec4::as_u16vec4(&_self).into(); output } /// Casts all elements of `self` to `u64`. - fn as_u64vec4(_self: Ref) -> Val { - let output: Val = bevy::math::DVec4::as_u64vec4(&_self) - .into(); + fn as_u64vec4(_self: Ref<::glam::DVec4>) -> Val<::glam::U64Vec4> { + let output: Val<::glam::U64Vec4> = ::glam::DVec4::as_u64vec4(&_self).into(); output } /// Casts all elements of `self` to `u8`. - fn as_u8vec4(_self: Ref) -> Val { - let output: Val = bevy::math::DVec4::as_u8vec4(&_self) - .into(); + fn as_u8vec4(_self: Ref<::glam::DVec4>) -> Val<::glam::U8Vec4> { + let output: Val<::glam::U8Vec4> = ::glam::DVec4::as_u8vec4(&_self).into(); output } /// Casts all elements of `self` to `u32`. - fn as_uvec4(_self: Ref) -> Val { - let output: Val = bevy::math::DVec4::as_uvec4(&_self).into(); + fn as_uvec4(_self: Ref<::glam::DVec4>) -> Val<::glam::UVec4> { + let output: Val<::glam::UVec4> = ::glam::DVec4::as_uvec4(&_self).into(); output } /// Casts all elements of `self` to `f32`. - fn as_vec4(_self: Ref) -> Val { - let output: Val = bevy::math::DVec4::as_vec4(&_self).into(); + fn as_vec4(_self: Ref<::glam::DVec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::DVec4::as_vec4(&_self).into(); output } /// Returns a vector containing the smallest integer greater than or equal to a number for /// each element of `self`. - fn ceil(_self: Val) -> Val { - let output: Val = bevy::math::DVec4::ceil(_self.into_inner()) - .into(); + fn ceil(_self: Val<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::ceil(_self.into_inner()).into(); output } /// Component-wise clamping of values, similar to [`f64::clamp`]. @@ -23965,11 +22089,11 @@ impl bevy::math::DVec4 { /// # Panics /// Will panic if `min` is greater than `max` when `glam_assert` is enabled. fn clamp( - _self: Val, - min: Val, - max: Val, - ) -> Val { - let output: Val = bevy::math::DVec4::clamp( + _self: Val<::glam::DVec4>, + min: Val<::glam::DVec4>, + max: Val<::glam::DVec4>, + ) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::clamp( _self.into_inner(), min.into_inner(), max.into_inner(), @@ -23981,11 +22105,11 @@ impl bevy::math::DVec4 { /// # Panics /// Will panic if `min` is greater than `max`, or if either `min` or `max` is negative, when `glam_assert` is enabled. fn clamp_length( - _self: Val, + _self: Val<::glam::DVec4>, min: f64, max: f64, - ) -> Val { - let output: Val = bevy::math::DVec4::clamp_length( + ) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::clamp_length( _self.into_inner(), min, max, @@ -23996,11 +22120,8 @@ impl bevy::math::DVec4 { /// Returns a vector with a length no more than `max`. /// # Panics /// Will panic if `max` is negative when `glam_assert` is enabled. - fn clamp_length_max( - _self: Val, - max: f64, - ) -> Val { - let output: Val = bevy::math::DVec4::clamp_length_max( + fn clamp_length_max(_self: Val<::glam::DVec4>, max: f64) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::clamp_length_max( _self.into_inner(), max, ) @@ -24010,19 +22131,16 @@ impl bevy::math::DVec4 { /// Returns a vector with a length no less than `min`. /// # Panics /// Will panic if `min` is negative when `glam_assert` is enabled. - fn clamp_length_min( - _self: Val, - min: f64, - ) -> Val { - let output: Val = bevy::math::DVec4::clamp_length_min( + fn clamp_length_min(_self: Val<::glam::DVec4>, min: f64) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::clamp_length_min( _self.into_inner(), min, ) .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -24032,11 +22150,8 @@ impl bevy::math::DVec4 { /// `self` and `rhs`. /// In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]` for all /// elements. - fn cmpeq( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec4::cmpeq( + fn cmpeq(_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::DVec4::cmpeq( _self.into_inner(), rhs.into_inner(), ) @@ -24047,11 +22162,8 @@ impl bevy::math::DVec4 { /// `self` and `rhs`. /// In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]` for all /// elements. - fn cmpge( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec4::cmpge( + fn cmpge(_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::DVec4::cmpge( _self.into_inner(), rhs.into_inner(), ) @@ -24062,11 +22174,8 @@ impl bevy::math::DVec4 { /// `self` and `rhs`. /// In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]` for all /// elements. - fn cmpgt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec4::cmpgt( + fn cmpgt(_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::DVec4::cmpgt( _self.into_inner(), rhs.into_inner(), ) @@ -24077,11 +22186,8 @@ impl bevy::math::DVec4 { /// `self` and `rhs`. /// In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]` for all /// elements. - fn cmple( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec4::cmple( + fn cmple(_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::DVec4::cmple( _self.into_inner(), rhs.into_inner(), ) @@ -24092,11 +22198,8 @@ impl bevy::math::DVec4 { /// `self` and `rhs`. /// In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]` for all /// elements. - fn cmplt( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec4::cmplt( + fn cmplt(_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::DVec4::cmplt( _self.into_inner(), rhs.into_inner(), ) @@ -24107,11 +22210,8 @@ impl bevy::math::DVec4 { /// `self` and `rhs`. /// In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]` for all /// elements. - fn cmpne( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec4::cmpne( + fn cmpne(_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::DVec4::cmpne( _self.into_inner(), rhs.into_inner(), ) @@ -24120,10 +22220,10 @@ impl bevy::math::DVec4 { } /// Returns a vector with signs of `rhs` and the magnitudes of `self`. fn copysign( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec4::copysign( + _self: Val<::glam::DVec4>, + rhs: Val<::glam::DVec4>, + ) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::copysign( _self.into_inner(), rhs.into_inner(), ) @@ -24131,48 +22231,36 @@ impl bevy::math::DVec4 { output } /// Computes the Euclidean distance between two points in space. - fn distance(_self: Val, rhs: Val) -> f64 { - let output: f64 = bevy::math::DVec4::distance( - _self.into_inner(), - rhs.into_inner(), - ) + fn distance(_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>) -> f64 { + let output: f64 = ::glam::DVec4::distance(_self.into_inner(), rhs.into_inner()) .into(); output } /// Compute the squared euclidean distance between two points in space. - fn distance_squared( - _self: Val, - rhs: Val, - ) -> f64 { - let output: f64 = bevy::math::DVec4::distance_squared( + fn distance_squared(_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>) -> f64 { + let output: f64 = ::glam::DVec4::distance_squared( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn div( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Div< + &::glam::DVec4, >>::div(_self.into_inner(), &rhs) .into(); output } - fn div( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Div< + ::glam::DVec4, >>::div(_self.into_inner(), rhs.into_inner()) .into(); output } - fn div(_self: Val, rhs: f64) -> Val { - let output: Val = , rhs: f64) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Div< f64, >>::div(_self.into_inner(), rhs) .into(); @@ -24180,10 +22268,10 @@ impl bevy::math::DVec4 { } /// Returns the element-wise quotient of [Euclidean division] of `self` by `rhs`. fn div_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec4::div_euclid( + _self: Val<::glam::DVec4>, + rhs: Val<::glam::DVec4>, + ) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::div_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -24191,17 +22279,17 @@ impl bevy::math::DVec4 { output } /// Computes the dot product of `self` and `rhs`. - fn dot(_self: Val, rhs: Val) -> f64 { - let output: f64 = bevy::math::DVec4::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>) -> f64 { + let output: f64 = ::glam::DVec4::dot(_self.into_inner(), rhs.into_inner()) .into(); output } /// Returns a vector where every component is the dot product of `self` and `rhs`. fn dot_into_vec( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec4::dot_into_vec( + _self: Val<::glam::DVec4>, + rhs: Val<::glam::DVec4>, + ) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::dot_into_vec( _self.into_inner(), rhs.into_inner(), ) @@ -24210,120 +22298,112 @@ impl bevy::math::DVec4 { } /// Returns the product of all elements of `self`. /// In other words, this computes `self.x * self.y * ..`. - fn element_product(_self: Val) -> f64 { - let output: f64 = bevy::math::DVec4::element_product(_self.into_inner()).into(); + fn element_product(_self: Val<::glam::DVec4>) -> f64 { + let output: f64 = ::glam::DVec4::element_product(_self.into_inner()).into(); output } /// Returns the sum of all elements of `self`. /// In other words, this computes `self.x + self.y + ..`. - fn element_sum(_self: Val) -> f64 { - let output: f64 = bevy::math::DVec4::element_sum(_self.into_inner()).into(); + fn element_sum(_self: Val<::glam::DVec4>) -> f64 { + let output: f64 = ::glam::DVec4::element_sum(_self.into_inner()).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::DVec4>) -> bool { + let output: bool = <::glam::DVec4 as ::core::cmp::PartialEq< + ::glam::DVec4, >>::eq(&_self, &other) .into(); output } /// Returns a vector containing `e^self` (the exponential function) for each element of /// `self`. - fn exp(_self: Val) -> Val { - let output: Val = bevy::math::DVec4::exp(_self.into_inner()) - .into(); + fn exp(_self: Val<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::exp(_self.into_inner()).into(); output } /// Returns a vector containing the largest integer less than or equal to a number for each /// element of `self`. - fn floor(_self: Val) -> Val { - let output: Val = bevy::math::DVec4::floor(_self.into_inner()) - .into(); + fn floor(_self: Val<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::floor(_self.into_inner()).into(); output } /// Returns a vector containing the fractional part of the vector as `self - self.trunc()`. /// Note that this differs from the GLSL implementation of `fract` which returns /// `self - self.floor()`. /// Note that this is fast but not precise for large numbers. - fn fract(_self: Val) -> Val { - let output: Val = bevy::math::DVec4::fract(_self.into_inner()) - .into(); + fn fract(_self: Val<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::fract(_self.into_inner()).into(); output } /// Returns a vector containing the fractional part of the vector as `self - self.floor()`. /// Note that this differs from the Rust implementation of `fract` which returns /// `self - self.trunc()`. /// Note that this is fast but not precise for large numbers. - fn fract_gl(_self: Val) -> Val { - let output: Val = bevy::math::DVec4::fract_gl( - _self.into_inner(), - ) + fn fract_gl(_self: Val<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::fract_gl(_self.into_inner()) .into(); output } /// Creates a new vector from an array. - fn from_array(a: [f64; 4]) -> Val { - let output: Val = bevy::math::DVec4::from_array(a).into(); + fn from_array(a: [f64; 4]) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::from_array(a).into(); output } /// Returns `true` if, and only if, all elements are finite. If any element is either /// `NaN`, positive or negative infinity, this will return `false`. - fn is_finite(_self: Val) -> bool { - let output: bool = bevy::math::DVec4::is_finite(_self.into_inner()).into(); + fn is_finite(_self: Val<::glam::DVec4>) -> bool { + let output: bool = ::glam::DVec4::is_finite(_self.into_inner()).into(); output } /// Performs `is_finite` on each element of self, returning a vector mask of the results. /// In other words, this computes `[x.is_finite(), y.is_finite(), ...]`. - fn is_finite_mask(_self: Val) -> Val { - let output: Val = bevy::math::DVec4::is_finite_mask( + fn is_finite_mask(_self: Val<::glam::DVec4>) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::DVec4::is_finite_mask( _self.into_inner(), ) .into(); output } /// Returns `true` if any elements are `NaN`. - fn is_nan(_self: Val) -> bool { - let output: bool = bevy::math::DVec4::is_nan(_self.into_inner()).into(); + fn is_nan(_self: Val<::glam::DVec4>) -> bool { + let output: bool = ::glam::DVec4::is_nan(_self.into_inner()).into(); output } /// Performs `is_nan` on each element of self, returning a vector mask of the results. /// In other words, this computes `[x.is_nan(), y.is_nan(), ...]`. - fn is_nan_mask(_self: Val) -> Val { - let output: Val = bevy::math::DVec4::is_nan_mask( - _self.into_inner(), - ) + fn is_nan_mask(_self: Val<::glam::DVec4>) -> Val<::glam::BVec4> { + let output: Val<::glam::BVec4> = ::glam::DVec4::is_nan_mask(_self.into_inner()) .into(); output } /// Returns a bitmask with the lowest 4 bits set to the sign bits from the elements of `self`. /// A negative element results in a `1` bit and a positive element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn is_negative_bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::DVec4::is_negative_bitmask(_self.into_inner()) - .into(); + fn is_negative_bitmask(_self: Val<::glam::DVec4>) -> u32 { + let output: u32 = ::glam::DVec4::is_negative_bitmask(_self.into_inner()).into(); output } /// Returns whether `self` is length `1.0` or not. /// Uses a precision threshold of approximately `1e-4`. - fn is_normalized(_self: Val) -> bool { - let output: bool = bevy::math::DVec4::is_normalized(_self.into_inner()).into(); + fn is_normalized(_self: Val<::glam::DVec4>) -> bool { + let output: bool = ::glam::DVec4::is_normalized(_self.into_inner()).into(); output } /// Computes the length of `self`. - fn length(_self: Val) -> f64 { - let output: f64 = bevy::math::DVec4::length(_self.into_inner()).into(); + fn length(_self: Val<::glam::DVec4>) -> f64 { + let output: f64 = ::glam::DVec4::length(_self.into_inner()).into(); output } /// Computes `1.0 / length()`. /// For valid results, `self` must _not_ be of length zero. - fn length_recip(_self: Val) -> f64 { - let output: f64 = bevy::math::DVec4::length_recip(_self.into_inner()).into(); + fn length_recip(_self: Val<::glam::DVec4>) -> f64 { + let output: f64 = ::glam::DVec4::length_recip(_self.into_inner()).into(); output } /// Computes the squared length of `self`. /// This is faster than `length()` as it avoids a square root operation. - fn length_squared(_self: Val) -> f64 { - let output: f64 = bevy::math::DVec4::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::DVec4>) -> f64 { + let output: f64 = ::glam::DVec4::length_squared(_self.into_inner()).into(); output } /// Performs a linear interpolation between `self` and `rhs` based on the value `s`. @@ -24331,11 +22411,11 @@ impl bevy::math::DVec4 { /// will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly /// extrapolated. fn lerp( - _self: Val, - rhs: Val, + _self: Val<::glam::DVec4>, + rhs: Val<::glam::DVec4>, s: f64, - ) -> Val { - let output: Val = bevy::math::DVec4::lerp( + ) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::lerp( _self.into_inner(), rhs.into_inner(), s, @@ -24345,11 +22425,8 @@ impl bevy::math::DVec4 { } /// Returns a vector containing the maximum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`. - fn max( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec4::max( + fn max(_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::max( _self.into_inner(), rhs.into_inner(), ) @@ -24358,8 +22435,8 @@ impl bevy::math::DVec4 { } /// Returns the horizontal maximum of `self`. /// In other words this computes `max(x, y, ..)`. - fn max_element(_self: Val) -> f64 { - let output: f64 = bevy::math::DVec4::max_element(_self.into_inner()).into(); + fn max_element(_self: Val<::glam::DVec4>) -> f64 { + let output: f64 = ::glam::DVec4::max_element(_self.into_inner()).into(); output } /// Calculates the midpoint between `self` and `rhs`. @@ -24367,10 +22444,10 @@ impl bevy::math::DVec4 { /// `a.midpoint(b)` should yield the same result as `a.lerp(b, 0.5)` /// while being slightly cheaper to compute. fn midpoint( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec4::midpoint( + _self: Val<::glam::DVec4>, + rhs: Val<::glam::DVec4>, + ) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::midpoint( _self.into_inner(), rhs.into_inner(), ) @@ -24379,11 +22456,8 @@ impl bevy::math::DVec4 { } /// Returns a vector containing the minimum values for each element of `self` and `rhs`. /// In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`. - fn min( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec4::min( + fn min(_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::min( _self.into_inner(), rhs.into_inner(), ) @@ -24392,19 +22466,19 @@ impl bevy::math::DVec4 { } /// Returns the horizontal minimum of `self`. /// In other words this computes `min(x, y, ..)`. - fn min_element(_self: Val) -> f64 { - let output: f64 = bevy::math::DVec4::min_element(_self.into_inner()).into(); + fn min_element(_self: Val<::glam::DVec4>) -> f64 { + let output: f64 = ::glam::DVec4::min_element(_self.into_inner()).into(); output } /// Moves towards `rhs` based on the value `d`. /// When `d` is `0.0`, the result will be equal to `self`. When `d` is equal to /// `self.distance(rhs)`, the result will be equal to `rhs`. Will not go past `rhs`. fn move_towards( - _self: Ref, - rhs: Val, + _self: Ref<::glam::DVec4>, + rhs: Val<::glam::DVec4>, d: f64, - ) -> Val { - let output: Val = bevy::math::DVec4::move_towards( + ) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::move_towards( &_self, rhs.into_inner(), d, @@ -24412,28 +22486,22 @@ impl bevy::math::DVec4 { .into(); output } - fn mul( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Mul< + &::glam::DVec4, >>::mul(_self.into_inner(), &rhs) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Mul< + ::glam::DVec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: f64) -> Val { - let output: Val = , rhs: f64) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Mul< f64, >>::mul(_self.into_inner(), rhs) .into(); @@ -24446,11 +22514,11 @@ impl bevy::math::DVec4 { /// and will be heavily dependant on designing algorithms with specific target hardware in /// mind. fn mul_add( - _self: Val, - a: Val, - b: Val, - ) -> Val { - let output: Val = bevy::math::DVec4::mul_add( + _self: Val<::glam::DVec4>, + a: Val<::glam::DVec4>, + b: Val<::glam::DVec4>, + ) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::mul_add( _self.into_inner(), a.into_inner(), b.into_inner(), @@ -24458,16 +22526,16 @@ impl bevy::math::DVec4 { .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); output } /// Creates a new vector. - fn new(x: f64, y: f64, z: f64, w: f64) -> Val { - let output: Val = bevy::math::DVec4::new(x, y, z, w).into(); + fn new(x: f64, y: f64, z: f64, w: f64) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::new(x, y, z, w).into(); output } /// Returns `self` normalized to length 1.0. @@ -24475,10 +22543,8 @@ impl bevy::math::DVec4 { /// See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`]. /// Panics /// Will panic if the resulting normalized vector is not finite when `glam_assert` is enabled. - fn normalize(_self: Val) -> Val { - let output: Val = bevy::math::DVec4::normalize( - _self.into_inner(), - ) + fn normalize(_self: Val<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::normalize(_self.into_inner()) .into(); output } @@ -24488,10 +22554,10 @@ impl bevy::math::DVec4 { /// the result of this operation will be the fallback value. /// See also [`Self::try_normalize()`]. fn normalize_or( - _self: Val, - fallback: Val, - ) -> Val { - let output: Val = bevy::math::DVec4::normalize_or( + _self: Val<::glam::DVec4>, + fallback: Val<::glam::DVec4>, + ) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::normalize_or( _self.into_inner(), fallback.into_inner(), ) @@ -24502,19 +22568,16 @@ impl bevy::math::DVec4 { /// In particular, if the input is zero (or very close to zero), or non-finite, /// the result of this operation will be zero. /// See also [`Self::try_normalize()`]. - fn normalize_or_zero(_self: Val) -> Val { - let output: Val = bevy::math::DVec4::normalize_or_zero( + fn normalize_or_zero(_self: Val<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::normalize_or_zero( _self.into_inner(), ) .into(); output } /// Returns a vector containing each element of `self` raised to the power of `n`. - fn powf(_self: Val, n: f64) -> Val { - let output: Val = bevy::math::DVec4::powf( - _self.into_inner(), - n, - ) + fn powf(_self: Val<::glam::DVec4>, n: f64) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::powf(_self.into_inner(), n) .into(); output } @@ -24523,10 +22586,10 @@ impl bevy::math::DVec4 { /// # Panics /// Will panic if `rhs` is zero length when `glam_assert` is enabled. fn project_onto( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec4::project_onto( + _self: Val<::glam::DVec4>, + rhs: Val<::glam::DVec4>, + ) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::project_onto( _self.into_inner(), rhs.into_inner(), ) @@ -24538,10 +22601,10 @@ impl bevy::math::DVec4 { /// # Panics /// Will panic if `rhs` is not normalized when `glam_assert` is enabled. fn project_onto_normalized( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec4::project_onto_normalized( + _self: Val<::glam::DVec4>, + rhs: Val<::glam::DVec4>, + ) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::project_onto_normalized( _self.into_inner(), rhs.into_inner(), ) @@ -24549,9 +22612,8 @@ impl bevy::math::DVec4 { output } /// Returns a vector containing the reciprocal `1.0/n` of each element of `self`. - fn recip(_self: Val) -> Val { - let output: Val = bevy::math::DVec4::recip(_self.into_inner()) - .into(); + fn recip(_self: Val<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::recip(_self.into_inner()).into(); output } /// Returns the reflection vector for a given incident vector `self` and surface normal @@ -24560,10 +22622,10 @@ impl bevy::math::DVec4 { /// # Panics /// Will panic if `normal` is not normalized when `glam_assert` is enabled. fn reflect( - _self: Val, - normal: Val, - ) -> Val { - let output: Val = bevy::math::DVec4::reflect( + _self: Val<::glam::DVec4>, + normal: Val<::glam::DVec4>, + ) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::reflect( _self.into_inner(), normal.into_inner(), ) @@ -24577,11 +22639,11 @@ impl bevy::math::DVec4 { /// # Panics /// Will panic if `self` or `normal` is not normalized when `glam_assert` is enabled. fn refract( - _self: Val, - normal: Val, + _self: Val<::glam::DVec4>, + normal: Val<::glam::DVec4>, eta: f64, - ) -> Val { - let output: Val = bevy::math::DVec4::refract( + ) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::refract( _self.into_inner(), normal.into_inner(), eta, @@ -24596,10 +22658,10 @@ impl bevy::math::DVec4 { /// # Panics /// Will panic if `rhs` has a length of zero when `glam_assert` is enabled. fn reject_from( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec4::reject_from( + _self: Val<::glam::DVec4>, + rhs: Val<::glam::DVec4>, + ) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::reject_from( _self.into_inner(), rhs.into_inner(), ) @@ -24613,38 +22675,32 @@ impl bevy::math::DVec4 { /// # Panics /// Will panic if `rhs` is not normalized when `glam_assert` is enabled. fn reject_from_normalized( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec4::reject_from_normalized( + _self: Val<::glam::DVec4>, + rhs: Val<::glam::DVec4>, + ) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::reject_from_normalized( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn rem( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Rem< + &::glam::DVec4, >>::rem(_self.into_inner(), &rhs) .into(); output } - fn rem( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Rem< + ::glam::DVec4, >>::rem(_self.into_inner(), rhs.into_inner()) .into(); output } - fn rem(_self: Val, rhs: f64) -> Val { - let output: Val = , rhs: f64) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Rem< f64, >>::rem(_self.into_inner(), rhs) .into(); @@ -24653,10 +22709,10 @@ impl bevy::math::DVec4 { /// Returns the element-wise remainder of [Euclidean division] of `self` by `rhs`. /// [Euclidean division]: f64::rem_euclid fn rem_euclid( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DVec4::rem_euclid( + _self: Val<::glam::DVec4>, + rhs: Val<::glam::DVec4>, + ) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::rem_euclid( _self.into_inner(), rhs.into_inner(), ) @@ -24665,9 +22721,8 @@ impl bevy::math::DVec4 { } /// Returns a vector containing the nearest integer to a number for each element of `self`. /// Round half-way cases away from 0.0. - fn round(_self: Val) -> Val { - let output: Val = bevy::math::DVec4::round(_self.into_inner()) - .into(); + fn round(_self: Val<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::round(_self.into_inner()).into(); output } /// Creates a vector from the elements in `if_true` and `if_false`, selecting which to use @@ -24675,11 +22730,11 @@ impl bevy::math::DVec4 { /// A true element in the mask uses the corresponding element from `if_true`, and false /// uses the element from `if_false`. fn select( - mask: Val, - if_true: Val, - if_false: Val, - ) -> Val { - let output: Val = bevy::math::DVec4::select( + mask: Val<::glam::BVec4>, + if_true: Val<::glam::DVec4>, + if_false: Val<::glam::DVec4>, + ) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::select( mask.into_inner(), if_true.into_inner(), if_false.into_inner(), @@ -24691,99 +22746,76 @@ impl bevy::math::DVec4 { /// - `1.0` if the number is positive, `+0.0` or `INFINITY` /// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY` /// - `NAN` if the number is `NAN` - fn signum(_self: Val) -> Val { - let output: Val = bevy::math::DVec4::signum( - _self.into_inner(), - ) + fn signum(_self: Val<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::signum(_self.into_inner()) .into(); output } /// Creates a vector with all elements set to `v`. - fn splat(v: f64) -> Val { - let output: Val = bevy::math::DVec4::splat(v).into(); + fn splat(v: f64) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::splat(v).into(); output } - fn sub( - _self: Val, - rhs: Ref, - ) -> Val { - let output: Val = , rhs: Ref<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Sub< + &::glam::DVec4, >>::sub(_self.into_inner(), &rhs) .into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Sub< + ::glam::DVec4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } - fn sub(_self: Val, rhs: f64) -> Val { - let output: Val = , rhs: f64) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = <::glam::DVec4 as ::core::ops::Sub< f64, >>::sub(_self.into_inner(), rhs) .into(); output } /// `[x, y, z, w]` - fn to_array(_self: Ref) -> [f64; 4] { - let output: [f64; 4] = bevy::math::DVec4::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::DVec4>) -> [f64; 4] { + let output: [f64; 4] = ::glam::DVec4::to_array(&_self).into(); output } /// Returns a vector containing the integer part each element of `self`. This means numbers are /// always truncated towards zero. - fn trunc(_self: Val) -> Val { - let output: Val = bevy::math::DVec4::trunc(_self.into_inner()) - .into(); + fn trunc(_self: Val<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::trunc(_self.into_inner()).into(); output } /// Creates a 3D vector from the `x`, `y` and `z` elements of `self`, discarding `w`. /// Truncation to [`DVec3`] may also be performed by using [`self.xyz()`][crate::swizzles::Vec4Swizzles::xyz()]. - fn truncate(_self: Val) -> Val { - let output: Val = bevy::math::DVec4::truncate( - _self.into_inner(), - ) + fn truncate(_self: Val<::glam::DVec4>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DVec4::truncate(_self.into_inner()) .into(); output } /// Creates a 4D vector from `self` with the given value of `w`. - fn with_w(_self: Val, w: f64) -> Val { - let output: Val = bevy::math::DVec4::with_w( - _self.into_inner(), - w, - ) + fn with_w(_self: Val<::glam::DVec4>, w: f64) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::with_w(_self.into_inner(), w) .into(); output } /// Creates a 4D vector from `self` with the given value of `x`. - fn with_x(_self: Val, x: f64) -> Val { - let output: Val = bevy::math::DVec4::with_x( - _self.into_inner(), - x, - ) + fn with_x(_self: Val<::glam::DVec4>, x: f64) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::with_x(_self.into_inner(), x) .into(); output } /// Creates a 4D vector from `self` with the given value of `y`. - fn with_y(_self: Val, y: f64) -> Val { - let output: Val = bevy::math::DVec4::with_y( - _self.into_inner(), - y, - ) + fn with_y(_self: Val<::glam::DVec4>, y: f64) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::with_y(_self.into_inner(), y) .into(); output } /// Creates a 4D vector from `self` with the given value of `z`. - fn with_z(_self: Val, z: f64) -> Val { - let output: Val = bevy::math::DVec4::with_z( - _self.into_inner(), - z, - ) + fn with_z(_self: Val<::glam::DVec4>, z: f64) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DVec4::with_z(_self.into_inner(), z) .into(); output } @@ -24794,10 +22826,10 @@ impl bevy::math::DVec4 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::Mat2 { +impl ::glam::Mat2 { /// Takes the absolute value of each element in `self` - fn abs(_self: Ref) -> Val { - let output: Val = bevy::math::Mat2::abs(&_self).into(); + fn abs(_self: Ref<::glam::Mat2>) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = ::glam::Mat2::abs(&_self).into(); output } /// Returns true if the absolute difference of all elements between `self` and `rhs` @@ -24808,11 +22840,11 @@ impl bevy::math::Mat2 { /// For more see /// [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/). fn abs_diff_eq( - _self: Ref, - rhs: Val, + _self: Ref<::glam::Mat2>, + rhs: Val<::glam::Mat2>, max_abs_diff: f32, ) -> bool { - let output: bool = bevy::math::Mat2::abs_diff_eq( + let output: bool = ::glam::Mat2::abs_diff_eq( &_self, rhs.into_inner(), max_abs_diff, @@ -24820,31 +22852,24 @@ impl bevy::math::Mat2 { .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Mat2>) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Add< + ::glam::Mat2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } /// Adds two 2x2 matrices. - fn add_mat2( - _self: Ref, - rhs: Ref, - ) -> Val { - let output: Val = bevy::math::Mat2::add_mat2(&_self, &rhs) - .into(); + fn add_mat2(_self: Ref<::glam::Mat2>, rhs: Ref<::glam::Mat2>) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = ::glam::Mat2::add_mat2(&_self, &rhs).into(); output } - fn as_dmat2(_self: Ref) -> Val { - let output: Val = bevy::math::Mat2::as_dmat2(&_self).into(); + fn as_dmat2(_self: Ref<::glam::Mat2>) -> Val<::glam::DMat2> { + let output: Val<::glam::DMat2> = ::glam::Mat2::as_dmat2(&_self).into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::Mat2>) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -24853,46 +22878,45 @@ impl bevy::math::Mat2 { /// Returns the matrix column for the given `index`. /// # Panics /// Panics if `index` is greater than 1. - fn col(_self: Ref, index: usize) -> Val { - let output: Val = bevy::math::Mat2::col(&_self, index).into(); + fn col(_self: Ref<::glam::Mat2>, index: usize) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Mat2::col(&_self, index).into(); output } /// Returns the determinant of `self`. - fn determinant(_self: Ref) -> f32 { - let output: f32 = bevy::math::Mat2::determinant(&_self).into(); + fn determinant(_self: Ref<::glam::Mat2>) -> f32 { + let output: f32 = ::glam::Mat2::determinant(&_self).into(); output } - fn div(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); output } /// Divides a 2x2 matrix by a scalar. - fn div_scalar(_self: Ref, rhs: f32) -> Val { - let output: Val = bevy::math::Mat2::div_scalar(&_self, rhs) - .into(); + fn div_scalar(_self: Ref<::glam::Mat2>, rhs: f32) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = ::glam::Mat2::div_scalar(&_self, rhs).into(); output } - fn eq(_self: Ref, rhs: Ref) -> bool { - let output: bool = , rhs: Ref<::glam::Mat2>) -> bool { + let output: bool = <::glam::Mat2 as ::core::cmp::PartialEq< + ::glam::Mat2, >>::eq(&_self, &rhs) .into(); output } /// Creates a 2x2 matrix containing a rotation of `angle` (in radians). - fn from_angle(angle: f32) -> Val { - let output: Val = bevy::math::Mat2::from_angle(angle).into(); + fn from_angle(angle: f32) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = ::glam::Mat2::from_angle(angle).into(); output } /// Creates a 2x2 matrix from two column vectors. fn from_cols( - x_axis: Val, - y_axis: Val, - ) -> Val { - let output: Val = bevy::math::Mat2::from_cols( + x_axis: Val<::glam::Vec2>, + y_axis: Val<::glam::Vec2>, + ) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = ::glam::Mat2::from_cols( x_axis.into_inner(), y_axis.into_inner(), ) @@ -24900,29 +22924,24 @@ impl bevy::math::Mat2 { output } /// Creates a 2x2 matrix with its diagonal set to `diagonal` and all other entries set to 0. - fn from_diagonal(diagonal: Val) -> Val { - let output: Val = bevy::math::Mat2::from_diagonal( + fn from_diagonal(diagonal: Val<::glam::Vec2>) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = ::glam::Mat2::from_diagonal( diagonal.into_inner(), ) .into(); output } /// Creates a 2x2 matrix from a 3x3 matrix, discarding the 2nd row and column. - fn from_mat3(m: Val) -> Val { - let output: Val = bevy::math::Mat2::from_mat3(m.into_inner()) - .into(); + fn from_mat3(m: Val<::glam::Mat3>) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = ::glam::Mat2::from_mat3(m.into_inner()).into(); output } /// Creates a 2x2 matrix from the minor of the given 3x3 matrix, discarding the `i`th column /// and `j`th row. /// # Panics /// Panics if `i` or `j` is greater than 2. - fn from_mat3_minor( - m: Val, - i: usize, - j: usize, - ) -> Val { - let output: Val = bevy::math::Mat2::from_mat3_minor( + fn from_mat3_minor(m: Val<::glam::Mat3>, i: usize, j: usize) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = ::glam::Mat2::from_mat3_minor( m.into_inner(), i, j, @@ -24931,21 +22950,16 @@ impl bevy::math::Mat2 { output } /// Creates a 2x2 matrix from a 3x3 matrix, discarding the 2nd row and column. - fn from_mat3a(m: Val) -> Val { - let output: Val = bevy::math::Mat2::from_mat3a(m.into_inner()) - .into(); + fn from_mat3a(m: Val<::glam::Mat3A>) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = ::glam::Mat2::from_mat3a(m.into_inner()).into(); output } /// Creates a 2x2 matrix from the minor of the given 3x3 matrix, discarding the `i`th column /// and `j`th row. /// # Panics /// Panics if `i` or `j` is greater than 2. - fn from_mat3a_minor( - m: Val, - i: usize, - j: usize, - ) -> Val { - let output: Val = bevy::math::Mat2::from_mat3a_minor( + fn from_mat3a_minor(m: Val<::glam::Mat3A>, i: usize, j: usize) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = ::glam::Mat2::from_mat3a_minor( m.into_inner(), i, j, @@ -24955,11 +22969,8 @@ impl bevy::math::Mat2 { } /// Creates a 2x2 matrix containing the combining non-uniform `scale` and rotation of /// `angle` (in radians). - fn from_scale_angle( - scale: Val, - angle: f32, - ) -> Val { - let output: Val = bevy::math::Mat2::from_scale_angle( + fn from_scale_angle(scale: Val<::glam::Vec2>, angle: f32) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = ::glam::Mat2::from_scale_angle( scale.into_inner(), angle, ) @@ -24970,77 +22981,60 @@ impl bevy::math::Mat2 { /// If the matrix is not invertible the returned matrix will be invalid. /// # Panics /// Will panic if the determinant of `self` is zero when `glam_assert` is enabled. - fn inverse(_self: Ref) -> Val { - let output: Val = bevy::math::Mat2::inverse(&_self).into(); + fn inverse(_self: Ref<::glam::Mat2>) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = ::glam::Mat2::inverse(&_self).into(); output } /// Returns `true` if, and only if, all elements are finite. /// If any element is either `NaN`, positive or negative infinity, this will return `false`. - fn is_finite(_self: Ref) -> bool { - let output: bool = bevy::math::Mat2::is_finite(&_self).into(); + fn is_finite(_self: Ref<::glam::Mat2>) -> bool { + let output: bool = ::glam::Mat2::is_finite(&_self).into(); output } /// Returns `true` if any elements are `NaN`. - fn is_nan(_self: Ref) -> bool { - let output: bool = bevy::math::Mat2::is_nan(&_self).into(); + fn is_nan(_self: Ref<::glam::Mat2>) -> bool { + let output: bool = ::glam::Mat2::is_nan(&_self).into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Mat2>) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Mul< + ::glam::Mat2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = <::glam::Mat2 as ::core::ops::Mul< + ::glam::Vec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); output } /// Multiplies two 2x2 matrices. - fn mul_mat2( - _self: Ref, - rhs: Ref, - ) -> Val { - let output: Val = bevy::math::Mat2::mul_mat2(&_self, &rhs) - .into(); + fn mul_mat2(_self: Ref<::glam::Mat2>, rhs: Ref<::glam::Mat2>) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = ::glam::Mat2::mul_mat2(&_self, &rhs).into(); output } /// Multiplies a 2x2 matrix by a scalar. - fn mul_scalar(_self: Ref, rhs: f32) -> Val { - let output: Val = bevy::math::Mat2::mul_scalar(&_self, rhs) - .into(); + fn mul_scalar(_self: Ref<::glam::Mat2>, rhs: f32) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = ::glam::Mat2::mul_scalar(&_self, rhs).into(); output } /// Transforms a 2D vector. - fn mul_vec2( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Mat2::mul_vec2( - &_self, - rhs.into_inner(), - ) + fn mul_vec2(_self: Ref<::glam::Mat2>, rhs: Val<::glam::Vec2>) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Mat2::mul_vec2(&_self, rhs.into_inner()) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::Mat2>) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -25049,44 +23043,37 @@ impl bevy::math::Mat2 { /// Returns the matrix row for the given `index`. /// # Panics /// Panics if `index` is greater than 1. - fn row(_self: Ref, index: usize) -> Val { - let output: Val = bevy::math::Mat2::row(&_self, index).into(); + fn row(_self: Ref<::glam::Mat2>, index: usize) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Mat2::row(&_self, index).into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Mat2>) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = <::glam::Mat2 as ::core::ops::Sub< + ::glam::Mat2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } /// Subtracts two 2x2 matrices. - fn sub_mat2( - _self: Ref, - rhs: Ref, - ) -> Val { - let output: Val = bevy::math::Mat2::sub_mat2(&_self, &rhs) - .into(); + fn sub_mat2(_self: Ref<::glam::Mat2>, rhs: Ref<::glam::Mat2>) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = ::glam::Mat2::sub_mat2(&_self, &rhs).into(); output } /// Creates a `[f32; 4]` array storing data in column major order. /// If you require data in row major order `transpose` the matrix first. - fn to_cols_array(_self: Ref) -> [f32; 4] { - let output: [f32; 4] = bevy::math::Mat2::to_cols_array(&_self).into(); + fn to_cols_array(_self: Ref<::glam::Mat2>) -> [f32; 4] { + let output: [f32; 4] = ::glam::Mat2::to_cols_array(&_self).into(); output } /// Creates a `[[f32; 2]; 2]` 2D array storing data in column major order. /// If you require data in row major order `transpose` the matrix first. - fn to_cols_array_2d(_self: Ref) -> [[f32; 2]; 2] { - let output: [[f32; 2]; 2] = bevy::math::Mat2::to_cols_array_2d(&_self).into(); + fn to_cols_array_2d(_self: Ref<::glam::Mat2>) -> [[f32; 2]; 2] { + let output: [[f32; 2]; 2] = ::glam::Mat2::to_cols_array_2d(&_self).into(); output } /// Returns the transpose of `self`. - fn transpose(_self: Ref) -> Val { - let output: Val = bevy::math::Mat2::transpose(&_self).into(); + fn transpose(_self: Ref<::glam::Mat2>) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = ::glam::Mat2::transpose(&_self).into(); output } } @@ -25096,10 +23083,10 @@ impl bevy::math::Mat2 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::Mat3 { +impl ::glam::Mat3 { /// Takes the absolute value of each element in `self` - fn abs(_self: Ref) -> Val { - let output: Val = bevy::math::Mat3::abs(&_self).into(); + fn abs(_self: Ref<::glam::Mat3>) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::Mat3::abs(&_self).into(); output } /// Returns true if the absolute difference of all elements between `self` and `rhs` @@ -25110,11 +23097,11 @@ impl bevy::math::Mat3 { /// For more see /// [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/). fn abs_diff_eq( - _self: Ref, - rhs: Val, + _self: Ref<::glam::Mat3>, + rhs: Val<::glam::Mat3>, max_abs_diff: f32, ) -> bool { - let output: bool = bevy::math::Mat3::abs_diff_eq( + let output: bool = ::glam::Mat3::abs_diff_eq( &_self, rhs.into_inner(), max_abs_diff, @@ -25122,31 +23109,24 @@ impl bevy::math::Mat3 { .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Mat3>) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Add< + ::glam::Mat3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } /// Adds two 3x3 matrices. - fn add_mat3( - _self: Ref, - rhs: Ref, - ) -> Val { - let output: Val = bevy::math::Mat3::add_mat3(&_self, &rhs) - .into(); + fn add_mat3(_self: Ref<::glam::Mat3>, rhs: Ref<::glam::Mat3>) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::Mat3::add_mat3(&_self, &rhs).into(); output } - fn as_dmat3(_self: Ref) -> Val { - let output: Val = bevy::math::Mat3::as_dmat3(&_self).into(); + fn as_dmat3(_self: Ref<::glam::Mat3>) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::Mat3::as_dmat3(&_self).into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::Mat3>) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -25155,31 +23135,30 @@ impl bevy::math::Mat3 { /// Returns the matrix column for the given `index`. /// # Panics /// Panics if `index` is greater than 2. - fn col(_self: Ref, index: usize) -> Val { - let output: Val = bevy::math::Mat3::col(&_self, index).into(); + fn col(_self: Ref<::glam::Mat3>, index: usize) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Mat3::col(&_self, index).into(); output } /// Returns the determinant of `self`. - fn determinant(_self: Ref) -> f32 { - let output: f32 = bevy::math::Mat3::determinant(&_self).into(); + fn determinant(_self: Ref<::glam::Mat3>) -> f32 { + let output: f32 = ::glam::Mat3::determinant(&_self).into(); output } - fn div(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); output } /// Divides a 3x3 matrix by a scalar. - fn div_scalar(_self: Ref, rhs: f32) -> Val { - let output: Val = bevy::math::Mat3::div_scalar(&_self, rhs) - .into(); + fn div_scalar(_self: Ref<::glam::Mat3>, rhs: f32) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::Mat3::div_scalar(&_self, rhs).into(); output } - fn eq(_self: Ref, rhs: Ref) -> bool { - let output: bool = , rhs: Ref<::glam::Mat3>) -> bool { + let output: bool = <::glam::Mat3 as ::core::cmp::PartialEq< + ::glam::Mat3, >>::eq(&_self, &rhs) .into(); output @@ -25188,19 +23167,16 @@ impl bevy::math::Mat3 { /// radians). /// The resulting matrix can be used to transform 2D points and vectors. See /// [`Self::transform_point2()`] and [`Self::transform_vector2()`]. - fn from_angle(angle: f32) -> Val { - let output: Val = bevy::math::Mat3::from_angle(angle).into(); + fn from_angle(angle: f32) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::Mat3::from_angle(angle).into(); output } /// Creates a 3D rotation matrix from a normalized rotation `axis` and `angle` (in /// radians). /// # Panics /// Will panic if `axis` is not normalized when `glam_assert` is enabled. - fn from_axis_angle( - axis: Val, - angle: f32, - ) -> Val { - let output: Val = bevy::math::Mat3::from_axis_angle( + fn from_axis_angle(axis: Val<::glam::Vec3>, angle: f32) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::Mat3::from_axis_angle( axis.into_inner(), angle, ) @@ -25209,11 +23185,11 @@ impl bevy::math::Mat3 { } /// Creates a 3x3 matrix from three column vectors. fn from_cols( - x_axis: Val, - y_axis: Val, - z_axis: Val, - ) -> Val { - let output: Val = bevy::math::Mat3::from_cols( + x_axis: Val<::glam::Vec3>, + y_axis: Val<::glam::Vec3>, + z_axis: Val<::glam::Vec3>, + ) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::Mat3::from_cols( x_axis.into_inner(), y_axis.into_inner(), z_axis.into_inner(), @@ -25222,8 +23198,8 @@ impl bevy::math::Mat3 { output } /// Creates a 3x3 matrix with its diagonal set to `diagonal` and all other entries set to 0. - fn from_diagonal(diagonal: Val) -> Val { - let output: Val = bevy::math::Mat3::from_diagonal( + fn from_diagonal(diagonal: Val<::glam::Vec3>) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::Mat3::from_diagonal( diagonal.into_inner(), ) .into(); @@ -25232,12 +23208,12 @@ impl bevy::math::Mat3 { /// Creates a 3D rotation matrix from the given euler rotation sequence and the angles (in /// radians). fn from_euler( - order: Val, + order: Val<::glam::EulerRot>, a: f32, b: f32, c: f32, - ) -> Val { - let output: Val = bevy::math::Mat3::from_euler( + ) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::Mat3::from_euler( order.into_inner(), a, b, @@ -25249,27 +23225,21 @@ impl bevy::math::Mat3 { /// Creates an affine transformation matrix from the given 2x2 matrix. /// The resulting matrix can be used to transform 2D points and vectors. See /// [`Self::transform_point2()`] and [`Self::transform_vector2()`]. - fn from_mat2(m: Val) -> Val { - let output: Val = bevy::math::Mat3::from_mat2(m.into_inner()) - .into(); + fn from_mat2(m: Val<::glam::Mat2>) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::Mat3::from_mat2(m.into_inner()).into(); output } /// Creates a 3x3 matrix from a 4x4 matrix, discarding the 4th row and column. - fn from_mat4(m: Val) -> Val { - let output: Val = bevy::math::Mat3::from_mat4(m.into_inner()) - .into(); + fn from_mat4(m: Val<::glam::Mat4>) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::Mat3::from_mat4(m.into_inner()).into(); output } /// Creates a 3x3 matrix from the minor of the given 4x4 matrix, discarding the `i`th column /// and `j`th row. /// # Panics /// Panics if `i` or `j` is greater than 3. - fn from_mat4_minor( - m: Val, - i: usize, - j: usize, - ) -> Val { - let output: Val = bevy::math::Mat3::from_mat4_minor( + fn from_mat4_minor(m: Val<::glam::Mat4>, i: usize, j: usize) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::Mat3::from_mat4_minor( m.into_inner(), i, j, @@ -25280,29 +23250,24 @@ impl bevy::math::Mat3 { /// Creates a 3D rotation matrix from the given quaternion. /// # Panics /// Will panic if `rotation` is not normalized when `glam_assert` is enabled. - fn from_quat(rotation: Val) -> Val { - let output: Val = bevy::math::Mat3::from_quat( - rotation.into_inner(), - ) + fn from_quat(rotation: Val<::glam::Quat>) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::Mat3::from_quat(rotation.into_inner()) .into(); output } /// Creates a 3D rotation matrix from `angle` (in radians) around the x axis. - fn from_rotation_x(angle: f32) -> Val { - let output: Val = bevy::math::Mat3::from_rotation_x(angle) - .into(); + fn from_rotation_x(angle: f32) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::Mat3::from_rotation_x(angle).into(); output } /// Creates a 3D rotation matrix from `angle` (in radians) around the y axis. - fn from_rotation_y(angle: f32) -> Val { - let output: Val = bevy::math::Mat3::from_rotation_y(angle) - .into(); + fn from_rotation_y(angle: f32) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::Mat3::from_rotation_y(angle).into(); output } /// Creates a 3D rotation matrix from `angle` (in radians) around the z axis. - fn from_rotation_z(angle: f32) -> Val { - let output: Val = bevy::math::Mat3::from_rotation_z(angle) - .into(); + fn from_rotation_z(angle: f32) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::Mat3::from_rotation_z(angle).into(); output } /// Creates an affine transformation matrix from the given non-uniform 2D `scale`. @@ -25310,10 +23275,8 @@ impl bevy::math::Mat3 { /// [`Self::transform_point2()`] and [`Self::transform_vector2()`]. /// # Panics /// Will panic if all elements of `scale` are zero when `glam_assert` is enabled. - fn from_scale(scale: Val) -> Val { - let output: Val = bevy::math::Mat3::from_scale( - scale.into_inner(), - ) + fn from_scale(scale: Val<::glam::Vec2>) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::Mat3::from_scale(scale.into_inner()) .into(); output } @@ -25322,11 +23285,11 @@ impl bevy::math::Mat3 { /// The resulting matrix can be used to transform 2D points and vectors. See /// [`Self::transform_point2()`] and [`Self::transform_vector2()`]. fn from_scale_angle_translation( - scale: Val, + scale: Val<::glam::Vec2>, angle: f32, - translation: Val, - ) -> Val { - let output: Val = bevy::math::Mat3::from_scale_angle_translation( + translation: Val<::glam::Vec2>, + ) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::Mat3::from_scale_angle_translation( scale.into_inner(), angle, translation.into_inner(), @@ -25337,8 +23300,8 @@ impl bevy::math::Mat3 { /// Creates an affine transformation matrix from the given 2D `translation`. /// The resulting matrix can be used to transform 2D points and vectors. See /// [`Self::transform_point2()`] and [`Self::transform_vector2()`]. - fn from_translation(translation: Val) -> Val { - let output: Val = bevy::math::Mat3::from_translation( + fn from_translation(translation: Val<::glam::Vec2>) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::Mat3::from_translation( translation.into_inner(), ) .into(); @@ -25348,109 +23311,86 @@ impl bevy::math::Mat3 { /// If the matrix is not invertible the returned matrix will be invalid. /// # Panics /// Will panic if the determinant of `self` is zero when `glam_assert` is enabled. - fn inverse(_self: Ref) -> Val { - let output: Val = bevy::math::Mat3::inverse(&_self).into(); + fn inverse(_self: Ref<::glam::Mat3>) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::Mat3::inverse(&_self).into(); output } /// Returns `true` if, and only if, all elements are finite. /// If any element is either `NaN`, positive or negative infinity, this will return `false`. - fn is_finite(_self: Ref) -> bool { - let output: bool = bevy::math::Mat3::is_finite(&_self).into(); + fn is_finite(_self: Ref<::glam::Mat3>) -> bool { + let output: bool = ::glam::Mat3::is_finite(&_self).into(); output } /// Returns `true` if any elements are `NaN`. - fn is_nan(_self: Ref) -> bool { - let output: bool = bevy::math::Mat3::is_nan(&_self).into(); + fn is_nan(_self: Ref<::glam::Mat3>) -> bool { + let output: bool = ::glam::Mat3::is_nan(&_self).into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Affine2>) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Mul< + ::glam::Affine2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Mat3>) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Mul< + ::glam::Mat3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = <::glam::Mat3 as ::core::ops::Mul< + ::glam::Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = <::glam::Mat3 as ::core::ops::Mul< + ::glam::Vec3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); output } /// Multiplies two 3x3 matrices. - fn mul_mat3( - _self: Ref, - rhs: Ref, - ) -> Val { - let output: Val = bevy::math::Mat3::mul_mat3(&_self, &rhs) - .into(); + fn mul_mat3(_self: Ref<::glam::Mat3>, rhs: Ref<::glam::Mat3>) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::Mat3::mul_mat3(&_self, &rhs).into(); output } /// Multiplies a 3x3 matrix by a scalar. - fn mul_scalar(_self: Ref, rhs: f32) -> Val { - let output: Val = bevy::math::Mat3::mul_scalar(&_self, rhs) - .into(); + fn mul_scalar(_self: Ref<::glam::Mat3>, rhs: f32) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::Mat3::mul_scalar(&_self, rhs).into(); output } /// Transforms a 3D vector. - fn mul_vec3( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Mat3::mul_vec3( - &_self, - rhs.into_inner(), - ) + fn mul_vec3(_self: Ref<::glam::Mat3>, rhs: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Mat3::mul_vec3(&_self, rhs.into_inner()) .into(); output } /// Transforms a [`Vec3A`]. fn mul_vec3a( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Mat3::mul_vec3a( + _self: Ref<::glam::Mat3>, + rhs: Val<::glam::Vec3A>, + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Mat3::mul_vec3a( &_self, rhs.into_inner(), ) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::Mat3>) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -25459,39 +23399,32 @@ impl bevy::math::Mat3 { /// Returns the matrix row for the given `index`. /// # Panics /// Panics if `index` is greater than 2. - fn row(_self: Ref, index: usize) -> Val { - let output: Val = bevy::math::Mat3::row(&_self, index).into(); + fn row(_self: Ref<::glam::Mat3>, index: usize) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Mat3::row(&_self, index).into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Mat3>) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = <::glam::Mat3 as ::core::ops::Sub< + ::glam::Mat3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } /// Subtracts two 3x3 matrices. - fn sub_mat3( - _self: Ref, - rhs: Ref, - ) -> Val { - let output: Val = bevy::math::Mat3::sub_mat3(&_self, &rhs) - .into(); + fn sub_mat3(_self: Ref<::glam::Mat3>, rhs: Ref<::glam::Mat3>) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::Mat3::sub_mat3(&_self, &rhs).into(); output } /// Creates a `[f32; 9]` array storing data in column major order. /// If you require data in row major order `transpose` the matrix first. - fn to_cols_array(_self: Ref) -> [f32; 9] { - let output: [f32; 9] = bevy::math::Mat3::to_cols_array(&_self).into(); + fn to_cols_array(_self: Ref<::glam::Mat3>) -> [f32; 9] { + let output: [f32; 9] = ::glam::Mat3::to_cols_array(&_self).into(); output } /// Creates a `[[f32; 3]; 3]` 3D array storing data in column major order. /// If you require data in row major order `transpose` the matrix first. - fn to_cols_array_2d(_self: Ref) -> [[f32; 3]; 3] { - let output: [[f32; 3]; 3] = bevy::math::Mat3::to_cols_array_2d(&_self).into(); + fn to_cols_array_2d(_self: Ref<::glam::Mat3>) -> [[f32; 3]; 3] { + let output: [[f32; 3]; 3] = ::glam::Mat3::to_cols_array_2d(&_self).into(); output } /// Extract Euler angles with the given Euler rotation order. @@ -25500,13 +23433,10 @@ impl bevy::math::Mat3 { /// # Panics /// Will panic if any input matrix column is not normalized when `glam_assert` is enabled. fn to_euler( - _self: Ref, - order: Val, + _self: Ref<::glam::Mat3>, + order: Val<::glam::EulerRot>, ) -> (f32, f32, f32) { - let output: (f32, f32, f32) = bevy::math::Mat3::to_euler( - &_self, - order.into_inner(), - ) + let output: (f32, f32, f32) = ::glam::Mat3::to_euler(&_self, order.into_inner()) .into(); output } @@ -25516,10 +23446,10 @@ impl bevy::math::Mat3 { /// # Panics /// Will panic if the 2nd row of `self` is not `(0, 0, 1)` when `glam_assert` is enabled. fn transform_point2( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Mat3::transform_point2( + _self: Ref<::glam::Mat3>, + rhs: Val<::glam::Vec2>, + ) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Mat3::transform_point2( &_self, rhs.into_inner(), ) @@ -25532,10 +23462,10 @@ impl bevy::math::Mat3 { /// # Panics /// Will panic if the 2nd row of `self` is not `(0, 0, 1)` when `glam_assert` is enabled. fn transform_vector2( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Mat3::transform_vector2( + _self: Ref<::glam::Mat3>, + rhs: Val<::glam::Vec2>, + ) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Mat3::transform_vector2( &_self, rhs.into_inner(), ) @@ -25543,8 +23473,8 @@ impl bevy::math::Mat3 { output } /// Returns the transpose of `self`. - fn transpose(_self: Ref) -> Val { - let output: Val = bevy::math::Mat3::transpose(&_self).into(); + fn transpose(_self: Ref<::glam::Mat3>) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::Mat3::transpose(&_self).into(); output } } @@ -25554,10 +23484,10 @@ impl bevy::math::Mat3 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::Mat3A { +impl ::glam::Mat3A { /// Takes the absolute value of each element in `self` - fn abs(_self: Ref) -> Val { - let output: Val = bevy::math::Mat3A::abs(&_self).into(); + fn abs(_self: Ref<::glam::Mat3A>) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::abs(&_self).into(); output } /// Returns true if the absolute difference of all elements between `self` and `rhs` @@ -25568,11 +23498,11 @@ impl bevy::math::Mat3A { /// For more see /// [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/). fn abs_diff_eq( - _self: Ref, - rhs: Val, + _self: Ref<::glam::Mat3A>, + rhs: Val<::glam::Mat3A>, max_abs_diff: f32, ) -> bool { - let output: bool = bevy::math::Mat3A::abs_diff_eq( + let output: bool = ::glam::Mat3A::abs_diff_eq( &_self, rhs.into_inner(), max_abs_diff, @@ -25580,31 +23510,27 @@ impl bevy::math::Mat3A { .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Mat3A>) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Add< + ::glam::Mat3A, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } /// Adds two 3x3 matrices. fn add_mat3( - _self: Ref, - rhs: Ref, - ) -> Val { - let output: Val = bevy::math::Mat3A::add_mat3(&_self, &rhs) - .into(); + _self: Ref<::glam::Mat3A>, + rhs: Ref<::glam::Mat3A>, + ) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::add_mat3(&_self, &rhs).into(); output } - fn as_dmat3(_self: Ref) -> Val { - let output: Val = bevy::math::Mat3A::as_dmat3(&_self).into(); + fn as_dmat3(_self: Ref<::glam::Mat3A>) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::Mat3A::as_dmat3(&_self).into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::Mat3A>) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -25613,32 +23539,30 @@ impl bevy::math::Mat3A { /// Returns the matrix column for the given `index`. /// # Panics /// Panics if `index` is greater than 2. - fn col(_self: Ref, index: usize) -> Val { - let output: Val = bevy::math::Mat3A::col(&_self, index) - .into(); + fn col(_self: Ref<::glam::Mat3A>, index: usize) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Mat3A::col(&_self, index).into(); output } /// Returns the determinant of `self`. - fn determinant(_self: Ref) -> f32 { - let output: f32 = bevy::math::Mat3A::determinant(&_self).into(); + fn determinant(_self: Ref<::glam::Mat3A>) -> f32 { + let output: f32 = ::glam::Mat3A::determinant(&_self).into(); output } - fn div(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); output } /// Divides a 3x3 matrix by a scalar. - fn div_scalar(_self: Ref, rhs: f32) -> Val { - let output: Val = bevy::math::Mat3A::div_scalar(&_self, rhs) - .into(); + fn div_scalar(_self: Ref<::glam::Mat3A>, rhs: f32) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::div_scalar(&_self, rhs).into(); output } - fn eq(_self: Ref, rhs: Ref) -> bool { - let output: bool = , rhs: Ref<::glam::Mat3A>) -> bool { + let output: bool = <::glam::Mat3A as ::core::cmp::PartialEq< + ::glam::Mat3A, >>::eq(&_self, &rhs) .into(); output @@ -25647,19 +23571,16 @@ impl bevy::math::Mat3A { /// radians). /// The resulting matrix can be used to transform 2D points and vectors. See /// [`Self::transform_point2()`] and [`Self::transform_vector2()`]. - fn from_angle(angle: f32) -> Val { - let output: Val = bevy::math::Mat3A::from_angle(angle).into(); + fn from_angle(angle: f32) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_angle(angle).into(); output } /// Creates a 3D rotation matrix from a normalized rotation `axis` and `angle` (in /// radians). /// # Panics /// Will panic if `axis` is not normalized when `glam_assert` is enabled. - fn from_axis_angle( - axis: Val, - angle: f32, - ) -> Val { - let output: Val = bevy::math::Mat3A::from_axis_angle( + fn from_axis_angle(axis: Val<::glam::Vec3>, angle: f32) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_axis_angle( axis.into_inner(), angle, ) @@ -25668,11 +23589,11 @@ impl bevy::math::Mat3A { } /// Creates a 3x3 matrix from three column vectors. fn from_cols( - x_axis: Val, - y_axis: Val, - z_axis: Val, - ) -> Val { - let output: Val = bevy::math::Mat3A::from_cols( + x_axis: Val<::glam::Vec3A>, + y_axis: Val<::glam::Vec3A>, + z_axis: Val<::glam::Vec3A>, + ) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_cols( x_axis.into_inner(), y_axis.into_inner(), z_axis.into_inner(), @@ -25681,8 +23602,8 @@ impl bevy::math::Mat3A { output } /// Creates a 3x3 matrix with its diagonal set to `diagonal` and all other entries set to 0. - fn from_diagonal(diagonal: Val) -> Val { - let output: Val = bevy::math::Mat3A::from_diagonal( + fn from_diagonal(diagonal: Val<::glam::Vec3>) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_diagonal( diagonal.into_inner(), ) .into(); @@ -25691,12 +23612,12 @@ impl bevy::math::Mat3A { /// Creates a 3D rotation matrix from the given euler rotation sequence and the angles (in /// radians). fn from_euler( - order: Val, + order: Val<::glam::EulerRot>, a: f32, b: f32, c: f32, - ) -> Val { - let output: Val = bevy::math::Mat3A::from_euler( + ) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_euler( order.into_inner(), a, b, @@ -25708,27 +23629,21 @@ impl bevy::math::Mat3A { /// Creates an affine transformation matrix from the given 2x2 matrix. /// The resulting matrix can be used to transform 2D points and vectors. See /// [`Self::transform_point2()`] and [`Self::transform_vector2()`]. - fn from_mat2(m: Val) -> Val { - let output: Val = bevy::math::Mat3A::from_mat2(m.into_inner()) - .into(); + fn from_mat2(m: Val<::glam::Mat2>) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_mat2(m.into_inner()).into(); output } /// Creates a 3x3 matrix from a 4x4 matrix, discarding the 4th row and column. - fn from_mat4(m: Val) -> Val { - let output: Val = bevy::math::Mat3A::from_mat4(m.into_inner()) - .into(); + fn from_mat4(m: Val<::glam::Mat4>) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_mat4(m.into_inner()).into(); output } /// Creates a 3x3 matrix from the minor of the given 4x4 matrix, discarding the `i`th column /// and `j`th row. /// # Panics /// Panics if `i` or `j` is greater than 3. - fn from_mat4_minor( - m: Val, - i: usize, - j: usize, - ) -> Val { - let output: Val = bevy::math::Mat3A::from_mat4_minor( + fn from_mat4_minor(m: Val<::glam::Mat4>, i: usize, j: usize) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_mat4_minor( m.into_inner(), i, j, @@ -25739,29 +23654,24 @@ impl bevy::math::Mat3A { /// Creates a 3D rotation matrix from the given quaternion. /// # Panics /// Will panic if `rotation` is not normalized when `glam_assert` is enabled. - fn from_quat(rotation: Val) -> Val { - let output: Val = bevy::math::Mat3A::from_quat( - rotation.into_inner(), - ) + fn from_quat(rotation: Val<::glam::Quat>) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_quat(rotation.into_inner()) .into(); output } /// Creates a 3D rotation matrix from `angle` (in radians) around the x axis. - fn from_rotation_x(angle: f32) -> Val { - let output: Val = bevy::math::Mat3A::from_rotation_x(angle) - .into(); + fn from_rotation_x(angle: f32) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_rotation_x(angle).into(); output } /// Creates a 3D rotation matrix from `angle` (in radians) around the y axis. - fn from_rotation_y(angle: f32) -> Val { - let output: Val = bevy::math::Mat3A::from_rotation_y(angle) - .into(); + fn from_rotation_y(angle: f32) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_rotation_y(angle).into(); output } /// Creates a 3D rotation matrix from `angle` (in radians) around the z axis. - fn from_rotation_z(angle: f32) -> Val { - let output: Val = bevy::math::Mat3A::from_rotation_z(angle) - .into(); + fn from_rotation_z(angle: f32) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_rotation_z(angle).into(); output } /// Creates an affine transformation matrix from the given non-uniform 2D `scale`. @@ -25769,10 +23679,8 @@ impl bevy::math::Mat3A { /// [`Self::transform_point2()`] and [`Self::transform_vector2()`]. /// # Panics /// Will panic if all elements of `scale` are zero when `glam_assert` is enabled. - fn from_scale(scale: Val) -> Val { - let output: Val = bevy::math::Mat3A::from_scale( - scale.into_inner(), - ) + fn from_scale(scale: Val<::glam::Vec2>) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_scale(scale.into_inner()) .into(); output } @@ -25781,11 +23689,11 @@ impl bevy::math::Mat3A { /// The resulting matrix can be used to transform 2D points and vectors. See /// [`Self::transform_point2()`] and [`Self::transform_vector2()`]. fn from_scale_angle_translation( - scale: Val, + scale: Val<::glam::Vec2>, angle: f32, - translation: Val, - ) -> Val { - let output: Val = bevy::math::Mat3A::from_scale_angle_translation( + translation: Val<::glam::Vec2>, + ) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_scale_angle_translation( scale.into_inner(), angle, translation.into_inner(), @@ -25796,8 +23704,8 @@ impl bevy::math::Mat3A { /// Creates an affine transformation matrix from the given 2D `translation`. /// The resulting matrix can be used to transform 2D points and vectors. See /// [`Self::transform_point2()`] and [`Self::transform_vector2()`]. - fn from_translation(translation: Val) -> Val { - let output: Val = bevy::math::Mat3A::from_translation( + fn from_translation(translation: Val<::glam::Vec2>) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::from_translation( translation.into_inner(), ) .into(); @@ -25807,63 +23715,51 @@ impl bevy::math::Mat3A { /// If the matrix is not invertible the returned matrix will be invalid. /// # Panics /// Will panic if the determinant of `self` is zero when `glam_assert` is enabled. - fn inverse(_self: Ref) -> Val { - let output: Val = bevy::math::Mat3A::inverse(&_self).into(); + fn inverse(_self: Ref<::glam::Mat3A>) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::inverse(&_self).into(); output } /// Returns `true` if, and only if, all elements are finite. /// If any element is either `NaN`, positive or negative infinity, this will return `false`. - fn is_finite(_self: Ref) -> bool { - let output: bool = bevy::math::Mat3A::is_finite(&_self).into(); + fn is_finite(_self: Ref<::glam::Mat3A>) -> bool { + let output: bool = ::glam::Mat3A::is_finite(&_self).into(); output } /// Returns `true` if any elements are `NaN`. - fn is_nan(_self: Ref) -> bool { - let output: bool = bevy::math::Mat3A::is_nan(&_self).into(); + fn is_nan(_self: Ref<::glam::Mat3A>) -> bool { + let output: bool = ::glam::Mat3A::is_nan(&_self).into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Affine2>) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Mul< + ::glam::Affine2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Mat3A>) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Mul< + ::glam::Mat3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = <::glam::Mat3A as ::core::ops::Mul< + ::glam::Vec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec3A>) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = <::glam::Mat3A as ::core::ops::Mul< + ::glam::Vec3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); @@ -25871,45 +23767,37 @@ impl bevy::math::Mat3A { } /// Multiplies two 3x3 matrices. fn mul_mat3( - _self: Ref, - rhs: Ref, - ) -> Val { - let output: Val = bevy::math::Mat3A::mul_mat3(&_self, &rhs) - .into(); + _self: Ref<::glam::Mat3A>, + rhs: Ref<::glam::Mat3A>, + ) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::mul_mat3(&_self, &rhs).into(); output } /// Multiplies a 3x3 matrix by a scalar. - fn mul_scalar(_self: Ref, rhs: f32) -> Val { - let output: Val = bevy::math::Mat3A::mul_scalar(&_self, rhs) - .into(); + fn mul_scalar(_self: Ref<::glam::Mat3A>, rhs: f32) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::mul_scalar(&_self, rhs).into(); output } /// Transforms a 3D vector. - fn mul_vec3( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Mat3A::mul_vec3( - &_self, - rhs.into_inner(), - ) + fn mul_vec3(_self: Ref<::glam::Mat3A>, rhs: Val<::glam::Vec3>) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Mat3A::mul_vec3(&_self, rhs.into_inner()) .into(); output } /// Transforms a [`Vec3A`]. fn mul_vec3a( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Mat3A::mul_vec3a( + _self: Ref<::glam::Mat3A>, + rhs: Val<::glam::Vec3A>, + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Mat3A::mul_vec3a( &_self, rhs.into_inner(), ) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::Mat3A>) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -25918,40 +23806,35 @@ impl bevy::math::Mat3A { /// Returns the matrix row for the given `index`. /// # Panics /// Panics if `index` is greater than 2. - fn row(_self: Ref, index: usize) -> Val { - let output: Val = bevy::math::Mat3A::row(&_self, index) - .into(); + fn row(_self: Ref<::glam::Mat3A>, index: usize) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Mat3A::row(&_self, index).into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Mat3A>) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = <::glam::Mat3A as ::core::ops::Sub< + ::glam::Mat3A, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } /// Subtracts two 3x3 matrices. fn sub_mat3( - _self: Ref, - rhs: Ref, - ) -> Val { - let output: Val = bevy::math::Mat3A::sub_mat3(&_self, &rhs) - .into(); + _self: Ref<::glam::Mat3A>, + rhs: Ref<::glam::Mat3A>, + ) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::sub_mat3(&_self, &rhs).into(); output } /// Creates a `[f32; 9]` array storing data in column major order. /// If you require data in row major order `transpose` the matrix first. - fn to_cols_array(_self: Ref) -> [f32; 9] { - let output: [f32; 9] = bevy::math::Mat3A::to_cols_array(&_self).into(); + fn to_cols_array(_self: Ref<::glam::Mat3A>) -> [f32; 9] { + let output: [f32; 9] = ::glam::Mat3A::to_cols_array(&_self).into(); output } /// Creates a `[[f32; 3]; 3]` 3D array storing data in column major order. /// If you require data in row major order `transpose` the matrix first. - fn to_cols_array_2d(_self: Ref) -> [[f32; 3]; 3] { - let output: [[f32; 3]; 3] = bevy::math::Mat3A::to_cols_array_2d(&_self).into(); + fn to_cols_array_2d(_self: Ref<::glam::Mat3A>) -> [[f32; 3]; 3] { + let output: [[f32; 3]; 3] = ::glam::Mat3A::to_cols_array_2d(&_self).into(); output } /// Extract Euler angles with the given Euler rotation order. @@ -25960,13 +23843,10 @@ impl bevy::math::Mat3A { /// # Panics /// Will panic if any input matrix column is not normalized when `glam_assert` is enabled. fn to_euler( - _self: Ref, - order: Val, + _self: Ref<::glam::Mat3A>, + order: Val<::glam::EulerRot>, ) -> (f32, f32, f32) { - let output: (f32, f32, f32) = bevy::math::Mat3A::to_euler( - &_self, - order.into_inner(), - ) + let output: (f32, f32, f32) = ::glam::Mat3A::to_euler(&_self, order.into_inner()) .into(); output } @@ -25976,10 +23856,10 @@ impl bevy::math::Mat3A { /// # Panics /// Will panic if the 2nd row of `self` is not `(0, 0, 1)` when `glam_assert` is enabled. fn transform_point2( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Mat3A::transform_point2( + _self: Ref<::glam::Mat3A>, + rhs: Val<::glam::Vec2>, + ) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Mat3A::transform_point2( &_self, rhs.into_inner(), ) @@ -25992,10 +23872,10 @@ impl bevy::math::Mat3A { /// # Panics /// Will panic if the 2nd row of `self` is not `(0, 0, 1)` when `glam_assert` is enabled. fn transform_vector2( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Mat3A::transform_vector2( + _self: Ref<::glam::Mat3A>, + rhs: Val<::glam::Vec2>, + ) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Mat3A::transform_vector2( &_self, rhs.into_inner(), ) @@ -26003,8 +23883,8 @@ impl bevy::math::Mat3A { output } /// Returns the transpose of `self`. - fn transpose(_self: Ref) -> Val { - let output: Val = bevy::math::Mat3A::transpose(&_self).into(); + fn transpose(_self: Ref<::glam::Mat3A>) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = ::glam::Mat3A::transpose(&_self).into(); output } } @@ -26014,10 +23894,10 @@ impl bevy::math::Mat3A { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::Mat4 { +impl ::glam::Mat4 { /// Takes the absolute value of each element in `self` - fn abs(_self: Ref) -> Val { - let output: Val = bevy::math::Mat4::abs(&_self).into(); + fn abs(_self: Ref<::glam::Mat4>) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::abs(&_self).into(); output } /// Returns true if the absolute difference of all elements between `self` and `rhs` @@ -26028,11 +23908,11 @@ impl bevy::math::Mat4 { /// For more see /// [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/). fn abs_diff_eq( - _self: Ref, - rhs: Val, + _self: Ref<::glam::Mat4>, + rhs: Val<::glam::Mat4>, max_abs_diff: f32, ) -> bool { - let output: bool = bevy::math::Mat4::abs_diff_eq( + let output: bool = ::glam::Mat4::abs_diff_eq( &_self, rhs.into_inner(), max_abs_diff, @@ -26040,31 +23920,24 @@ impl bevy::math::Mat4 { .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Mat4>) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Add< + ::glam::Mat4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } /// Adds two 4x4 matrices. - fn add_mat4( - _self: Ref, - rhs: Ref, - ) -> Val { - let output: Val = bevy::math::Mat4::add_mat4(&_self, &rhs) - .into(); + fn add_mat4(_self: Ref<::glam::Mat4>, rhs: Ref<::glam::Mat4>) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::add_mat4(&_self, &rhs).into(); output } - fn as_dmat4(_self: Ref) -> Val { - let output: Val = bevy::math::Mat4::as_dmat4(&_self).into(); + fn as_dmat4(_self: Ref<::glam::Mat4>) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::Mat4::as_dmat4(&_self).into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::Mat4>) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -26073,31 +23946,30 @@ impl bevy::math::Mat4 { /// Returns the matrix column for the given `index`. /// # Panics /// Panics if `index` is greater than 3. - fn col(_self: Ref, index: usize) -> Val { - let output: Val = bevy::math::Mat4::col(&_self, index).into(); + fn col(_self: Ref<::glam::Mat4>, index: usize) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Mat4::col(&_self, index).into(); output } /// Returns the determinant of `self`. - fn determinant(_self: Ref) -> f32 { - let output: f32 = bevy::math::Mat4::determinant(&_self).into(); + fn determinant(_self: Ref<::glam::Mat4>) -> f32 { + let output: f32 = ::glam::Mat4::determinant(&_self).into(); output } - fn div(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Div< f32, >>::div(_self.into_inner(), rhs) .into(); output } /// Divides a 4x4 matrix by a scalar. - fn div_scalar(_self: Ref, rhs: f32) -> Val { - let output: Val = bevy::math::Mat4::div_scalar(&_self, rhs) - .into(); + fn div_scalar(_self: Ref<::glam::Mat4>, rhs: f32) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::div_scalar(&_self, rhs).into(); output } - fn eq(_self: Ref, rhs: Ref) -> bool { - let output: bool = , rhs: Ref<::glam::Mat4>) -> bool { + let output: bool = <::glam::Mat4 as ::core::cmp::PartialEq< + ::glam::Mat4, >>::eq(&_self, &rhs) .into(); output @@ -26108,11 +23980,8 @@ impl bevy::math::Mat4 { /// [`Self::transform_point3()`] and [`Self::transform_vector3()`]. /// # Panics /// Will panic if `axis` is not normalized when `glam_assert` is enabled. - fn from_axis_angle( - axis: Val, - angle: f32, - ) -> Val { - let output: Val = bevy::math::Mat4::from_axis_angle( + fn from_axis_angle(axis: Val<::glam::Vec3>, angle: f32) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::from_axis_angle( axis.into_inner(), angle, ) @@ -26121,12 +23990,12 @@ impl bevy::math::Mat4 { } /// Creates a 4x4 matrix from four column vectors. fn from_cols( - x_axis: Val, - y_axis: Val, - z_axis: Val, - w_axis: Val, - ) -> Val { - let output: Val = bevy::math::Mat4::from_cols( + x_axis: Val<::glam::Vec4>, + y_axis: Val<::glam::Vec4>, + z_axis: Val<::glam::Vec4>, + w_axis: Val<::glam::Vec4>, + ) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::from_cols( x_axis.into_inner(), y_axis.into_inner(), z_axis.into_inner(), @@ -26136,8 +24005,8 @@ impl bevy::math::Mat4 { output } /// Creates a 4x4 matrix with its diagonal set to `diagonal` and all other entries set to 0. - fn from_diagonal(diagonal: Val) -> Val { - let output: Val = bevy::math::Mat4::from_diagonal( + fn from_diagonal(diagonal: Val<::glam::Vec4>) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::from_diagonal( diagonal.into_inner(), ) .into(); @@ -26148,12 +24017,12 @@ impl bevy::math::Mat4 { /// The resulting matrix can be used to transform 3D points and vectors. See /// [`Self::transform_point3()`] and [`Self::transform_vector3()`]. fn from_euler( - order: Val, + order: Val<::glam::EulerRot>, a: f32, b: f32, c: f32, - ) -> Val { - let output: Val = bevy::math::Mat4::from_euler( + ) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::from_euler( order.into_inner(), a, b, @@ -26166,18 +24035,16 @@ impl bevy::math::Mat4 { /// matrix. /// The resulting matrix can be used to transform 3D points and vectors. See /// [`Self::transform_point3()`] and [`Self::transform_vector3()`]. - fn from_mat3(m: Val) -> Val { - let output: Val = bevy::math::Mat4::from_mat3(m.into_inner()) - .into(); + fn from_mat3(m: Val<::glam::Mat3>) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::from_mat3(m.into_inner()).into(); output } /// Creates an affine transformation matrix from the given 3x3 linear transformation /// matrix. /// The resulting matrix can be used to transform 3D points and vectors. See /// [`Self::transform_point3()`] and [`Self::transform_vector3()`]. - fn from_mat3a(m: Val) -> Val { - let output: Val = bevy::math::Mat4::from_mat3a(m.into_inner()) - .into(); + fn from_mat3a(m: Val<::glam::Mat3A>) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::from_mat3a(m.into_inner()).into(); output } /// Creates an affine transformation matrix from the given `rotation` quaternion. @@ -26185,10 +24052,8 @@ impl bevy::math::Mat4 { /// [`Self::transform_point3()`] and [`Self::transform_vector3()`]. /// # Panics /// Will panic if `rotation` is not normalized when `glam_assert` is enabled. - fn from_quat(rotation: Val) -> Val { - let output: Val = bevy::math::Mat4::from_quat( - rotation.into_inner(), - ) + fn from_quat(rotation: Val<::glam::Quat>) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::from_quat(rotation.into_inner()) .into(); output } @@ -26198,10 +24063,10 @@ impl bevy::math::Mat4 { /// # Panics /// Will panic if `rotation` is not normalized when `glam_assert` is enabled. fn from_rotation_translation( - rotation: Val, - translation: Val, - ) -> Val { - let output: Val = bevy::math::Mat4::from_rotation_translation( + rotation: Val<::glam::Quat>, + translation: Val<::glam::Vec3>, + ) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::from_rotation_translation( rotation.into_inner(), translation.into_inner(), ) @@ -26212,27 +24077,24 @@ impl bevy::math::Mat4 { /// `angle` (in radians). /// The resulting matrix can be used to transform 3D points and vectors. See /// [`Self::transform_point3()`] and [`Self::transform_vector3()`]. - fn from_rotation_x(angle: f32) -> Val { - let output: Val = bevy::math::Mat4::from_rotation_x(angle) - .into(); + fn from_rotation_x(angle: f32) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::from_rotation_x(angle).into(); output } /// Creates an affine transformation matrix containing a 3D rotation around the y axis of /// `angle` (in radians). /// The resulting matrix can be used to transform 3D points and vectors. See /// [`Self::transform_point3()`] and [`Self::transform_vector3()`]. - fn from_rotation_y(angle: f32) -> Val { - let output: Val = bevy::math::Mat4::from_rotation_y(angle) - .into(); + fn from_rotation_y(angle: f32) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::from_rotation_y(angle).into(); output } /// Creates an affine transformation matrix containing a 3D rotation around the z axis of /// `angle` (in radians). /// The resulting matrix can be used to transform 3D points and vectors. See /// [`Self::transform_point3()`] and [`Self::transform_vector3()`]. - fn from_rotation_z(angle: f32) -> Val { - let output: Val = bevy::math::Mat4::from_rotation_z(angle) - .into(); + fn from_rotation_z(angle: f32) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::from_rotation_z(angle).into(); output } /// Creates an affine transformation matrix containing the given 3D non-uniform `scale`. @@ -26240,10 +24102,8 @@ impl bevy::math::Mat4 { /// [`Self::transform_point3()`] and [`Self::transform_vector3()`]. /// # Panics /// Will panic if all elements of `scale` are zero when `glam_assert` is enabled. - fn from_scale(scale: Val) -> Val { - let output: Val = bevy::math::Mat4::from_scale( - scale.into_inner(), - ) + fn from_scale(scale: Val<::glam::Vec3>) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::from_scale(scale.into_inner()) .into(); output } @@ -26254,11 +24114,11 @@ impl bevy::math::Mat4 { /// # Panics /// Will panic if `rotation` is not normalized when `glam_assert` is enabled. fn from_scale_rotation_translation( - scale: Val, - rotation: Val, - translation: Val, - ) -> Val { - let output: Val = bevy::math::Mat4::from_scale_rotation_translation( + scale: Val<::glam::Vec3>, + rotation: Val<::glam::Quat>, + translation: Val<::glam::Vec3>, + ) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::from_scale_rotation_translation( scale.into_inner(), rotation.into_inner(), translation.into_inner(), @@ -26269,8 +24129,8 @@ impl bevy::math::Mat4 { /// Creates an affine transformation matrix from the given 3D `translation`. /// The resulting matrix can be used to transform 3D points and vectors. See /// [`Self::transform_point3()`] and [`Self::transform_vector3()`]. - fn from_translation(translation: Val) -> Val { - let output: Val = bevy::math::Mat4::from_translation( + fn from_translation(translation: Val<::glam::Vec3>) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::from_translation( translation.into_inner(), ) .into(); @@ -26280,19 +24140,19 @@ impl bevy::math::Mat4 { /// If the matrix is not invertible the returned matrix will be invalid. /// # Panics /// Will panic if the determinant of `self` is zero when `glam_assert` is enabled. - fn inverse(_self: Ref) -> Val { - let output: Val = bevy::math::Mat4::inverse(&_self).into(); + fn inverse(_self: Ref<::glam::Mat4>) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::inverse(&_self).into(); output } /// Returns `true` if, and only if, all elements are finite. /// If any element is either `NaN`, positive or negative infinity, this will return `false`. - fn is_finite(_self: Ref) -> bool { - let output: bool = bevy::math::Mat4::is_finite(&_self).into(); + fn is_finite(_self: Ref<::glam::Mat4>) -> bool { + let output: bool = ::glam::Mat4::is_finite(&_self).into(); output } /// Returns `true` if any elements are `NaN`. - fn is_nan(_self: Ref) -> bool { - let output: bool = bevy::math::Mat4::is_nan(&_self).into(); + fn is_nan(_self: Ref<::glam::Mat4>) -> bool { + let output: bool = ::glam::Mat4::is_nan(&_self).into(); output } /// Creates a left-handed view matrix using a camera position, an up direction, and a focal @@ -26301,11 +24161,11 @@ impl bevy::math::Mat4 { /// # Panics /// Will panic if `up` is not normalized when `glam_assert` is enabled. fn look_at_lh( - eye: Val, - center: Val, - up: Val, - ) -> Val { - let output: Val = bevy::math::Mat4::look_at_lh( + eye: Val<::glam::Vec3>, + center: Val<::glam::Vec3>, + up: Val<::glam::Vec3>, + ) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::look_at_lh( eye.into_inner(), center.into_inner(), up.into_inner(), @@ -26319,11 +24179,11 @@ impl bevy::math::Mat4 { /// # Panics /// Will panic if `up` is not normalized when `glam_assert` is enabled. fn look_at_rh( - eye: Val, - center: Val, - up: Val, - ) -> Val { - let output: Val = bevy::math::Mat4::look_at_rh( + eye: Val<::glam::Vec3>, + center: Val<::glam::Vec3>, + up: Val<::glam::Vec3>, + ) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::look_at_rh( eye.into_inner(), center.into_inner(), up.into_inner(), @@ -26335,11 +24195,11 @@ impl bevy::math::Mat4 { /// direction. /// For a view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`. fn look_to_lh( - eye: Val, - dir: Val, - up: Val, - ) -> Val { - let output: Val = bevy::math::Mat4::look_to_lh( + eye: Val<::glam::Vec3>, + dir: Val<::glam::Vec3>, + up: Val<::glam::Vec3>, + ) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::look_to_lh( eye.into_inner(), dir.into_inner(), up.into_inner(), @@ -26351,11 +24211,11 @@ impl bevy::math::Mat4 { /// direction. /// For a view coordinate system with `+X=right`, `+Y=up` and `+Z=back`. fn look_to_rh( - eye: Val, - dir: Val, - up: Val, - ) -> Val { - let output: Val = bevy::math::Mat4::look_to_rh( + eye: Val<::glam::Vec3>, + dir: Val<::glam::Vec3>, + up: Val<::glam::Vec3>, + ) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::look_to_rh( eye.into_inner(), dir.into_inner(), up.into_inner(), @@ -26363,72 +24223,52 @@ impl bevy::math::Mat4 { .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Affine3A>) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Mul< + ::glam::Affine3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Mat4>) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Mul< + ::glam::Mat4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = <::glam::Mat4 as ::core::ops::Mul< + ::glam::Vec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: f32) -> Val { - let output: Val = , rhs: f32) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Mul< f32, >>::mul(_self.into_inner(), rhs) .into(); output } /// Multiplies two 4x4 matrices. - fn mul_mat4( - _self: Ref, - rhs: Ref, - ) -> Val { - let output: Val = bevy::math::Mat4::mul_mat4(&_self, &rhs) - .into(); + fn mul_mat4(_self: Ref<::glam::Mat4>, rhs: Ref<::glam::Mat4>) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::mul_mat4(&_self, &rhs).into(); output } /// Multiplies a 4x4 matrix by a scalar. - fn mul_scalar(_self: Ref, rhs: f32) -> Val { - let output: Val = bevy::math::Mat4::mul_scalar(&_self, rhs) - .into(); + fn mul_scalar(_self: Ref<::glam::Mat4>, rhs: f32) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::mul_scalar(&_self, rhs).into(); output } /// Transforms a 4D vector. - fn mul_vec4( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Mat4::mul_vec4( - &_self, - rhs.into_inner(), - ) + fn mul_vec4(_self: Ref<::glam::Mat4>, rhs: Val<::glam::Vec4>) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Mat4::mul_vec4(&_self, rhs.into_inner()) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::Mat4>) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -26443,8 +24283,8 @@ impl bevy::math::Mat4 { top: f32, near: f32, far: f32, - ) -> Val { - let output: Val = bevy::math::Mat4::orthographic_lh( + ) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::orthographic_lh( left, right, bottom, @@ -26464,8 +24304,8 @@ impl bevy::math::Mat4 { top: f32, near: f32, far: f32, - ) -> Val { - let output: Val = bevy::math::Mat4::orthographic_rh( + ) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::orthographic_rh( left, right, bottom, @@ -26488,8 +24328,8 @@ impl bevy::math::Mat4 { top: f32, near: f32, far: f32, - ) -> Val { - let output: Val = bevy::math::Mat4::orthographic_rh_gl( + ) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::orthographic_rh_gl( left, right, bottom, @@ -26510,8 +24350,8 @@ impl bevy::math::Mat4 { fov_y_radians: f32, aspect_ratio: f32, z_near: f32, - ) -> Val { - let output: Val = bevy::math::Mat4::perspective_infinite_lh( + ) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::perspective_infinite_lh( fov_y_radians, aspect_ratio, z_near, @@ -26527,8 +24367,8 @@ impl bevy::math::Mat4 { fov_y_radians: f32, aspect_ratio: f32, z_near: f32, - ) -> Val { - let output: Val = bevy::math::Mat4::perspective_infinite_reverse_lh( + ) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::perspective_infinite_reverse_lh( fov_y_radians, aspect_ratio, z_near, @@ -26544,8 +24384,8 @@ impl bevy::math::Mat4 { fov_y_radians: f32, aspect_ratio: f32, z_near: f32, - ) -> Val { - let output: Val = bevy::math::Mat4::perspective_infinite_reverse_rh( + ) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::perspective_infinite_reverse_rh( fov_y_radians, aspect_ratio, z_near, @@ -26563,8 +24403,8 @@ impl bevy::math::Mat4 { fov_y_radians: f32, aspect_ratio: f32, z_near: f32, - ) -> Val { - let output: Val = bevy::math::Mat4::perspective_infinite_rh( + ) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::perspective_infinite_rh( fov_y_radians, aspect_ratio, z_near, @@ -26582,8 +24422,8 @@ impl bevy::math::Mat4 { aspect_ratio: f32, z_near: f32, z_far: f32, - ) -> Val { - let output: Val = bevy::math::Mat4::perspective_lh( + ) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::perspective_lh( fov_y_radians, aspect_ratio, z_near, @@ -26602,8 +24442,8 @@ impl bevy::math::Mat4 { aspect_ratio: f32, z_near: f32, z_far: f32, - ) -> Val { - let output: Val = bevy::math::Mat4::perspective_rh( + ) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::perspective_rh( fov_y_radians, aspect_ratio, z_near, @@ -26621,8 +24461,8 @@ impl bevy::math::Mat4 { aspect_ratio: f32, z_near: f32, z_far: f32, - ) -> Val { - let output: Val = bevy::math::Mat4::perspective_rh_gl( + ) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::perspective_rh_gl( fov_y_radians, aspect_ratio, z_near, @@ -26636,10 +24476,10 @@ impl bevy::math::Mat4 { /// The perspective divide is performed meaning the resulting 3D vector is divided by `w`. /// This method assumes that `self` contains a projective transform. fn project_point3( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Mat4::project_point3( + _self: Ref<::glam::Mat4>, + rhs: Val<::glam::Vec3>, + ) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Mat4::project_point3( &_self, rhs.into_inner(), ) @@ -26651,10 +24491,10 @@ impl bevy::math::Mat4 { /// The perspective divide is performed meaning the resulting 3D vector is divided by `w`. /// This method assumes that `self` contains a projective transform. fn project_point3a( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Mat4::project_point3a( + _self: Ref<::glam::Mat4>, + rhs: Val<::glam::Vec3A>, + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Mat4::project_point3a( &_self, rhs.into_inner(), ) @@ -26664,39 +24504,32 @@ impl bevy::math::Mat4 { /// Returns the matrix row for the given `index`. /// # Panics /// Panics if `index` is greater than 3. - fn row(_self: Ref, index: usize) -> Val { - let output: Val = bevy::math::Mat4::row(&_self, index).into(); + fn row(_self: Ref<::glam::Mat4>, index: usize) -> Val<::glam::Vec4> { + let output: Val<::glam::Vec4> = ::glam::Mat4::row(&_self, index).into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Mat4>) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = <::glam::Mat4 as ::core::ops::Sub< + ::glam::Mat4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } /// Subtracts two 4x4 matrices. - fn sub_mat4( - _self: Ref, - rhs: Ref, - ) -> Val { - let output: Val = bevy::math::Mat4::sub_mat4(&_self, &rhs) - .into(); + fn sub_mat4(_self: Ref<::glam::Mat4>, rhs: Ref<::glam::Mat4>) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::sub_mat4(&_self, &rhs).into(); output } /// Creates a `[f32; 16]` array storing data in column major order. /// If you require data in row major order `transpose` the matrix first. - fn to_cols_array(_self: Ref) -> [f32; 16] { - let output: [f32; 16] = bevy::math::Mat4::to_cols_array(&_self).into(); + fn to_cols_array(_self: Ref<::glam::Mat4>) -> [f32; 16] { + let output: [f32; 16] = ::glam::Mat4::to_cols_array(&_self).into(); output } /// Creates a `[[f32; 4]; 4]` 4D array storing data in column major order. /// If you require data in row major order `transpose` the matrix first. - fn to_cols_array_2d(_self: Ref) -> [[f32; 4]; 4] { - let output: [[f32; 4]; 4] = bevy::math::Mat4::to_cols_array_2d(&_self).into(); + fn to_cols_array_2d(_self: Ref<::glam::Mat4>) -> [[f32; 4]; 4] { + let output: [[f32; 4]; 4] = ::glam::Mat4::to_cols_array_2d(&_self).into(); output } /// Extract Euler angles with the given Euler rotation order. @@ -26706,13 +24539,10 @@ impl bevy::math::Mat4 { /// Will panic if any column of the upper 3x3 rotation matrix is not normalized when /// `glam_assert` is enabled. fn to_euler( - _self: Ref, - order: Val, + _self: Ref<::glam::Mat4>, + order: Val<::glam::EulerRot>, ) -> (f32, f32, f32) { - let output: (f32, f32, f32) = bevy::math::Mat4::to_euler( - &_self, - order.into_inner(), - ) + let output: (f32, f32, f32) = ::glam::Mat4::to_euler(&_self, order.into_inner()) .into(); output } @@ -26725,10 +24555,10 @@ impl bevy::math::Mat4 { /// # Panics /// Will panic if the 3rd row of `self` is not `(0, 0, 0, 1)` when `glam_assert` is enabled. fn transform_point3( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Mat4::transform_point3( + _self: Ref<::glam::Mat4>, + rhs: Val<::glam::Vec3>, + ) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Mat4::transform_point3( &_self, rhs.into_inner(), ) @@ -26738,10 +24568,10 @@ impl bevy::math::Mat4 { /// Transforms the given [`Vec3A`] as 3D point. /// This is the equivalent of multiplying the [`Vec3A`] as a 4D vector where `w` is `1.0`. fn transform_point3a( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Mat4::transform_point3a( + _self: Ref<::glam::Mat4>, + rhs: Val<::glam::Vec3A>, + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Mat4::transform_point3a( &_self, rhs.into_inner(), ) @@ -26755,10 +24585,10 @@ impl bevy::math::Mat4 { /// # Panics /// Will panic if the 3rd row of `self` is not `(0, 0, 0, 1)` when `glam_assert` is enabled. fn transform_vector3( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Mat4::transform_vector3( + _self: Ref<::glam::Mat4>, + rhs: Val<::glam::Vec3>, + ) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Mat4::transform_vector3( &_self, rhs.into_inner(), ) @@ -26768,10 +24598,10 @@ impl bevy::math::Mat4 { /// Transforms the give [`Vec3A`] as 3D vector. /// This is the equivalent of multiplying the [`Vec3A`] as a 4D vector where `w` is `0.0`. fn transform_vector3a( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Mat4::transform_vector3a( + _self: Ref<::glam::Mat4>, + rhs: Val<::glam::Vec3A>, + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Mat4::transform_vector3a( &_self, rhs.into_inner(), ) @@ -26779,8 +24609,8 @@ impl bevy::math::Mat4 { output } /// Returns the transpose of `self`. - fn transpose(_self: Ref) -> Val { - let output: Val = bevy::math::Mat4::transpose(&_self).into(); + fn transpose(_self: Ref<::glam::Mat4>) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::Mat4::transpose(&_self).into(); output } } @@ -26790,10 +24620,10 @@ impl bevy::math::Mat4 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::DMat2 { +impl ::glam::DMat2 { /// Takes the absolute value of each element in `self` - fn abs(_self: Ref) -> Val { - let output: Val = bevy::math::DMat2::abs(&_self).into(); + fn abs(_self: Ref<::glam::DMat2>) -> Val<::glam::DMat2> { + let output: Val<::glam::DMat2> = ::glam::DMat2::abs(&_self).into(); output } /// Returns true if the absolute difference of all elements between `self` and `rhs` @@ -26804,11 +24634,11 @@ impl bevy::math::DMat2 { /// For more see /// [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/). fn abs_diff_eq( - _self: Ref, - rhs: Val, + _self: Ref<::glam::DMat2>, + rhs: Val<::glam::DMat2>, max_abs_diff: f64, ) -> bool { - let output: bool = bevy::math::DMat2::abs_diff_eq( + let output: bool = ::glam::DMat2::abs_diff_eq( &_self, rhs.into_inner(), max_abs_diff, @@ -26816,31 +24646,27 @@ impl bevy::math::DMat2 { .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DMat2>) -> Val<::glam::DMat2> { + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Add< + ::glam::DMat2, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } /// Adds two 2x2 matrices. fn add_mat2( - _self: Ref, - rhs: Ref, - ) -> Val { - let output: Val = bevy::math::DMat2::add_mat2(&_self, &rhs) - .into(); + _self: Ref<::glam::DMat2>, + rhs: Ref<::glam::DMat2>, + ) -> Val<::glam::DMat2> { + let output: Val<::glam::DMat2> = ::glam::DMat2::add_mat2(&_self, &rhs).into(); output } - fn as_mat2(_self: Ref) -> Val { - let output: Val = bevy::math::DMat2::as_mat2(&_self).into(); + fn as_mat2(_self: Ref<::glam::DMat2>) -> Val<::glam::Mat2> { + let output: Val<::glam::Mat2> = ::glam::DMat2::as_mat2(&_self).into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::DMat2>) -> Val<::glam::DMat2> { + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -26849,47 +24675,45 @@ impl bevy::math::DMat2 { /// Returns the matrix column for the given `index`. /// # Panics /// Panics if `index` is greater than 1. - fn col(_self: Ref, index: usize) -> Val { - let output: Val = bevy::math::DMat2::col(&_self, index) - .into(); + fn col(_self: Ref<::glam::DMat2>, index: usize) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DMat2::col(&_self, index).into(); output } /// Returns the determinant of `self`. - fn determinant(_self: Ref) -> f64 { - let output: f64 = bevy::math::DMat2::determinant(&_self).into(); + fn determinant(_self: Ref<::glam::DMat2>) -> f64 { + let output: f64 = ::glam::DMat2::determinant(&_self).into(); output } - fn div(_self: Val, rhs: f64) -> Val { - let output: Val = , rhs: f64) -> Val<::glam::DMat2> { + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Div< f64, >>::div(_self.into_inner(), rhs) .into(); output } /// Divides a 2x2 matrix by a scalar. - fn div_scalar(_self: Ref, rhs: f64) -> Val { - let output: Val = bevy::math::DMat2::div_scalar(&_self, rhs) - .into(); + fn div_scalar(_self: Ref<::glam::DMat2>, rhs: f64) -> Val<::glam::DMat2> { + let output: Val<::glam::DMat2> = ::glam::DMat2::div_scalar(&_self, rhs).into(); output } - fn eq(_self: Ref, rhs: Ref) -> bool { - let output: bool = , rhs: Ref<::glam::DMat2>) -> bool { + let output: bool = <::glam::DMat2 as ::core::cmp::PartialEq< + ::glam::DMat2, >>::eq(&_self, &rhs) .into(); output } /// Creates a 2x2 matrix containing a rotation of `angle` (in radians). - fn from_angle(angle: f64) -> Val { - let output: Val = bevy::math::DMat2::from_angle(angle).into(); + fn from_angle(angle: f64) -> Val<::glam::DMat2> { + let output: Val<::glam::DMat2> = ::glam::DMat2::from_angle(angle).into(); output } /// Creates a 2x2 matrix from two column vectors. fn from_cols( - x_axis: Val, - y_axis: Val, - ) -> Val { - let output: Val = bevy::math::DMat2::from_cols( + x_axis: Val<::glam::DVec2>, + y_axis: Val<::glam::DVec2>, + ) -> Val<::glam::DMat2> { + let output: Val<::glam::DMat2> = ::glam::DMat2::from_cols( x_axis.into_inner(), y_axis.into_inner(), ) @@ -26897,29 +24721,24 @@ impl bevy::math::DMat2 { output } /// Creates a 2x2 matrix with its diagonal set to `diagonal` and all other entries set to 0. - fn from_diagonal(diagonal: Val) -> Val { - let output: Val = bevy::math::DMat2::from_diagonal( + fn from_diagonal(diagonal: Val<::glam::DVec2>) -> Val<::glam::DMat2> { + let output: Val<::glam::DMat2> = ::glam::DMat2::from_diagonal( diagonal.into_inner(), ) .into(); output } /// Creates a 2x2 matrix from a 3x3 matrix, discarding the 2nd row and column. - fn from_mat3(m: Val) -> Val { - let output: Val = bevy::math::DMat2::from_mat3(m.into_inner()) - .into(); + fn from_mat3(m: Val<::glam::DMat3>) -> Val<::glam::DMat2> { + let output: Val<::glam::DMat2> = ::glam::DMat2::from_mat3(m.into_inner()).into(); output } /// Creates a 2x2 matrix from the minor of the given 3x3 matrix, discarding the `i`th column /// and `j`th row. /// # Panics /// Panics if `i` or `j` is greater than 2. - fn from_mat3_minor( - m: Val, - i: usize, - j: usize, - ) -> Val { - let output: Val = bevy::math::DMat2::from_mat3_minor( + fn from_mat3_minor(m: Val<::glam::DMat3>, i: usize, j: usize) -> Val<::glam::DMat2> { + let output: Val<::glam::DMat2> = ::glam::DMat2::from_mat3_minor( m.into_inner(), i, j, @@ -26929,11 +24748,8 @@ impl bevy::math::DMat2 { } /// Creates a 2x2 matrix containing the combining non-uniform `scale` and rotation of /// `angle` (in radians). - fn from_scale_angle( - scale: Val, - angle: f64, - ) -> Val { - let output: Val = bevy::math::DMat2::from_scale_angle( + fn from_scale_angle(scale: Val<::glam::DVec2>, angle: f64) -> Val<::glam::DMat2> { + let output: Val<::glam::DMat2> = ::glam::DMat2::from_scale_angle( scale.into_inner(), angle, ) @@ -26944,43 +24760,37 @@ impl bevy::math::DMat2 { /// If the matrix is not invertible the returned matrix will be invalid. /// # Panics /// Will panic if the determinant of `self` is zero when `glam_assert` is enabled. - fn inverse(_self: Ref) -> Val { - let output: Val = bevy::math::DMat2::inverse(&_self).into(); + fn inverse(_self: Ref<::glam::DMat2>) -> Val<::glam::DMat2> { + let output: Val<::glam::DMat2> = ::glam::DMat2::inverse(&_self).into(); output } /// Returns `true` if, and only if, all elements are finite. /// If any element is either `NaN`, positive or negative infinity, this will return `false`. - fn is_finite(_self: Ref) -> bool { - let output: bool = bevy::math::DMat2::is_finite(&_self).into(); + fn is_finite(_self: Ref<::glam::DMat2>) -> bool { + let output: bool = ::glam::DMat2::is_finite(&_self).into(); output } /// Returns `true` if any elements are `NaN`. - fn is_nan(_self: Ref) -> bool { - let output: bool = bevy::math::DMat2::is_nan(&_self).into(); + fn is_nan(_self: Ref<::glam::DMat2>) -> bool { + let output: bool = ::glam::DMat2::is_nan(&_self).into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DMat2>) -> Val<::glam::DMat2> { + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Mul< + ::glam::DMat2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DVec2>) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = <::glam::DMat2 as ::core::ops::Mul< + ::glam::DVec2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: f64) -> Val { - let output: Val = , rhs: f64) -> Val<::glam::DMat2> { + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Mul< f64, >>::mul(_self.into_inner(), rhs) .into(); @@ -26988,33 +24798,31 @@ impl bevy::math::DMat2 { } /// Multiplies two 2x2 matrices. fn mul_mat2( - _self: Ref, - rhs: Ref, - ) -> Val { - let output: Val = bevy::math::DMat2::mul_mat2(&_self, &rhs) - .into(); + _self: Ref<::glam::DMat2>, + rhs: Ref<::glam::DMat2>, + ) -> Val<::glam::DMat2> { + let output: Val<::glam::DMat2> = ::glam::DMat2::mul_mat2(&_self, &rhs).into(); output } /// Multiplies a 2x2 matrix by a scalar. - fn mul_scalar(_self: Ref, rhs: f64) -> Val { - let output: Val = bevy::math::DMat2::mul_scalar(&_self, rhs) - .into(); + fn mul_scalar(_self: Ref<::glam::DMat2>, rhs: f64) -> Val<::glam::DMat2> { + let output: Val<::glam::DMat2> = ::glam::DMat2::mul_scalar(&_self, rhs).into(); output } /// Transforms a 2D vector. fn mul_vec2( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DMat2::mul_vec2( + _self: Ref<::glam::DMat2>, + rhs: Val<::glam::DVec2>, + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DMat2::mul_vec2( &_self, rhs.into_inner(), ) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::DMat2>) -> Val<::glam::DMat2> { + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -27023,45 +24831,40 @@ impl bevy::math::DMat2 { /// Returns the matrix row for the given `index`. /// # Panics /// Panics if `index` is greater than 1. - fn row(_self: Ref, index: usize) -> Val { - let output: Val = bevy::math::DMat2::row(&_self, index) - .into(); + fn row(_self: Ref<::glam::DMat2>, index: usize) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DMat2::row(&_self, index).into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DMat2>) -> Val<::glam::DMat2> { + let output: Val<::glam::DMat2> = <::glam::DMat2 as ::core::ops::Sub< + ::glam::DMat2, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } /// Subtracts two 2x2 matrices. fn sub_mat2( - _self: Ref, - rhs: Ref, - ) -> Val { - let output: Val = bevy::math::DMat2::sub_mat2(&_self, &rhs) - .into(); + _self: Ref<::glam::DMat2>, + rhs: Ref<::glam::DMat2>, + ) -> Val<::glam::DMat2> { + let output: Val<::glam::DMat2> = ::glam::DMat2::sub_mat2(&_self, &rhs).into(); output } /// Creates a `[f64; 4]` array storing data in column major order. /// If you require data in row major order `transpose` the matrix first. - fn to_cols_array(_self: Ref) -> [f64; 4] { - let output: [f64; 4] = bevy::math::DMat2::to_cols_array(&_self).into(); + fn to_cols_array(_self: Ref<::glam::DMat2>) -> [f64; 4] { + let output: [f64; 4] = ::glam::DMat2::to_cols_array(&_self).into(); output } /// Creates a `[[f64; 2]; 2]` 2D array storing data in column major order. /// If you require data in row major order `transpose` the matrix first. - fn to_cols_array_2d(_self: Ref) -> [[f64; 2]; 2] { - let output: [[f64; 2]; 2] = bevy::math::DMat2::to_cols_array_2d(&_self).into(); + fn to_cols_array_2d(_self: Ref<::glam::DMat2>) -> [[f64; 2]; 2] { + let output: [[f64; 2]; 2] = ::glam::DMat2::to_cols_array_2d(&_self).into(); output } /// Returns the transpose of `self`. - fn transpose(_self: Ref) -> Val { - let output: Val = bevy::math::DMat2::transpose(&_self).into(); + fn transpose(_self: Ref<::glam::DMat2>) -> Val<::glam::DMat2> { + let output: Val<::glam::DMat2> = ::glam::DMat2::transpose(&_self).into(); output } } @@ -27071,10 +24874,10 @@ impl bevy::math::DMat2 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::DMat3 { +impl ::glam::DMat3 { /// Takes the absolute value of each element in `self` - fn abs(_self: Ref) -> Val { - let output: Val = bevy::math::DMat3::abs(&_self).into(); + fn abs(_self: Ref<::glam::DMat3>) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::DMat3::abs(&_self).into(); output } /// Returns true if the absolute difference of all elements between `self` and `rhs` @@ -27085,11 +24888,11 @@ impl bevy::math::DMat3 { /// For more see /// [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/). fn abs_diff_eq( - _self: Ref, - rhs: Val, + _self: Ref<::glam::DMat3>, + rhs: Val<::glam::DMat3>, max_abs_diff: f64, ) -> bool { - let output: bool = bevy::math::DMat3::abs_diff_eq( + let output: bool = ::glam::DMat3::abs_diff_eq( &_self, rhs.into_inner(), max_abs_diff, @@ -27097,31 +24900,27 @@ impl bevy::math::DMat3 { .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DMat3>) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Add< + ::glam::DMat3, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } /// Adds two 3x3 matrices. fn add_mat3( - _self: Ref, - rhs: Ref, - ) -> Val { - let output: Val = bevy::math::DMat3::add_mat3(&_self, &rhs) - .into(); + _self: Ref<::glam::DMat3>, + rhs: Ref<::glam::DMat3>, + ) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::DMat3::add_mat3(&_self, &rhs).into(); output } - fn as_mat3(_self: Ref) -> Val { - let output: Val = bevy::math::DMat3::as_mat3(&_self).into(); + fn as_mat3(_self: Ref<::glam::DMat3>) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = ::glam::DMat3::as_mat3(&_self).into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::DMat3>) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -27130,32 +24929,30 @@ impl bevy::math::DMat3 { /// Returns the matrix column for the given `index`. /// # Panics /// Panics if `index` is greater than 2. - fn col(_self: Ref, index: usize) -> Val { - let output: Val = bevy::math::DMat3::col(&_self, index) - .into(); + fn col(_self: Ref<::glam::DMat3>, index: usize) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DMat3::col(&_self, index).into(); output } /// Returns the determinant of `self`. - fn determinant(_self: Ref) -> f64 { - let output: f64 = bevy::math::DMat3::determinant(&_self).into(); + fn determinant(_self: Ref<::glam::DMat3>) -> f64 { + let output: f64 = ::glam::DMat3::determinant(&_self).into(); output } - fn div(_self: Val, rhs: f64) -> Val { - let output: Val = , rhs: f64) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Div< f64, >>::div(_self.into_inner(), rhs) .into(); output } /// Divides a 3x3 matrix by a scalar. - fn div_scalar(_self: Ref, rhs: f64) -> Val { - let output: Val = bevy::math::DMat3::div_scalar(&_self, rhs) - .into(); + fn div_scalar(_self: Ref<::glam::DMat3>, rhs: f64) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::DMat3::div_scalar(&_self, rhs).into(); output } - fn eq(_self: Ref, rhs: Ref) -> bool { - let output: bool = , rhs: Ref<::glam::DMat3>) -> bool { + let output: bool = <::glam::DMat3 as ::core::cmp::PartialEq< + ::glam::DMat3, >>::eq(&_self, &rhs) .into(); output @@ -27164,19 +24961,16 @@ impl bevy::math::DMat3 { /// radians). /// The resulting matrix can be used to transform 2D points and vectors. See /// [`Self::transform_point2()`] and [`Self::transform_vector2()`]. - fn from_angle(angle: f64) -> Val { - let output: Val = bevy::math::DMat3::from_angle(angle).into(); + fn from_angle(angle: f64) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::DMat3::from_angle(angle).into(); output } /// Creates a 3D rotation matrix from a normalized rotation `axis` and `angle` (in /// radians). /// # Panics /// Will panic if `axis` is not normalized when `glam_assert` is enabled. - fn from_axis_angle( - axis: Val, - angle: f64, - ) -> Val { - let output: Val = bevy::math::DMat3::from_axis_angle( + fn from_axis_angle(axis: Val<::glam::DVec3>, angle: f64) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::DMat3::from_axis_angle( axis.into_inner(), angle, ) @@ -27185,11 +24979,11 @@ impl bevy::math::DMat3 { } /// Creates a 3x3 matrix from three column vectors. fn from_cols( - x_axis: Val, - y_axis: Val, - z_axis: Val, - ) -> Val { - let output: Val = bevy::math::DMat3::from_cols( + x_axis: Val<::glam::DVec3>, + y_axis: Val<::glam::DVec3>, + z_axis: Val<::glam::DVec3>, + ) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::DMat3::from_cols( x_axis.into_inner(), y_axis.into_inner(), z_axis.into_inner(), @@ -27198,8 +24992,8 @@ impl bevy::math::DMat3 { output } /// Creates a 3x3 matrix with its diagonal set to `diagonal` and all other entries set to 0. - fn from_diagonal(diagonal: Val) -> Val { - let output: Val = bevy::math::DMat3::from_diagonal( + fn from_diagonal(diagonal: Val<::glam::DVec3>) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::DMat3::from_diagonal( diagonal.into_inner(), ) .into(); @@ -27208,12 +25002,12 @@ impl bevy::math::DMat3 { /// Creates a 3D rotation matrix from the given euler rotation sequence and the angles (in /// radians). fn from_euler( - order: Val, + order: Val<::glam::EulerRot>, a: f64, b: f64, c: f64, - ) -> Val { - let output: Val = bevy::math::DMat3::from_euler( + ) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::DMat3::from_euler( order.into_inner(), a, b, @@ -27225,27 +25019,21 @@ impl bevy::math::DMat3 { /// Creates an affine transformation matrix from the given 2x2 matrix. /// The resulting matrix can be used to transform 2D points and vectors. See /// [`Self::transform_point2()`] and [`Self::transform_vector2()`]. - fn from_mat2(m: Val) -> Val { - let output: Val = bevy::math::DMat3::from_mat2(m.into_inner()) - .into(); + fn from_mat2(m: Val<::glam::DMat2>) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::DMat3::from_mat2(m.into_inner()).into(); output } /// Creates a 3x3 matrix from a 4x4 matrix, discarding the 4th row and column. - fn from_mat4(m: Val) -> Val { - let output: Val = bevy::math::DMat3::from_mat4(m.into_inner()) - .into(); + fn from_mat4(m: Val<::glam::DMat4>) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::DMat3::from_mat4(m.into_inner()).into(); output } /// Creates a 3x3 matrix from the minor of the given 4x4 matrix, discarding the `i`th column /// and `j`th row. /// # Panics /// Panics if `i` or `j` is greater than 3. - fn from_mat4_minor( - m: Val, - i: usize, - j: usize, - ) -> Val { - let output: Val = bevy::math::DMat3::from_mat4_minor( + fn from_mat4_minor(m: Val<::glam::DMat4>, i: usize, j: usize) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::DMat3::from_mat4_minor( m.into_inner(), i, j, @@ -27256,29 +25044,24 @@ impl bevy::math::DMat3 { /// Creates a 3D rotation matrix from the given quaternion. /// # Panics /// Will panic if `rotation` is not normalized when `glam_assert` is enabled. - fn from_quat(rotation: Val) -> Val { - let output: Val = bevy::math::DMat3::from_quat( - rotation.into_inner(), - ) + fn from_quat(rotation: Val<::glam::DQuat>) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::DMat3::from_quat(rotation.into_inner()) .into(); output } /// Creates a 3D rotation matrix from `angle` (in radians) around the x axis. - fn from_rotation_x(angle: f64) -> Val { - let output: Val = bevy::math::DMat3::from_rotation_x(angle) - .into(); + fn from_rotation_x(angle: f64) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::DMat3::from_rotation_x(angle).into(); output } /// Creates a 3D rotation matrix from `angle` (in radians) around the y axis. - fn from_rotation_y(angle: f64) -> Val { - let output: Val = bevy::math::DMat3::from_rotation_y(angle) - .into(); + fn from_rotation_y(angle: f64) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::DMat3::from_rotation_y(angle).into(); output } /// Creates a 3D rotation matrix from `angle` (in radians) around the z axis. - fn from_rotation_z(angle: f64) -> Val { - let output: Val = bevy::math::DMat3::from_rotation_z(angle) - .into(); + fn from_rotation_z(angle: f64) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::DMat3::from_rotation_z(angle).into(); output } /// Creates an affine transformation matrix from the given non-uniform 2D `scale`. @@ -27286,10 +25069,8 @@ impl bevy::math::DMat3 { /// [`Self::transform_point2()`] and [`Self::transform_vector2()`]. /// # Panics /// Will panic if all elements of `scale` are zero when `glam_assert` is enabled. - fn from_scale(scale: Val) -> Val { - let output: Val = bevy::math::DMat3::from_scale( - scale.into_inner(), - ) + fn from_scale(scale: Val<::glam::DVec2>) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::DMat3::from_scale(scale.into_inner()) .into(); output } @@ -27298,11 +25079,11 @@ impl bevy::math::DMat3 { /// The resulting matrix can be used to transform 2D points and vectors. See /// [`Self::transform_point2()`] and [`Self::transform_vector2()`]. fn from_scale_angle_translation( - scale: Val, + scale: Val<::glam::DVec2>, angle: f64, - translation: Val, - ) -> Val { - let output: Val = bevy::math::DMat3::from_scale_angle_translation( + translation: Val<::glam::DVec2>, + ) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::DMat3::from_scale_angle_translation( scale.into_inner(), angle, translation.into_inner(), @@ -27313,8 +25094,8 @@ impl bevy::math::DMat3 { /// Creates an affine transformation matrix from the given 2D `translation`. /// The resulting matrix can be used to transform 2D points and vectors. See /// [`Self::transform_point2()`] and [`Self::transform_vector2()`]. - fn from_translation(translation: Val) -> Val { - let output: Val = bevy::math::DMat3::from_translation( + fn from_translation(translation: Val<::glam::DVec2>) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::DMat3::from_translation( translation.into_inner(), ) .into(); @@ -27324,53 +25105,44 @@ impl bevy::math::DMat3 { /// If the matrix is not invertible the returned matrix will be invalid. /// # Panics /// Will panic if the determinant of `self` is zero when `glam_assert` is enabled. - fn inverse(_self: Ref) -> Val { - let output: Val = bevy::math::DMat3::inverse(&_self).into(); + fn inverse(_self: Ref<::glam::DMat3>) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::DMat3::inverse(&_self).into(); output } /// Returns `true` if, and only if, all elements are finite. /// If any element is either `NaN`, positive or negative infinity, this will return `false`. - fn is_finite(_self: Ref) -> bool { - let output: bool = bevy::math::DMat3::is_finite(&_self).into(); + fn is_finite(_self: Ref<::glam::DMat3>) -> bool { + let output: bool = ::glam::DMat3::is_finite(&_self).into(); output } /// Returns `true` if any elements are `NaN`. - fn is_nan(_self: Ref) -> bool { - let output: bool = bevy::math::DMat3::is_nan(&_self).into(); + fn is_nan(_self: Ref<::glam::DMat3>) -> bool { + let output: bool = ::glam::DMat3::is_nan(&_self).into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DAffine2>) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Mul< + ::glam::DAffine2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DMat3>) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Mul< + ::glam::DMat3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = <::glam::DMat3 as ::core::ops::Mul< + ::glam::DVec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: f64) -> Val { - let output: Val = , rhs: f64) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Mul< f64, >>::mul(_self.into_inner(), rhs) .into(); @@ -27378,33 +25150,31 @@ impl bevy::math::DMat3 { } /// Multiplies two 3x3 matrices. fn mul_mat3( - _self: Ref, - rhs: Ref, - ) -> Val { - let output: Val = bevy::math::DMat3::mul_mat3(&_self, &rhs) - .into(); + _self: Ref<::glam::DMat3>, + rhs: Ref<::glam::DMat3>, + ) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::DMat3::mul_mat3(&_self, &rhs).into(); output } /// Multiplies a 3x3 matrix by a scalar. - fn mul_scalar(_self: Ref, rhs: f64) -> Val { - let output: Val = bevy::math::DMat3::mul_scalar(&_self, rhs) - .into(); + fn mul_scalar(_self: Ref<::glam::DMat3>, rhs: f64) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::DMat3::mul_scalar(&_self, rhs).into(); output } /// Transforms a 3D vector. fn mul_vec3( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DMat3::mul_vec3( + _self: Ref<::glam::DMat3>, + rhs: Val<::glam::DVec3>, + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DMat3::mul_vec3( &_self, rhs.into_inner(), ) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::DMat3>) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -27413,40 +25183,35 @@ impl bevy::math::DMat3 { /// Returns the matrix row for the given `index`. /// # Panics /// Panics if `index` is greater than 2. - fn row(_self: Ref, index: usize) -> Val { - let output: Val = bevy::math::DMat3::row(&_self, index) - .into(); + fn row(_self: Ref<::glam::DMat3>, index: usize) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DMat3::row(&_self, index).into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DMat3>) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = <::glam::DMat3 as ::core::ops::Sub< + ::glam::DMat3, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } /// Subtracts two 3x3 matrices. fn sub_mat3( - _self: Ref, - rhs: Ref, - ) -> Val { - let output: Val = bevy::math::DMat3::sub_mat3(&_self, &rhs) - .into(); + _self: Ref<::glam::DMat3>, + rhs: Ref<::glam::DMat3>, + ) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::DMat3::sub_mat3(&_self, &rhs).into(); output } /// Creates a `[f64; 9]` array storing data in column major order. /// If you require data in row major order `transpose` the matrix first. - fn to_cols_array(_self: Ref) -> [f64; 9] { - let output: [f64; 9] = bevy::math::DMat3::to_cols_array(&_self).into(); + fn to_cols_array(_self: Ref<::glam::DMat3>) -> [f64; 9] { + let output: [f64; 9] = ::glam::DMat3::to_cols_array(&_self).into(); output } /// Creates a `[[f64; 3]; 3]` 3D array storing data in column major order. /// If you require data in row major order `transpose` the matrix first. - fn to_cols_array_2d(_self: Ref) -> [[f64; 3]; 3] { - let output: [[f64; 3]; 3] = bevy::math::DMat3::to_cols_array_2d(&_self).into(); + fn to_cols_array_2d(_self: Ref<::glam::DMat3>) -> [[f64; 3]; 3] { + let output: [[f64; 3]; 3] = ::glam::DMat3::to_cols_array_2d(&_self).into(); output } /// Extract Euler angles with the given Euler rotation order. @@ -27455,13 +25220,10 @@ impl bevy::math::DMat3 { /// # Panics /// Will panic if any input matrix column is not normalized when `glam_assert` is enabled. fn to_euler( - _self: Ref, - order: Val, + _self: Ref<::glam::DMat3>, + order: Val<::glam::EulerRot>, ) -> (f64, f64, f64) { - let output: (f64, f64, f64) = bevy::math::DMat3::to_euler( - &_self, - order.into_inner(), - ) + let output: (f64, f64, f64) = ::glam::DMat3::to_euler(&_self, order.into_inner()) .into(); output } @@ -27471,10 +25233,10 @@ impl bevy::math::DMat3 { /// # Panics /// Will panic if the 2nd row of `self` is not `(0, 0, 1)` when `glam_assert` is enabled. fn transform_point2( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DMat3::transform_point2( + _self: Ref<::glam::DMat3>, + rhs: Val<::glam::DVec2>, + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DMat3::transform_point2( &_self, rhs.into_inner(), ) @@ -27487,10 +25249,10 @@ impl bevy::math::DMat3 { /// # Panics /// Will panic if the 2nd row of `self` is not `(0, 0, 1)` when `glam_assert` is enabled. fn transform_vector2( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DMat3::transform_vector2( + _self: Ref<::glam::DMat3>, + rhs: Val<::glam::DVec2>, + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DMat3::transform_vector2( &_self, rhs.into_inner(), ) @@ -27498,8 +25260,8 @@ impl bevy::math::DMat3 { output } /// Returns the transpose of `self`. - fn transpose(_self: Ref) -> Val { - let output: Val = bevy::math::DMat3::transpose(&_self).into(); + fn transpose(_self: Ref<::glam::DMat3>) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = ::glam::DMat3::transpose(&_self).into(); output } } @@ -27509,10 +25271,10 @@ impl bevy::math::DMat3 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::DMat4 { +impl ::glam::DMat4 { /// Takes the absolute value of each element in `self` - fn abs(_self: Ref) -> Val { - let output: Val = bevy::math::DMat4::abs(&_self).into(); + fn abs(_self: Ref<::glam::DMat4>) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::abs(&_self).into(); output } /// Returns true if the absolute difference of all elements between `self` and `rhs` @@ -27523,11 +25285,11 @@ impl bevy::math::DMat4 { /// For more see /// [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/). fn abs_diff_eq( - _self: Ref, - rhs: Val, + _self: Ref<::glam::DMat4>, + rhs: Val<::glam::DMat4>, max_abs_diff: f64, ) -> bool { - let output: bool = bevy::math::DMat4::abs_diff_eq( + let output: bool = ::glam::DMat4::abs_diff_eq( &_self, rhs.into_inner(), max_abs_diff, @@ -27535,31 +25297,27 @@ impl bevy::math::DMat4 { .into(); output } - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DMat4>) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Add< + ::glam::DMat4, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output } /// Adds two 4x4 matrices. fn add_mat4( - _self: Ref, - rhs: Ref, - ) -> Val { - let output: Val = bevy::math::DMat4::add_mat4(&_self, &rhs) - .into(); + _self: Ref<::glam::DMat4>, + rhs: Ref<::glam::DMat4>, + ) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::add_mat4(&_self, &rhs).into(); output } - fn as_mat4(_self: Ref) -> Val { - let output: Val = bevy::math::DMat4::as_mat4(&_self).into(); + fn as_mat4(_self: Ref<::glam::DMat4>) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = ::glam::DMat4::as_mat4(&_self).into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::DMat4>) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -27568,32 +25326,30 @@ impl bevy::math::DMat4 { /// Returns the matrix column for the given `index`. /// # Panics /// Panics if `index` is greater than 3. - fn col(_self: Ref, index: usize) -> Val { - let output: Val = bevy::math::DMat4::col(&_self, index) - .into(); + fn col(_self: Ref<::glam::DMat4>, index: usize) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DMat4::col(&_self, index).into(); output } /// Returns the determinant of `self`. - fn determinant(_self: Ref) -> f64 { - let output: f64 = bevy::math::DMat4::determinant(&_self).into(); + fn determinant(_self: Ref<::glam::DMat4>) -> f64 { + let output: f64 = ::glam::DMat4::determinant(&_self).into(); output } - fn div(_self: Val, rhs: f64) -> Val { - let output: Val = , rhs: f64) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Div< f64, >>::div(_self.into_inner(), rhs) .into(); output } /// Divides a 4x4 matrix by a scalar. - fn div_scalar(_self: Ref, rhs: f64) -> Val { - let output: Val = bevy::math::DMat4::div_scalar(&_self, rhs) - .into(); + fn div_scalar(_self: Ref<::glam::DMat4>, rhs: f64) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::div_scalar(&_self, rhs).into(); output } - fn eq(_self: Ref, rhs: Ref) -> bool { - let output: bool = , rhs: Ref<::glam::DMat4>) -> bool { + let output: bool = <::glam::DMat4 as ::core::cmp::PartialEq< + ::glam::DMat4, >>::eq(&_self, &rhs) .into(); output @@ -27604,11 +25360,8 @@ impl bevy::math::DMat4 { /// [`Self::transform_point3()`] and [`Self::transform_vector3()`]. /// # Panics /// Will panic if `axis` is not normalized when `glam_assert` is enabled. - fn from_axis_angle( - axis: Val, - angle: f64, - ) -> Val { - let output: Val = bevy::math::DMat4::from_axis_angle( + fn from_axis_angle(axis: Val<::glam::DVec3>, angle: f64) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::from_axis_angle( axis.into_inner(), angle, ) @@ -27617,12 +25370,12 @@ impl bevy::math::DMat4 { } /// Creates a 4x4 matrix from four column vectors. fn from_cols( - x_axis: Val, - y_axis: Val, - z_axis: Val, - w_axis: Val, - ) -> Val { - let output: Val = bevy::math::DMat4::from_cols( + x_axis: Val<::glam::DVec4>, + y_axis: Val<::glam::DVec4>, + z_axis: Val<::glam::DVec4>, + w_axis: Val<::glam::DVec4>, + ) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::from_cols( x_axis.into_inner(), y_axis.into_inner(), z_axis.into_inner(), @@ -27632,8 +25385,8 @@ impl bevy::math::DMat4 { output } /// Creates a 4x4 matrix with its diagonal set to `diagonal` and all other entries set to 0. - fn from_diagonal(diagonal: Val) -> Val { - let output: Val = bevy::math::DMat4::from_diagonal( + fn from_diagonal(diagonal: Val<::glam::DVec4>) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::from_diagonal( diagonal.into_inner(), ) .into(); @@ -27644,12 +25397,12 @@ impl bevy::math::DMat4 { /// The resulting matrix can be used to transform 3D points and vectors. See /// [`Self::transform_point3()`] and [`Self::transform_vector3()`]. fn from_euler( - order: Val, + order: Val<::glam::EulerRot>, a: f64, b: f64, c: f64, - ) -> Val { - let output: Val = bevy::math::DMat4::from_euler( + ) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::from_euler( order.into_inner(), a, b, @@ -27662,9 +25415,8 @@ impl bevy::math::DMat4 { /// matrix. /// The resulting matrix can be used to transform 3D points and vectors. See /// [`Self::transform_point3()`] and [`Self::transform_vector3()`]. - fn from_mat3(m: Val) -> Val { - let output: Val = bevy::math::DMat4::from_mat3(m.into_inner()) - .into(); + fn from_mat3(m: Val<::glam::DMat3>) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::from_mat3(m.into_inner()).into(); output } /// Creates an affine transformation matrix from the given `rotation` quaternion. @@ -27672,10 +25424,8 @@ impl bevy::math::DMat4 { /// [`Self::transform_point3()`] and [`Self::transform_vector3()`]. /// # Panics /// Will panic if `rotation` is not normalized when `glam_assert` is enabled. - fn from_quat(rotation: Val) -> Val { - let output: Val = bevy::math::DMat4::from_quat( - rotation.into_inner(), - ) + fn from_quat(rotation: Val<::glam::DQuat>) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::from_quat(rotation.into_inner()) .into(); output } @@ -27685,10 +25435,10 @@ impl bevy::math::DMat4 { /// # Panics /// Will panic if `rotation` is not normalized when `glam_assert` is enabled. fn from_rotation_translation( - rotation: Val, - translation: Val, - ) -> Val { - let output: Val = bevy::math::DMat4::from_rotation_translation( + rotation: Val<::glam::DQuat>, + translation: Val<::glam::DVec3>, + ) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::from_rotation_translation( rotation.into_inner(), translation.into_inner(), ) @@ -27699,27 +25449,24 @@ impl bevy::math::DMat4 { /// `angle` (in radians). /// The resulting matrix can be used to transform 3D points and vectors. See /// [`Self::transform_point3()`] and [`Self::transform_vector3()`]. - fn from_rotation_x(angle: f64) -> Val { - let output: Val = bevy::math::DMat4::from_rotation_x(angle) - .into(); + fn from_rotation_x(angle: f64) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::from_rotation_x(angle).into(); output } /// Creates an affine transformation matrix containing a 3D rotation around the y axis of /// `angle` (in radians). /// The resulting matrix can be used to transform 3D points and vectors. See /// [`Self::transform_point3()`] and [`Self::transform_vector3()`]. - fn from_rotation_y(angle: f64) -> Val { - let output: Val = bevy::math::DMat4::from_rotation_y(angle) - .into(); + fn from_rotation_y(angle: f64) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::from_rotation_y(angle).into(); output } /// Creates an affine transformation matrix containing a 3D rotation around the z axis of /// `angle` (in radians). /// The resulting matrix can be used to transform 3D points and vectors. See /// [`Self::transform_point3()`] and [`Self::transform_vector3()`]. - fn from_rotation_z(angle: f64) -> Val { - let output: Val = bevy::math::DMat4::from_rotation_z(angle) - .into(); + fn from_rotation_z(angle: f64) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::from_rotation_z(angle).into(); output } /// Creates an affine transformation matrix containing the given 3D non-uniform `scale`. @@ -27727,10 +25474,8 @@ impl bevy::math::DMat4 { /// [`Self::transform_point3()`] and [`Self::transform_vector3()`]. /// # Panics /// Will panic if all elements of `scale` are zero when `glam_assert` is enabled. - fn from_scale(scale: Val) -> Val { - let output: Val = bevy::math::DMat4::from_scale( - scale.into_inner(), - ) + fn from_scale(scale: Val<::glam::DVec3>) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::from_scale(scale.into_inner()) .into(); output } @@ -27741,11 +25486,11 @@ impl bevy::math::DMat4 { /// # Panics /// Will panic if `rotation` is not normalized when `glam_assert` is enabled. fn from_scale_rotation_translation( - scale: Val, - rotation: Val, - translation: Val, - ) -> Val { - let output: Val = bevy::math::DMat4::from_scale_rotation_translation( + scale: Val<::glam::DVec3>, + rotation: Val<::glam::DQuat>, + translation: Val<::glam::DVec3>, + ) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::from_scale_rotation_translation( scale.into_inner(), rotation.into_inner(), translation.into_inner(), @@ -27756,8 +25501,8 @@ impl bevy::math::DMat4 { /// Creates an affine transformation matrix from the given 3D `translation`. /// The resulting matrix can be used to transform 3D points and vectors. See /// [`Self::transform_point3()`] and [`Self::transform_vector3()`]. - fn from_translation(translation: Val) -> Val { - let output: Val = bevy::math::DMat4::from_translation( + fn from_translation(translation: Val<::glam::DVec3>) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::from_translation( translation.into_inner(), ) .into(); @@ -27767,19 +25512,19 @@ impl bevy::math::DMat4 { /// If the matrix is not invertible the returned matrix will be invalid. /// # Panics /// Will panic if the determinant of `self` is zero when `glam_assert` is enabled. - fn inverse(_self: Ref) -> Val { - let output: Val = bevy::math::DMat4::inverse(&_self).into(); + fn inverse(_self: Ref<::glam::DMat4>) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::inverse(&_self).into(); output } /// Returns `true` if, and only if, all elements are finite. /// If any element is either `NaN`, positive or negative infinity, this will return `false`. - fn is_finite(_self: Ref) -> bool { - let output: bool = bevy::math::DMat4::is_finite(&_self).into(); + fn is_finite(_self: Ref<::glam::DMat4>) -> bool { + let output: bool = ::glam::DMat4::is_finite(&_self).into(); output } /// Returns `true` if any elements are `NaN`. - fn is_nan(_self: Ref) -> bool { - let output: bool = bevy::math::DMat4::is_nan(&_self).into(); + fn is_nan(_self: Ref<::glam::DMat4>) -> bool { + let output: bool = ::glam::DMat4::is_nan(&_self).into(); output } /// Creates a left-handed view matrix using a camera position, an up direction, and a focal @@ -27788,11 +25533,11 @@ impl bevy::math::DMat4 { /// # Panics /// Will panic if `up` is not normalized when `glam_assert` is enabled. fn look_at_lh( - eye: Val, - center: Val, - up: Val, - ) -> Val { - let output: Val = bevy::math::DMat4::look_at_lh( + eye: Val<::glam::DVec3>, + center: Val<::glam::DVec3>, + up: Val<::glam::DVec3>, + ) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::look_at_lh( eye.into_inner(), center.into_inner(), up.into_inner(), @@ -27806,11 +25551,11 @@ impl bevy::math::DMat4 { /// # Panics /// Will panic if `up` is not normalized when `glam_assert` is enabled. fn look_at_rh( - eye: Val, - center: Val, - up: Val, - ) -> Val { - let output: Val = bevy::math::DMat4::look_at_rh( + eye: Val<::glam::DVec3>, + center: Val<::glam::DVec3>, + up: Val<::glam::DVec3>, + ) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::look_at_rh( eye.into_inner(), center.into_inner(), up.into_inner(), @@ -27822,11 +25567,11 @@ impl bevy::math::DMat4 { /// direction. /// For a view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`. fn look_to_lh( - eye: Val, - dir: Val, - up: Val, - ) -> Val { - let output: Val = bevy::math::DMat4::look_to_lh( + eye: Val<::glam::DVec3>, + dir: Val<::glam::DVec3>, + up: Val<::glam::DVec3>, + ) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::look_to_lh( eye.into_inner(), dir.into_inner(), up.into_inner(), @@ -27838,11 +25583,11 @@ impl bevy::math::DMat4 { /// direction. /// For a view coordinate system with `+X=right`, `+Y=up` and `+Z=back`. fn look_to_rh( - eye: Val, - dir: Val, - up: Val, - ) -> Val { - let output: Val = bevy::math::DMat4::look_to_rh( + eye: Val<::glam::DVec3>, + dir: Val<::glam::DVec3>, + up: Val<::glam::DVec3>, + ) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::look_to_rh( eye.into_inner(), dir.into_inner(), up.into_inner(), @@ -27850,38 +25595,29 @@ impl bevy::math::DMat4 { .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DAffine3>) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Mul< + ::glam::DAffine3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DMat4>) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Mul< + ::glam::DMat4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DVec4>) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = <::glam::DMat4 as ::core::ops::Mul< + ::glam::DVec4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul(_self: Val, rhs: f64) -> Val { - let output: Val = , rhs: f64) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Mul< f64, >>::mul(_self.into_inner(), rhs) .into(); @@ -27889,33 +25625,31 @@ impl bevy::math::DMat4 { } /// Multiplies two 4x4 matrices. fn mul_mat4( - _self: Ref, - rhs: Ref, - ) -> Val { - let output: Val = bevy::math::DMat4::mul_mat4(&_self, &rhs) - .into(); + _self: Ref<::glam::DMat4>, + rhs: Ref<::glam::DMat4>, + ) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::mul_mat4(&_self, &rhs).into(); output } /// Multiplies a 4x4 matrix by a scalar. - fn mul_scalar(_self: Ref, rhs: f64) -> Val { - let output: Val = bevy::math::DMat4::mul_scalar(&_self, rhs) - .into(); + fn mul_scalar(_self: Ref<::glam::DMat4>, rhs: f64) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::mul_scalar(&_self, rhs).into(); output } /// Transforms a 4D vector. fn mul_vec4( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DMat4::mul_vec4( + _self: Ref<::glam::DMat4>, + rhs: Val<::glam::DVec4>, + ) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DMat4::mul_vec4( &_self, rhs.into_inner(), ) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::DMat4>) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -27930,8 +25664,8 @@ impl bevy::math::DMat4 { top: f64, near: f64, far: f64, - ) -> Val { - let output: Val = bevy::math::DMat4::orthographic_lh( + ) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::orthographic_lh( left, right, bottom, @@ -27951,8 +25685,8 @@ impl bevy::math::DMat4 { top: f64, near: f64, far: f64, - ) -> Val { - let output: Val = bevy::math::DMat4::orthographic_rh( + ) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::orthographic_rh( left, right, bottom, @@ -27975,8 +25709,8 @@ impl bevy::math::DMat4 { top: f64, near: f64, far: f64, - ) -> Val { - let output: Val = bevy::math::DMat4::orthographic_rh_gl( + ) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::orthographic_rh_gl( left, right, bottom, @@ -27997,8 +25731,8 @@ impl bevy::math::DMat4 { fov_y_radians: f64, aspect_ratio: f64, z_near: f64, - ) -> Val { - let output: Val = bevy::math::DMat4::perspective_infinite_lh( + ) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::perspective_infinite_lh( fov_y_radians, aspect_ratio, z_near, @@ -28014,8 +25748,8 @@ impl bevy::math::DMat4 { fov_y_radians: f64, aspect_ratio: f64, z_near: f64, - ) -> Val { - let output: Val = bevy::math::DMat4::perspective_infinite_reverse_lh( + ) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::perspective_infinite_reverse_lh( fov_y_radians, aspect_ratio, z_near, @@ -28031,8 +25765,8 @@ impl bevy::math::DMat4 { fov_y_radians: f64, aspect_ratio: f64, z_near: f64, - ) -> Val { - let output: Val = bevy::math::DMat4::perspective_infinite_reverse_rh( + ) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::perspective_infinite_reverse_rh( fov_y_radians, aspect_ratio, z_near, @@ -28050,8 +25784,8 @@ impl bevy::math::DMat4 { fov_y_radians: f64, aspect_ratio: f64, z_near: f64, - ) -> Val { - let output: Val = bevy::math::DMat4::perspective_infinite_rh( + ) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::perspective_infinite_rh( fov_y_radians, aspect_ratio, z_near, @@ -28069,8 +25803,8 @@ impl bevy::math::DMat4 { aspect_ratio: f64, z_near: f64, z_far: f64, - ) -> Val { - let output: Val = bevy::math::DMat4::perspective_lh( + ) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::perspective_lh( fov_y_radians, aspect_ratio, z_near, @@ -28089,8 +25823,8 @@ impl bevy::math::DMat4 { aspect_ratio: f64, z_near: f64, z_far: f64, - ) -> Val { - let output: Val = bevy::math::DMat4::perspective_rh( + ) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::perspective_rh( fov_y_radians, aspect_ratio, z_near, @@ -28108,8 +25842,8 @@ impl bevy::math::DMat4 { aspect_ratio: f64, z_near: f64, z_far: f64, - ) -> Val { - let output: Val = bevy::math::DMat4::perspective_rh_gl( + ) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::perspective_rh_gl( fov_y_radians, aspect_ratio, z_near, @@ -28123,10 +25857,10 @@ impl bevy::math::DMat4 { /// The perspective divide is performed meaning the resulting 3D vector is divided by `w`. /// This method assumes that `self` contains a projective transform. fn project_point3( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DMat4::project_point3( + _self: Ref<::glam::DMat4>, + rhs: Val<::glam::DVec3>, + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DMat4::project_point3( &_self, rhs.into_inner(), ) @@ -28136,40 +25870,35 @@ impl bevy::math::DMat4 { /// Returns the matrix row for the given `index`. /// # Panics /// Panics if `index` is greater than 3. - fn row(_self: Ref, index: usize) -> Val { - let output: Val = bevy::math::DMat4::row(&_self, index) - .into(); + fn row(_self: Ref<::glam::DMat4>, index: usize) -> Val<::glam::DVec4> { + let output: Val<::glam::DVec4> = ::glam::DMat4::row(&_self, index).into(); output } - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DMat4>) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = <::glam::DMat4 as ::core::ops::Sub< + ::glam::DMat4, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } /// Subtracts two 4x4 matrices. fn sub_mat4( - _self: Ref, - rhs: Ref, - ) -> Val { - let output: Val = bevy::math::DMat4::sub_mat4(&_self, &rhs) - .into(); + _self: Ref<::glam::DMat4>, + rhs: Ref<::glam::DMat4>, + ) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::sub_mat4(&_self, &rhs).into(); output } /// Creates a `[f64; 16]` array storing data in column major order. /// If you require data in row major order `transpose` the matrix first. - fn to_cols_array(_self: Ref) -> [f64; 16] { - let output: [f64; 16] = bevy::math::DMat4::to_cols_array(&_self).into(); + fn to_cols_array(_self: Ref<::glam::DMat4>) -> [f64; 16] { + let output: [f64; 16] = ::glam::DMat4::to_cols_array(&_self).into(); output } /// Creates a `[[f64; 4]; 4]` 4D array storing data in column major order. /// If you require data in row major order `transpose` the matrix first. - fn to_cols_array_2d(_self: Ref) -> [[f64; 4]; 4] { - let output: [[f64; 4]; 4] = bevy::math::DMat4::to_cols_array_2d(&_self).into(); + fn to_cols_array_2d(_self: Ref<::glam::DMat4>) -> [[f64; 4]; 4] { + let output: [[f64; 4]; 4] = ::glam::DMat4::to_cols_array_2d(&_self).into(); output } /// Extract Euler angles with the given Euler rotation order. @@ -28179,13 +25908,10 @@ impl bevy::math::DMat4 { /// Will panic if any column of the upper 3x3 rotation matrix is not normalized when /// `glam_assert` is enabled. fn to_euler( - _self: Ref, - order: Val, + _self: Ref<::glam::DMat4>, + order: Val<::glam::EulerRot>, ) -> (f64, f64, f64) { - let output: (f64, f64, f64) = bevy::math::DMat4::to_euler( - &_self, - order.into_inner(), - ) + let output: (f64, f64, f64) = ::glam::DMat4::to_euler(&_self, order.into_inner()) .into(); output } @@ -28198,10 +25924,10 @@ impl bevy::math::DMat4 { /// # Panics /// Will panic if the 3rd row of `self` is not `(0, 0, 0, 1)` when `glam_assert` is enabled. fn transform_point3( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DMat4::transform_point3( + _self: Ref<::glam::DMat4>, + rhs: Val<::glam::DVec3>, + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DMat4::transform_point3( &_self, rhs.into_inner(), ) @@ -28215,10 +25941,10 @@ impl bevy::math::DMat4 { /// # Panics /// Will panic if the 3rd row of `self` is not `(0, 0, 0, 1)` when `glam_assert` is enabled. fn transform_vector3( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DMat4::transform_vector3( + _self: Ref<::glam::DMat4>, + rhs: Val<::glam::DVec3>, + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DMat4::transform_vector3( &_self, rhs.into_inner(), ) @@ -28226,8 +25952,8 @@ impl bevy::math::DMat4 { output } /// Returns the transpose of `self`. - fn transpose(_self: Ref) -> Val { - let output: Val = bevy::math::DMat4::transpose(&_self).into(); + fn transpose(_self: Ref<::glam::DMat4>) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = ::glam::DMat4::transpose(&_self).into(); output } } @@ -28237,7 +25963,7 @@ impl bevy::math::DMat4 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::Affine2 { +impl ::glam::Affine2 { /// Returns true if the absolute difference of all elements between `self` and `rhs` /// is less than or equal to `max_abs_diff`. /// This can be used to compare if two 3x4 matrices contain similar elements. It works @@ -28246,11 +25972,11 @@ impl bevy::math::Affine2 { /// For more see /// [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/). fn abs_diff_eq( - _self: Ref, - rhs: Val, + _self: Ref<::glam::Affine2>, + rhs: Val<::glam::Affine2>, max_abs_diff: f32, ) -> bool { - let output: bool = bevy::math::Affine2::abs_diff_eq( + let output: bool = ::glam::Affine2::abs_diff_eq( &_self, rhs.into_inner(), max_abs_diff, @@ -28258,24 +25984,23 @@ impl bevy::math::Affine2 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::Affine2>) -> Val<::glam::Affine2> { + let output: Val<::glam::Affine2> = <::glam::Affine2 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); output } - fn eq(_self: Ref, rhs: Ref) -> bool { - let output: bool = , rhs: Ref<::glam::Affine2>) -> bool { + let output: bool = <::glam::Affine2 as ::core::cmp::PartialEq< + ::glam::Affine2, >>::eq(&_self, &rhs) .into(); output } /// Creates an affine transform from the given rotation `angle`. - fn from_angle(angle: f32) -> Val { - let output: Val = bevy::math::Affine2::from_angle(angle) - .into(); + fn from_angle(angle: f32) -> Val<::glam::Affine2> { + let output: Val<::glam::Affine2> = ::glam::Affine2::from_angle(angle).into(); output } /// Creates an affine transform from the given 2D rotation `angle` (in radians) and @@ -28283,9 +26008,9 @@ impl bevy::math::Affine2 { /// Equivalent to `Affine2::from_translation(translation) * Affine2::from_angle(angle)` fn from_angle_translation( angle: f32, - translation: Val, - ) -> Val { - let output: Val = bevy::math::Affine2::from_angle_translation( + translation: Val<::glam::Vec2>, + ) -> Val<::glam::Affine2> { + let output: Val<::glam::Affine2> = ::glam::Affine2::from_angle_translation( angle, translation.into_inner(), ) @@ -28294,11 +26019,11 @@ impl bevy::math::Affine2 { } /// Creates an affine transform from three column vectors. fn from_cols( - x_axis: Val, - y_axis: Val, - z_axis: Val, - ) -> Val { - let output: Val = bevy::math::Affine2::from_cols( + x_axis: Val<::glam::Vec2>, + y_axis: Val<::glam::Vec2>, + z_axis: Val<::glam::Vec2>, + ) -> Val<::glam::Affine2> { + let output: Val<::glam::Affine2> = ::glam::Affine2::from_cols( x_axis.into_inner(), y_axis.into_inner(), z_axis.into_inner(), @@ -28307,8 +26032,8 @@ impl bevy::math::Affine2 { output } /// Creates an affine transform from a 2x2 matrix (expressing scale, shear and rotation) - fn from_mat2(matrix2: Val) -> Val { - let output: Val = bevy::math::Affine2::from_mat2( + fn from_mat2(matrix2: Val<::glam::Mat2>) -> Val<::glam::Affine2> { + let output: Val<::glam::Affine2> = ::glam::Affine2::from_mat2( matrix2.into_inner(), ) .into(); @@ -28319,10 +26044,10 @@ impl bevy::math::Affine2 { /// Equivalent to /// `Affine2::from_translation(translation) * Affine2::from_mat2(mat2)` fn from_mat2_translation( - matrix2: Val, - translation: Val, - ) -> Val { - let output: Val = bevy::math::Affine2::from_mat2_translation( + matrix2: Val<::glam::Mat2>, + translation: Val<::glam::Vec2>, + ) -> Val<::glam::Affine2> { + let output: Val<::glam::Affine2> = ::glam::Affine2::from_mat2_translation( matrix2.into_inner(), translation.into_inner(), ) @@ -28330,25 +26055,21 @@ impl bevy::math::Affine2 { output } /// The given `Mat3` must be an affine transform, - fn from_mat3(m: Val) -> Val { - let output: Val = bevy::math::Affine2::from_mat3( - m.into_inner(), - ) + fn from_mat3(m: Val<::glam::Mat3>) -> Val<::glam::Affine2> { + let output: Val<::glam::Affine2> = ::glam::Affine2::from_mat3(m.into_inner()) .into(); output } /// The given [`Mat3A`] must be an affine transform, - fn from_mat3a(m: Val) -> Val { - let output: Val = bevy::math::Affine2::from_mat3a( - m.into_inner(), - ) + fn from_mat3a(m: Val<::glam::Mat3A>) -> Val<::glam::Affine2> { + let output: Val<::glam::Affine2> = ::glam::Affine2::from_mat3a(m.into_inner()) .into(); output } /// Creates an affine transform that changes scale. /// Note that if any scale is zero the transform will be non-invertible. - fn from_scale(scale: Val) -> Val { - let output: Val = bevy::math::Affine2::from_scale( + fn from_scale(scale: Val<::glam::Vec2>) -> Val<::glam::Affine2> { + let output: Val<::glam::Affine2> = ::glam::Affine2::from_scale( scale.into_inner(), ) .into(); @@ -28359,11 +26080,11 @@ impl bevy::math::Affine2 { /// Equivalent to `Affine2::from_translation(translation) * /// Affine2::from_angle(angle) * Affine2::from_scale(scale)` fn from_scale_angle_translation( - scale: Val, + scale: Val<::glam::Vec2>, angle: f32, - translation: Val, - ) -> Val { - let output: Val = bevy::math::Affine2::from_scale_angle_translation( + translation: Val<::glam::Vec2>, + ) -> Val<::glam::Affine2> { + let output: Val<::glam::Affine2> = ::glam::Affine2::from_scale_angle_translation( scale.into_inner(), angle, translation.into_inner(), @@ -28372,8 +26093,8 @@ impl bevy::math::Affine2 { output } /// Creates an affine transformation from the given 2D `translation`. - fn from_translation(translation: Val) -> Val { - let output: Val = bevy::math::Affine2::from_translation( + fn from_translation(translation: Val<::glam::Vec2>) -> Val<::glam::Affine2> { + let output: Val<::glam::Affine2> = ::glam::Affine2::from_translation( translation.into_inner(), ) .into(); @@ -28381,71 +26102,64 @@ impl bevy::math::Affine2 { } /// Return the inverse of this transform. /// Note that if the transform is not invertible the result will be invalid. - fn inverse(_self: Ref) -> Val { - let output: Val = bevy::math::Affine2::inverse(&_self) - .into(); + fn inverse(_self: Ref<::glam::Affine2>) -> Val<::glam::Affine2> { + let output: Val<::glam::Affine2> = ::glam::Affine2::inverse(&_self).into(); output } /// Returns `true` if, and only if, all elements are finite. /// If any element is either `NaN`, positive or negative infinity, this will return /// `false`. - fn is_finite(_self: Ref) -> bool { - let output: bool = bevy::math::Affine2::is_finite(&_self).into(); + fn is_finite(_self: Ref<::glam::Affine2>) -> bool { + let output: bool = ::glam::Affine2::is_finite(&_self).into(); output } /// Returns `true` if any elements are `NaN`. - fn is_nan(_self: Ref) -> bool { - let output: bool = bevy::math::Affine2::is_nan(&_self).into(); + fn is_nan(_self: Ref<::glam::Affine2>) -> bool { + let output: bool = ::glam::Affine2::is_nan(&_self).into(); output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::Affine2>, + ) -> Val<::glam::Affine2> { + let output: Val<::glam::Affine2> = <::glam::Affine2 as ::core::ops::Mul< + ::glam::Affine2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Mat3>) -> Val<::glam::Mat3> { + let output: Val<::glam::Mat3> = <::glam::Affine2 as ::core::ops::Mul< + ::glam::Mat3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Mat3A>) -> Val<::glam::Mat3A> { + let output: Val<::glam::Mat3A> = <::glam::Affine2 as ::core::ops::Mul< + ::glam::Mat3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } /// Creates a `[f32; 6]` array storing data in column major order. - fn to_cols_array(_self: Ref) -> [f32; 6] { - let output: [f32; 6] = bevy::math::Affine2::to_cols_array(&_self).into(); + fn to_cols_array(_self: Ref<::glam::Affine2>) -> [f32; 6] { + let output: [f32; 6] = ::glam::Affine2::to_cols_array(&_self).into(); output } /// Creates a `[[f32; 2]; 3]` 2D array storing data in /// column major order. /// If you require data in row major order `transpose` the matrix first. - fn to_cols_array_2d(_self: Ref) -> [[f32; 2]; 3] { - let output: [[f32; 2]; 3] = bevy::math::Affine2::to_cols_array_2d(&_self).into(); + fn to_cols_array_2d(_self: Ref<::glam::Affine2>) -> [[f32; 2]; 3] { + let output: [[f32; 2]; 3] = ::glam::Affine2::to_cols_array_2d(&_self).into(); output } /// Transforms the given 2D point, applying shear, scale, rotation and translation. fn transform_point2( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Affine2::transform_point2( + _self: Ref<::glam::Affine2>, + rhs: Val<::glam::Vec2>, + ) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Affine2::transform_point2( &_self, rhs.into_inner(), ) @@ -28456,10 +26170,10 @@ impl bevy::math::Affine2 { /// translation). /// To also apply translation, use [`Self::transform_point2()`] instead. fn transform_vector2( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Affine2::transform_vector2( + _self: Ref<::glam::Affine2>, + rhs: Val<::glam::Vec2>, + ) -> Val<::glam::Vec2> { + let output: Val<::glam::Vec2> = ::glam::Affine2::transform_vector2( &_self, rhs.into_inner(), ) @@ -28473,7 +26187,7 @@ impl bevy::math::Affine2 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::Affine3A { +impl ::glam::Affine3A { /// Returns true if the absolute difference of all elements between `self` and `rhs` /// is less than or equal to `max_abs_diff`. /// This can be used to compare if two 3x4 matrices contain similar elements. It works @@ -28482,11 +26196,11 @@ impl bevy::math::Affine3A { /// For more see /// [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/). fn abs_diff_eq( - _self: Ref, - rhs: Val, + _self: Ref<::glam::Affine3A>, + rhs: Val<::glam::Affine3A>, max_abs_diff: f32, ) -> bool { - let output: bool = bevy::math::Affine3A::abs_diff_eq( + let output: bool = ::glam::Affine3A::abs_diff_eq( &_self, rhs.into_inner(), max_abs_diff, @@ -28494,27 +26208,24 @@ impl bevy::math::Affine3A { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::Affine3A>) -> Val<::glam::Affine3A> { + let output: Val<::glam::Affine3A> = <::glam::Affine3A as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); output } - fn eq(_self: Ref, rhs: Ref) -> bool { - let output: bool = , rhs: Ref<::glam::Affine3A>) -> bool { + let output: bool = <::glam::Affine3A as ::core::cmp::PartialEq< + ::glam::Affine3A, >>::eq(&_self, &rhs) .into(); output } /// Creates an affine transform containing a 3D rotation around a normalized /// rotation `axis` of `angle` (in radians). - fn from_axis_angle( - axis: Val, - angle: f32, - ) -> Val { - let output: Val = bevy::math::Affine3A::from_axis_angle( + fn from_axis_angle(axis: Val<::glam::Vec3>, angle: f32) -> Val<::glam::Affine3A> { + let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_axis_angle( axis.into_inner(), angle, ) @@ -28523,12 +26234,12 @@ impl bevy::math::Affine3A { } /// Creates an affine transform from three column vectors. fn from_cols( - x_axis: Val, - y_axis: Val, - z_axis: Val, - w_axis: Val, - ) -> Val { - let output: Val = bevy::math::Affine3A::from_cols( + x_axis: Val<::glam::Vec3A>, + y_axis: Val<::glam::Vec3A>, + z_axis: Val<::glam::Vec3A>, + w_axis: Val<::glam::Vec3A>, + ) -> Val<::glam::Affine3A> { + let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_cols( x_axis.into_inner(), y_axis.into_inner(), z_axis.into_inner(), @@ -28539,8 +26250,8 @@ impl bevy::math::Affine3A { } /// Creates an affine transform from a 3x3 matrix (expressing scale, shear and /// rotation) - fn from_mat3(mat3: Val) -> Val { - let output: Val = bevy::math::Affine3A::from_mat3( + fn from_mat3(mat3: Val<::glam::Mat3>) -> Val<::glam::Affine3A> { + let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_mat3( mat3.into_inner(), ) .into(); @@ -28550,10 +26261,10 @@ impl bevy::math::Affine3A { /// and a translation vector. /// Equivalent to `Affine3A::from_translation(translation) * Affine3A::from_mat3(mat3)` fn from_mat3_translation( - mat3: Val, - translation: Val, - ) -> Val { - let output: Val = bevy::math::Affine3A::from_mat3_translation( + mat3: Val<::glam::Mat3>, + translation: Val<::glam::Vec3>, + ) -> Val<::glam::Affine3A> { + let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_mat3_translation( mat3.into_inner(), translation.into_inner(), ) @@ -28562,16 +26273,14 @@ impl bevy::math::Affine3A { } /// The given `Mat4` must be an affine transform, /// i.e. contain no perspective transform. - fn from_mat4(m: Val) -> Val { - let output: Val = bevy::math::Affine3A::from_mat4( - m.into_inner(), - ) + fn from_mat4(m: Val<::glam::Mat4>) -> Val<::glam::Affine3A> { + let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_mat4(m.into_inner()) .into(); output } /// Creates an affine transform from the given `rotation` quaternion. - fn from_quat(rotation: Val) -> Val { - let output: Val = bevy::math::Affine3A::from_quat( + fn from_quat(rotation: Val<::glam::Quat>) -> Val<::glam::Affine3A> { + let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_quat( rotation.into_inner(), ) .into(); @@ -28580,10 +26289,10 @@ impl bevy::math::Affine3A { /// Creates an affine transform from the given 3D `rotation` and `translation`. /// Equivalent to `Affine3A::from_translation(translation) * Affine3A::from_quat(rotation)` fn from_rotation_translation( - rotation: Val, - translation: Val, - ) -> Val { - let output: Val = bevy::math::Affine3A::from_rotation_translation( + rotation: Val<::glam::Quat>, + translation: Val<::glam::Vec3>, + ) -> Val<::glam::Affine3A> { + let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_rotation_translation( rotation.into_inner(), translation.into_inner(), ) @@ -28592,35 +26301,29 @@ impl bevy::math::Affine3A { } /// Creates an affine transform containing a 3D rotation around the x axis of /// `angle` (in radians). - fn from_rotation_x(angle: f32) -> Val { - let output: Val = bevy::math::Affine3A::from_rotation_x( - angle, - ) + fn from_rotation_x(angle: f32) -> Val<::glam::Affine3A> { + let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_rotation_x(angle) .into(); output } /// Creates an affine transform containing a 3D rotation around the y axis of /// `angle` (in radians). - fn from_rotation_y(angle: f32) -> Val { - let output: Val = bevy::math::Affine3A::from_rotation_y( - angle, - ) + fn from_rotation_y(angle: f32) -> Val<::glam::Affine3A> { + let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_rotation_y(angle) .into(); output } /// Creates an affine transform containing a 3D rotation around the z axis of /// `angle` (in radians). - fn from_rotation_z(angle: f32) -> Val { - let output: Val = bevy::math::Affine3A::from_rotation_z( - angle, - ) + fn from_rotation_z(angle: f32) -> Val<::glam::Affine3A> { + let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_rotation_z(angle) .into(); output } /// Creates an affine transform that changes scale. /// Note that if any scale is zero the transform will be non-invertible. - fn from_scale(scale: Val) -> Val { - let output: Val = bevy::math::Affine3A::from_scale( + fn from_scale(scale: Val<::glam::Vec3>) -> Val<::glam::Affine3A> { + let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_scale( scale.into_inner(), ) .into(); @@ -28631,11 +26334,11 @@ impl bevy::math::Affine3A { /// Equivalent to `Affine3A::from_translation(translation) * /// Affine3A::from_quat(rotation) * Affine3A::from_scale(scale)` fn from_scale_rotation_translation( - scale: Val, - rotation: Val, - translation: Val, - ) -> Val { - let output: Val = bevy::math::Affine3A::from_scale_rotation_translation( + scale: Val<::glam::Vec3>, + rotation: Val<::glam::Quat>, + translation: Val<::glam::Vec3>, + ) -> Val<::glam::Affine3A> { + let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_scale_rotation_translation( scale.into_inner(), rotation.into_inner(), translation.into_inner(), @@ -28644,10 +26347,8 @@ impl bevy::math::Affine3A { output } /// Creates an affine transformation from the given 3D `translation`. - fn from_translation( - translation: Val, - ) -> Val { - let output: Val = bevy::math::Affine3A::from_translation( + fn from_translation(translation: Val<::glam::Vec3>) -> Val<::glam::Affine3A> { + let output: Val<::glam::Affine3A> = ::glam::Affine3A::from_translation( translation.into_inner(), ) .into(); @@ -28655,21 +26356,20 @@ impl bevy::math::Affine3A { } /// Return the inverse of this transform. /// Note that if the transform is not invertible the result will be invalid. - fn inverse(_self: Ref) -> Val { - let output: Val = bevy::math::Affine3A::inverse(&_self) - .into(); + fn inverse(_self: Ref<::glam::Affine3A>) -> Val<::glam::Affine3A> { + let output: Val<::glam::Affine3A> = ::glam::Affine3A::inverse(&_self).into(); output } /// Returns `true` if, and only if, all elements are finite. /// If any element is either `NaN`, positive or negative infinity, this will return /// `false`. - fn is_finite(_self: Ref) -> bool { - let output: bool = bevy::math::Affine3A::is_finite(&_self).into(); + fn is_finite(_self: Ref<::glam::Affine3A>) -> bool { + let output: bool = ::glam::Affine3A::is_finite(&_self).into(); output } /// Returns `true` if any elements are `NaN`. - fn is_nan(_self: Ref) -> bool { - let output: bool = bevy::math::Affine3A::is_nan(&_self).into(); + fn is_nan(_self: Ref<::glam::Affine3A>) -> bool { + let output: bool = ::glam::Affine3A::is_nan(&_self).into(); output } /// Creates a left-handed view transform using a camera position, an up direction, and a focal @@ -28678,11 +26378,11 @@ impl bevy::math::Affine3A { /// # Panics /// Will panic if `up` is not normalized when `glam_assert` is enabled. fn look_at_lh( - eye: Val, - center: Val, - up: Val, - ) -> Val { - let output: Val = bevy::math::Affine3A::look_at_lh( + eye: Val<::glam::Vec3>, + center: Val<::glam::Vec3>, + up: Val<::glam::Vec3>, + ) -> Val<::glam::Affine3A> { + let output: Val<::glam::Affine3A> = ::glam::Affine3A::look_at_lh( eye.into_inner(), center.into_inner(), up.into_inner(), @@ -28696,11 +26396,11 @@ impl bevy::math::Affine3A { /// # Panics /// Will panic if `up` is not normalized when `glam_assert` is enabled. fn look_at_rh( - eye: Val, - center: Val, - up: Val, - ) -> Val { - let output: Val = bevy::math::Affine3A::look_at_rh( + eye: Val<::glam::Vec3>, + center: Val<::glam::Vec3>, + up: Val<::glam::Vec3>, + ) -> Val<::glam::Affine3A> { + let output: Val<::glam::Affine3A> = ::glam::Affine3A::look_at_rh( eye.into_inner(), center.into_inner(), up.into_inner(), @@ -28712,11 +26412,11 @@ impl bevy::math::Affine3A { /// direction. /// For a view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`. fn look_to_lh( - eye: Val, - dir: Val, - up: Val, - ) -> Val { - let output: Val = bevy::math::Affine3A::look_to_lh( + eye: Val<::glam::Vec3>, + dir: Val<::glam::Vec3>, + up: Val<::glam::Vec3>, + ) -> Val<::glam::Affine3A> { + let output: Val<::glam::Affine3A> = ::glam::Affine3A::look_to_lh( eye.into_inner(), dir.into_inner(), up.into_inner(), @@ -28728,11 +26428,11 @@ impl bevy::math::Affine3A { /// direction. /// For a view coordinate system with `+X=right`, `+Y=up` and `+Z=back`. fn look_to_rh( - eye: Val, - dir: Val, - up: Val, - ) -> Val { - let output: Val = bevy::math::Affine3A::look_to_rh( + eye: Val<::glam::Vec3>, + dir: Val<::glam::Vec3>, + up: Val<::glam::Vec3>, + ) -> Val<::glam::Affine3A> { + let output: Val<::glam::Affine3A> = ::glam::Affine3A::look_to_rh( eye.into_inner(), dir.into_inner(), up.into_inner(), @@ -28741,44 +26441,40 @@ impl bevy::math::Affine3A { output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::Affine3A>, + ) -> Val<::glam::Affine3A> { + let output: Val<::glam::Affine3A> = <::glam::Affine3A as ::core::ops::Mul< + ::glam::Affine3A, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::Mat4>) -> Val<::glam::Mat4> { + let output: Val<::glam::Mat4> = <::glam::Affine3A as ::core::ops::Mul< + ::glam::Mat4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } /// Creates a `[f32; 12]` array storing data in column major order. - fn to_cols_array(_self: Ref) -> [f32; 12] { - let output: [f32; 12] = bevy::math::Affine3A::to_cols_array(&_self).into(); + fn to_cols_array(_self: Ref<::glam::Affine3A>) -> [f32; 12] { + let output: [f32; 12] = ::glam::Affine3A::to_cols_array(&_self).into(); output } /// Creates a `[[f32; 3]; 4]` 3D array storing data in /// column major order. /// If you require data in row major order `transpose` the matrix first. - fn to_cols_array_2d(_self: Ref) -> [[f32; 3]; 4] { - let output: [[f32; 3]; 4] = bevy::math::Affine3A::to_cols_array_2d(&_self) - .into(); + fn to_cols_array_2d(_self: Ref<::glam::Affine3A>) -> [[f32; 3]; 4] { + let output: [[f32; 3]; 4] = ::glam::Affine3A::to_cols_array_2d(&_self).into(); output } /// Transforms the given 3D points, applying shear, scale, rotation and translation. fn transform_point3( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Affine3A::transform_point3( + _self: Ref<::glam::Affine3A>, + rhs: Val<::glam::Vec3>, + ) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Affine3A::transform_point3( &_self, rhs.into_inner(), ) @@ -28787,10 +26483,10 @@ impl bevy::math::Affine3A { } /// Transforms the given [`Vec3A`], applying shear, scale, rotation and translation. fn transform_point3a( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Affine3A::transform_point3a( + _self: Ref<::glam::Affine3A>, + rhs: Val<::glam::Vec3A>, + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Affine3A::transform_point3a( &_self, rhs.into_inner(), ) @@ -28801,10 +26497,10 @@ impl bevy::math::Affine3A { /// translation). /// To also apply translation, use [`Self::transform_point3()`] instead. fn transform_vector3( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Affine3A::transform_vector3( + _self: Ref<::glam::Affine3A>, + rhs: Val<::glam::Vec3>, + ) -> Val<::glam::Vec3> { + let output: Val<::glam::Vec3> = ::glam::Affine3A::transform_vector3( &_self, rhs.into_inner(), ) @@ -28815,10 +26511,10 @@ impl bevy::math::Affine3A { /// translation). /// To also apply translation, use [`Self::transform_point3a()`] instead. fn transform_vector3a( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::Affine3A::transform_vector3a( + _self: Ref<::glam::Affine3A>, + rhs: Val<::glam::Vec3A>, + ) -> Val<::glam::Vec3A> { + let output: Val<::glam::Vec3A> = ::glam::Affine3A::transform_vector3a( &_self, rhs.into_inner(), ) @@ -28832,7 +26528,7 @@ impl bevy::math::Affine3A { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::DAffine2 { +impl ::glam::DAffine2 { /// Returns true if the absolute difference of all elements between `self` and `rhs` /// is less than or equal to `max_abs_diff`. /// This can be used to compare if two 3x4 matrices contain similar elements. It works @@ -28841,11 +26537,11 @@ impl bevy::math::DAffine2 { /// For more see /// [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/). fn abs_diff_eq( - _self: Ref, - rhs: Val, + _self: Ref<::glam::DAffine2>, + rhs: Val<::glam::DAffine2>, max_abs_diff: f64, ) -> bool { - let output: bool = bevy::math::DAffine2::abs_diff_eq( + let output: bool = ::glam::DAffine2::abs_diff_eq( &_self, rhs.into_inner(), max_abs_diff, @@ -28853,24 +26549,23 @@ impl bevy::math::DAffine2 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::DAffine2>) -> Val<::glam::DAffine2> { + let output: Val<::glam::DAffine2> = <::glam::DAffine2 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); output } - fn eq(_self: Ref, rhs: Ref) -> bool { - let output: bool = , rhs: Ref<::glam::DAffine2>) -> bool { + let output: bool = <::glam::DAffine2 as ::core::cmp::PartialEq< + ::glam::DAffine2, >>::eq(&_self, &rhs) .into(); output } /// Creates an affine transform from the given rotation `angle`. - fn from_angle(angle: f64) -> Val { - let output: Val = bevy::math::DAffine2::from_angle(angle) - .into(); + fn from_angle(angle: f64) -> Val<::glam::DAffine2> { + let output: Val<::glam::DAffine2> = ::glam::DAffine2::from_angle(angle).into(); output } /// Creates an affine transform from the given 2D rotation `angle` (in radians) and @@ -28878,9 +26573,9 @@ impl bevy::math::DAffine2 { /// Equivalent to `DAffine2::from_translation(translation) * DAffine2::from_angle(angle)` fn from_angle_translation( angle: f64, - translation: Val, - ) -> Val { - let output: Val = bevy::math::DAffine2::from_angle_translation( + translation: Val<::glam::DVec2>, + ) -> Val<::glam::DAffine2> { + let output: Val<::glam::DAffine2> = ::glam::DAffine2::from_angle_translation( angle, translation.into_inner(), ) @@ -28889,11 +26584,11 @@ impl bevy::math::DAffine2 { } /// Creates an affine transform from three column vectors. fn from_cols( - x_axis: Val, - y_axis: Val, - z_axis: Val, - ) -> Val { - let output: Val = bevy::math::DAffine2::from_cols( + x_axis: Val<::glam::DVec2>, + y_axis: Val<::glam::DVec2>, + z_axis: Val<::glam::DVec2>, + ) -> Val<::glam::DAffine2> { + let output: Val<::glam::DAffine2> = ::glam::DAffine2::from_cols( x_axis.into_inner(), y_axis.into_inner(), z_axis.into_inner(), @@ -28902,8 +26597,8 @@ impl bevy::math::DAffine2 { output } /// Creates an affine transform from a 2x2 matrix (expressing scale, shear and rotation) - fn from_mat2(matrix2: Val) -> Val { - let output: Val = bevy::math::DAffine2::from_mat2( + fn from_mat2(matrix2: Val<::glam::DMat2>) -> Val<::glam::DAffine2> { + let output: Val<::glam::DAffine2> = ::glam::DAffine2::from_mat2( matrix2.into_inner(), ) .into(); @@ -28914,10 +26609,10 @@ impl bevy::math::DAffine2 { /// Equivalent to /// `DAffine2::from_translation(translation) * DAffine2::from_mat2(mat2)` fn from_mat2_translation( - matrix2: Val, - translation: Val, - ) -> Val { - let output: Val = bevy::math::DAffine2::from_mat2_translation( + matrix2: Val<::glam::DMat2>, + translation: Val<::glam::DVec2>, + ) -> Val<::glam::DAffine2> { + let output: Val<::glam::DAffine2> = ::glam::DAffine2::from_mat2_translation( matrix2.into_inner(), translation.into_inner(), ) @@ -28925,17 +26620,15 @@ impl bevy::math::DAffine2 { output } /// The given `DMat3` must be an affine transform, - fn from_mat3(m: Val) -> Val { - let output: Val = bevy::math::DAffine2::from_mat3( - m.into_inner(), - ) + fn from_mat3(m: Val<::glam::DMat3>) -> Val<::glam::DAffine2> { + let output: Val<::glam::DAffine2> = ::glam::DAffine2::from_mat3(m.into_inner()) .into(); output } /// Creates an affine transform that changes scale. /// Note that if any scale is zero the transform will be non-invertible. - fn from_scale(scale: Val) -> Val { - let output: Val = bevy::math::DAffine2::from_scale( + fn from_scale(scale: Val<::glam::DVec2>) -> Val<::glam::DAffine2> { + let output: Val<::glam::DAffine2> = ::glam::DAffine2::from_scale( scale.into_inner(), ) .into(); @@ -28946,11 +26639,11 @@ impl bevy::math::DAffine2 { /// Equivalent to `DAffine2::from_translation(translation) * /// DAffine2::from_angle(angle) * DAffine2::from_scale(scale)` fn from_scale_angle_translation( - scale: Val, + scale: Val<::glam::DVec2>, angle: f64, - translation: Val, - ) -> Val { - let output: Val = bevy::math::DAffine2::from_scale_angle_translation( + translation: Val<::glam::DVec2>, + ) -> Val<::glam::DAffine2> { + let output: Val<::glam::DAffine2> = ::glam::DAffine2::from_scale_angle_translation( scale.into_inner(), angle, translation.into_inner(), @@ -28959,10 +26652,8 @@ impl bevy::math::DAffine2 { output } /// Creates an affine transformation from the given 2D `translation`. - fn from_translation( - translation: Val, - ) -> Val { - let output: Val = bevy::math::DAffine2::from_translation( + fn from_translation(translation: Val<::glam::DVec2>) -> Val<::glam::DAffine2> { + let output: Val<::glam::DAffine2> = ::glam::DAffine2::from_translation( translation.into_inner(), ) .into(); @@ -28970,62 +26661,57 @@ impl bevy::math::DAffine2 { } /// Return the inverse of this transform. /// Note that if the transform is not invertible the result will be invalid. - fn inverse(_self: Ref) -> Val { - let output: Val = bevy::math::DAffine2::inverse(&_self) - .into(); + fn inverse(_self: Ref<::glam::DAffine2>) -> Val<::glam::DAffine2> { + let output: Val<::glam::DAffine2> = ::glam::DAffine2::inverse(&_self).into(); output } /// Returns `true` if, and only if, all elements are finite. /// If any element is either `NaN`, positive or negative infinity, this will return /// `false`. - fn is_finite(_self: Ref) -> bool { - let output: bool = bevy::math::DAffine2::is_finite(&_self).into(); + fn is_finite(_self: Ref<::glam::DAffine2>) -> bool { + let output: bool = ::glam::DAffine2::is_finite(&_self).into(); output } /// Returns `true` if any elements are `NaN`. - fn is_nan(_self: Ref) -> bool { - let output: bool = bevy::math::DAffine2::is_nan(&_self).into(); + fn is_nan(_self: Ref<::glam::DAffine2>) -> bool { + let output: bool = ::glam::DAffine2::is_nan(&_self).into(); output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::DAffine2>, + ) -> Val<::glam::DAffine2> { + let output: Val<::glam::DAffine2> = <::glam::DAffine2 as ::core::ops::Mul< + ::glam::DAffine2, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DMat3>) -> Val<::glam::DMat3> { + let output: Val<::glam::DMat3> = <::glam::DAffine2 as ::core::ops::Mul< + ::glam::DMat3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } /// Creates a `[f64; 6]` array storing data in column major order. - fn to_cols_array(_self: Ref) -> [f64; 6] { - let output: [f64; 6] = bevy::math::DAffine2::to_cols_array(&_self).into(); + fn to_cols_array(_self: Ref<::glam::DAffine2>) -> [f64; 6] { + let output: [f64; 6] = ::glam::DAffine2::to_cols_array(&_self).into(); output } /// Creates a `[[f64; 2]; 3]` 2D array storing data in /// column major order. /// If you require data in row major order `transpose` the matrix first. - fn to_cols_array_2d(_self: Ref) -> [[f64; 2]; 3] { - let output: [[f64; 2]; 3] = bevy::math::DAffine2::to_cols_array_2d(&_self) - .into(); + fn to_cols_array_2d(_self: Ref<::glam::DAffine2>) -> [[f64; 2]; 3] { + let output: [[f64; 2]; 3] = ::glam::DAffine2::to_cols_array_2d(&_self).into(); output } /// Transforms the given 2D point, applying shear, scale, rotation and translation. fn transform_point2( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DAffine2::transform_point2( + _self: Ref<::glam::DAffine2>, + rhs: Val<::glam::DVec2>, + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DAffine2::transform_point2( &_self, rhs.into_inner(), ) @@ -29036,10 +26722,10 @@ impl bevy::math::DAffine2 { /// translation). /// To also apply translation, use [`Self::transform_point2()`] instead. fn transform_vector2( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DAffine2::transform_vector2( + _self: Ref<::glam::DAffine2>, + rhs: Val<::glam::DVec2>, + ) -> Val<::glam::DVec2> { + let output: Val<::glam::DVec2> = ::glam::DAffine2::transform_vector2( &_self, rhs.into_inner(), ) @@ -29053,7 +26739,7 @@ impl bevy::math::DAffine2 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::DAffine3 { +impl ::glam::DAffine3 { /// Returns true if the absolute difference of all elements between `self` and `rhs` /// is less than or equal to `max_abs_diff`. /// This can be used to compare if two 3x4 matrices contain similar elements. It works @@ -29062,11 +26748,11 @@ impl bevy::math::DAffine3 { /// For more see /// [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/). fn abs_diff_eq( - _self: Ref, - rhs: Val, + _self: Ref<::glam::DAffine3>, + rhs: Val<::glam::DAffine3>, max_abs_diff: f64, ) -> bool { - let output: bool = bevy::math::DAffine3::abs_diff_eq( + let output: bool = ::glam::DAffine3::abs_diff_eq( &_self, rhs.into_inner(), max_abs_diff, @@ -29074,27 +26760,24 @@ impl bevy::math::DAffine3 { .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::DAffine3>) -> Val<::glam::DAffine3> { + let output: Val<::glam::DAffine3> = <::glam::DAffine3 as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); output } - fn eq(_self: Ref, rhs: Ref) -> bool { - let output: bool = , rhs: Ref<::glam::DAffine3>) -> bool { + let output: bool = <::glam::DAffine3 as ::core::cmp::PartialEq< + ::glam::DAffine3, >>::eq(&_self, &rhs) .into(); output } /// Creates an affine transform containing a 3D rotation around a normalized /// rotation `axis` of `angle` (in radians). - fn from_axis_angle( - axis: Val, - angle: f64, - ) -> Val { - let output: Val = bevy::math::DAffine3::from_axis_angle( + fn from_axis_angle(axis: Val<::glam::DVec3>, angle: f64) -> Val<::glam::DAffine3> { + let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_axis_angle( axis.into_inner(), angle, ) @@ -29103,12 +26786,12 @@ impl bevy::math::DAffine3 { } /// Creates an affine transform from three column vectors. fn from_cols( - x_axis: Val, - y_axis: Val, - z_axis: Val, - w_axis: Val, - ) -> Val { - let output: Val = bevy::math::DAffine3::from_cols( + x_axis: Val<::glam::DVec3>, + y_axis: Val<::glam::DVec3>, + z_axis: Val<::glam::DVec3>, + w_axis: Val<::glam::DVec3>, + ) -> Val<::glam::DAffine3> { + let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_cols( x_axis.into_inner(), y_axis.into_inner(), z_axis.into_inner(), @@ -29119,8 +26802,8 @@ impl bevy::math::DAffine3 { } /// Creates an affine transform from a 3x3 matrix (expressing scale, shear and /// rotation) - fn from_mat3(mat3: Val) -> Val { - let output: Val = bevy::math::DAffine3::from_mat3( + fn from_mat3(mat3: Val<::glam::DMat3>) -> Val<::glam::DAffine3> { + let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_mat3( mat3.into_inner(), ) .into(); @@ -29130,10 +26813,10 @@ impl bevy::math::DAffine3 { /// and a translation vector. /// Equivalent to `DAffine3::from_translation(translation) * DAffine3::from_mat3(mat3)` fn from_mat3_translation( - mat3: Val, - translation: Val, - ) -> Val { - let output: Val = bevy::math::DAffine3::from_mat3_translation( + mat3: Val<::glam::DMat3>, + translation: Val<::glam::DVec3>, + ) -> Val<::glam::DAffine3> { + let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_mat3_translation( mat3.into_inner(), translation.into_inner(), ) @@ -29142,16 +26825,14 @@ impl bevy::math::DAffine3 { } /// The given `DMat4` must be an affine transform, /// i.e. contain no perspective transform. - fn from_mat4(m: Val) -> Val { - let output: Val = bevy::math::DAffine3::from_mat4( - m.into_inner(), - ) + fn from_mat4(m: Val<::glam::DMat4>) -> Val<::glam::DAffine3> { + let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_mat4(m.into_inner()) .into(); output } /// Creates an affine transform from the given `rotation` quaternion. - fn from_quat(rotation: Val) -> Val { - let output: Val = bevy::math::DAffine3::from_quat( + fn from_quat(rotation: Val<::glam::DQuat>) -> Val<::glam::DAffine3> { + let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_quat( rotation.into_inner(), ) .into(); @@ -29160,10 +26841,10 @@ impl bevy::math::DAffine3 { /// Creates an affine transform from the given 3D `rotation` and `translation`. /// Equivalent to `DAffine3::from_translation(translation) * DAffine3::from_quat(rotation)` fn from_rotation_translation( - rotation: Val, - translation: Val, - ) -> Val { - let output: Val = bevy::math::DAffine3::from_rotation_translation( + rotation: Val<::glam::DQuat>, + translation: Val<::glam::DVec3>, + ) -> Val<::glam::DAffine3> { + let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_rotation_translation( rotation.into_inner(), translation.into_inner(), ) @@ -29172,35 +26853,29 @@ impl bevy::math::DAffine3 { } /// Creates an affine transform containing a 3D rotation around the x axis of /// `angle` (in radians). - fn from_rotation_x(angle: f64) -> Val { - let output: Val = bevy::math::DAffine3::from_rotation_x( - angle, - ) + fn from_rotation_x(angle: f64) -> Val<::glam::DAffine3> { + let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_rotation_x(angle) .into(); output } /// Creates an affine transform containing a 3D rotation around the y axis of /// `angle` (in radians). - fn from_rotation_y(angle: f64) -> Val { - let output: Val = bevy::math::DAffine3::from_rotation_y( - angle, - ) + fn from_rotation_y(angle: f64) -> Val<::glam::DAffine3> { + let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_rotation_y(angle) .into(); output } /// Creates an affine transform containing a 3D rotation around the z axis of /// `angle` (in radians). - fn from_rotation_z(angle: f64) -> Val { - let output: Val = bevy::math::DAffine3::from_rotation_z( - angle, - ) + fn from_rotation_z(angle: f64) -> Val<::glam::DAffine3> { + let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_rotation_z(angle) .into(); output } /// Creates an affine transform that changes scale. /// Note that if any scale is zero the transform will be non-invertible. - fn from_scale(scale: Val) -> Val { - let output: Val = bevy::math::DAffine3::from_scale( + fn from_scale(scale: Val<::glam::DVec3>) -> Val<::glam::DAffine3> { + let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_scale( scale.into_inner(), ) .into(); @@ -29211,11 +26886,11 @@ impl bevy::math::DAffine3 { /// Equivalent to `DAffine3::from_translation(translation) * /// DAffine3::from_quat(rotation) * DAffine3::from_scale(scale)` fn from_scale_rotation_translation( - scale: Val, - rotation: Val, - translation: Val, - ) -> Val { - let output: Val = bevy::math::DAffine3::from_scale_rotation_translation( + scale: Val<::glam::DVec3>, + rotation: Val<::glam::DQuat>, + translation: Val<::glam::DVec3>, + ) -> Val<::glam::DAffine3> { + let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_scale_rotation_translation( scale.into_inner(), rotation.into_inner(), translation.into_inner(), @@ -29224,10 +26899,8 @@ impl bevy::math::DAffine3 { output } /// Creates an affine transformation from the given 3D `translation`. - fn from_translation( - translation: Val, - ) -> Val { - let output: Val = bevy::math::DAffine3::from_translation( + fn from_translation(translation: Val<::glam::DVec3>) -> Val<::glam::DAffine3> { + let output: Val<::glam::DAffine3> = ::glam::DAffine3::from_translation( translation.into_inner(), ) .into(); @@ -29235,21 +26908,20 @@ impl bevy::math::DAffine3 { } /// Return the inverse of this transform. /// Note that if the transform is not invertible the result will be invalid. - fn inverse(_self: Ref) -> Val { - let output: Val = bevy::math::DAffine3::inverse(&_self) - .into(); + fn inverse(_self: Ref<::glam::DAffine3>) -> Val<::glam::DAffine3> { + let output: Val<::glam::DAffine3> = ::glam::DAffine3::inverse(&_self).into(); output } /// Returns `true` if, and only if, all elements are finite. /// If any element is either `NaN`, positive or negative infinity, this will return /// `false`. - fn is_finite(_self: Ref) -> bool { - let output: bool = bevy::math::DAffine3::is_finite(&_self).into(); + fn is_finite(_self: Ref<::glam::DAffine3>) -> bool { + let output: bool = ::glam::DAffine3::is_finite(&_self).into(); output } /// Returns `true` if any elements are `NaN`. - fn is_nan(_self: Ref) -> bool { - let output: bool = bevy::math::DAffine3::is_nan(&_self).into(); + fn is_nan(_self: Ref<::glam::DAffine3>) -> bool { + let output: bool = ::glam::DAffine3::is_nan(&_self).into(); output } /// Creates a left-handed view transform using a camera position, an up direction, and a focal @@ -29258,11 +26930,11 @@ impl bevy::math::DAffine3 { /// # Panics /// Will panic if `up` is not normalized when `glam_assert` is enabled. fn look_at_lh( - eye: Val, - center: Val, - up: Val, - ) -> Val { - let output: Val = bevy::math::DAffine3::look_at_lh( + eye: Val<::glam::DVec3>, + center: Val<::glam::DVec3>, + up: Val<::glam::DVec3>, + ) -> Val<::glam::DAffine3> { + let output: Val<::glam::DAffine3> = ::glam::DAffine3::look_at_lh( eye.into_inner(), center.into_inner(), up.into_inner(), @@ -29276,11 +26948,11 @@ impl bevy::math::DAffine3 { /// # Panics /// Will panic if `up` is not normalized when `glam_assert` is enabled. fn look_at_rh( - eye: Val, - center: Val, - up: Val, - ) -> Val { - let output: Val = bevy::math::DAffine3::look_at_rh( + eye: Val<::glam::DVec3>, + center: Val<::glam::DVec3>, + up: Val<::glam::DVec3>, + ) -> Val<::glam::DAffine3> { + let output: Val<::glam::DAffine3> = ::glam::DAffine3::look_at_rh( eye.into_inner(), center.into_inner(), up.into_inner(), @@ -29292,11 +26964,11 @@ impl bevy::math::DAffine3 { /// direction. /// For a view coordinate system with `+X=right`, `+Y=up` and `+Z=forward`. fn look_to_lh( - eye: Val, - dir: Val, - up: Val, - ) -> Val { - let output: Val = bevy::math::DAffine3::look_to_lh( + eye: Val<::glam::DVec3>, + dir: Val<::glam::DVec3>, + up: Val<::glam::DVec3>, + ) -> Val<::glam::DAffine3> { + let output: Val<::glam::DAffine3> = ::glam::DAffine3::look_to_lh( eye.into_inner(), dir.into_inner(), up.into_inner(), @@ -29308,11 +26980,11 @@ impl bevy::math::DAffine3 { /// direction. /// For a view coordinate system with `+X=right`, `+Y=up` and `+Z=back`. fn look_to_rh( - eye: Val, - dir: Val, - up: Val, - ) -> Val { - let output: Val = bevy::math::DAffine3::look_to_rh( + eye: Val<::glam::DVec3>, + dir: Val<::glam::DVec3>, + up: Val<::glam::DVec3>, + ) -> Val<::glam::DAffine3> { + let output: Val<::glam::DAffine3> = ::glam::DAffine3::look_to_rh( eye.into_inner(), dir.into_inner(), up.into_inner(), @@ -29321,44 +26993,40 @@ impl bevy::math::DAffine3 { output } fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , + rhs: Val<::glam::DAffine3>, + ) -> Val<::glam::DAffine3> { + let output: Val<::glam::DAffine3> = <::glam::DAffine3 as ::core::ops::Mul< + ::glam::DAffine3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DMat4>) -> Val<::glam::DMat4> { + let output: Val<::glam::DMat4> = <::glam::DAffine3 as ::core::ops::Mul< + ::glam::DMat4, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } /// Creates a `[f64; 12]` array storing data in column major order. - fn to_cols_array(_self: Ref) -> [f64; 12] { - let output: [f64; 12] = bevy::math::DAffine3::to_cols_array(&_self).into(); + fn to_cols_array(_self: Ref<::glam::DAffine3>) -> [f64; 12] { + let output: [f64; 12] = ::glam::DAffine3::to_cols_array(&_self).into(); output } /// Creates a `[[f64; 3]; 4]` 3D array storing data in /// column major order. /// If you require data in row major order `transpose` the matrix first. - fn to_cols_array_2d(_self: Ref) -> [[f64; 3]; 4] { - let output: [[f64; 3]; 4] = bevy::math::DAffine3::to_cols_array_2d(&_self) - .into(); + fn to_cols_array_2d(_self: Ref<::glam::DAffine3>) -> [[f64; 3]; 4] { + let output: [[f64; 3]; 4] = ::glam::DAffine3::to_cols_array_2d(&_self).into(); output } /// Transforms the given 3D points, applying shear, scale, rotation and translation. fn transform_point3( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DAffine3::transform_point3( + _self: Ref<::glam::DAffine3>, + rhs: Val<::glam::DVec3>, + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DAffine3::transform_point3( &_self, rhs.into_inner(), ) @@ -29369,10 +27037,10 @@ impl bevy::math::DAffine3 { /// translation). /// To also apply translation, use [`Self::transform_point3()`] instead. fn transform_vector3( - _self: Ref, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DAffine3::transform_vector3( + _self: Ref<::glam::DAffine3>, + rhs: Val<::glam::DVec3>, + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DAffine3::transform_vector3( &_self, rhs.into_inner(), ) @@ -29386,7 +27054,7 @@ impl bevy::math::DAffine3 { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::DQuat { +impl ::glam::DQuat { /// Returns true if the absolute difference of all elements between `self` and `rhs` /// is less than or equal to `max_abs_diff`. /// This can be used to compare if two quaternions contain similar elements. It works @@ -29395,11 +27063,11 @@ impl bevy::math::DQuat { /// For more see /// [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/). fn abs_diff_eq( - _self: Val, - rhs: Val, + _self: Val<::glam::DQuat>, + rhs: Val<::glam::DQuat>, max_abs_diff: f64, ) -> bool { - let output: bool = bevy::math::DQuat::abs_diff_eq( + let output: bool = ::glam::DQuat::abs_diff_eq( _self.into_inner(), rhs.into_inner(), max_abs_diff, @@ -29411,12 +27079,9 @@ impl bevy::math::DQuat { /// The sum is not guaranteed to be normalized. /// Note that addition is not the same as combining the rotations represented by the /// two quaternions! That corresponds to multiplication. - fn add( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DQuat>) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Add< + ::glam::DQuat, >>::add(_self.into_inner(), rhs.into_inner()) .into(); output @@ -29426,23 +27091,21 @@ impl bevy::math::DQuat { /// Both quaternions must be normalized. /// # Panics /// Will panic if `self` or `rhs` are not normalized when `glam_assert` is enabled. - fn angle_between(_self: Val, rhs: Val) -> f64 { - let output: f64 = bevy::math::DQuat::angle_between( + fn angle_between(_self: Val<::glam::DQuat>, rhs: Val<::glam::DQuat>) -> f64 { + let output: f64 = ::glam::DQuat::angle_between( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn as_quat(_self: Val) -> Val { - let output: Val = bevy::math::DQuat::as_quat( - _self.into_inner(), - ) + fn as_quat(_self: Val<::glam::DQuat>) -> Val<::glam::Quat> { + let output: Val<::glam::Quat> = ::glam::DQuat::as_quat(_self.into_inner()) .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::DQuat>) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = <::glam::DQuat as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -29450,17 +27113,15 @@ impl bevy::math::DQuat { } /// Returns the quaternion conjugate of `self`. For a unit quaternion the /// conjugate is also the inverse. - fn conjugate(_self: Val) -> Val { - let output: Val = bevy::math::DQuat::conjugate( - _self.into_inner(), - ) + fn conjugate(_self: Val<::glam::DQuat>) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = ::glam::DQuat::conjugate(_self.into_inner()) .into(); output } /// Divides a quaternion by a scalar value. /// The quotient is not guaranteed to be normalized. - fn div(_self: Val, rhs: f64) -> Val { - let output: Val = , rhs: f64) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Div< f64, >>::div(_self.into_inner(), rhs) .into(); @@ -29468,14 +27129,14 @@ impl bevy::math::DQuat { } /// Computes the dot product of `self` and `rhs`. The dot product is /// equal to the cosine of the angle between two quaternion rotations. - fn dot(_self: Val, rhs: Val) -> f64 { - let output: f64 = bevy::math::DQuat::dot(_self.into_inner(), rhs.into_inner()) + fn dot(_self: Val<::glam::DQuat>, rhs: Val<::glam::DQuat>) -> f64 { + let output: f64 = ::glam::DQuat::dot(_self.into_inner(), rhs.into_inner()) .into(); output } - fn eq(_self: Ref, rhs: Ref) -> bool { - let output: bool = , rhs: Ref<::glam::DQuat>) -> bool { + let output: bool = <::glam::DQuat as ::core::cmp::PartialEq< + ::glam::DQuat, >>::eq(&_self, &rhs) .into(); output @@ -29486,27 +27147,24 @@ impl bevy::math::DQuat { /// # Panics /// Will panic if any input affine matrix column is not normalized when `glam_assert` is /// enabled. - fn from_affine3(a: Ref) -> Val { - let output: Val = bevy::math::DQuat::from_affine3(&a).into(); + fn from_affine3(a: Ref<::glam::DAffine3>) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = ::glam::DQuat::from_affine3(&a).into(); output } /// Creates a rotation quaternion from an array. /// # Preconditions /// This function does not check if the input is normalized, it is up to the user to /// provide normalized input or to normalized the resulting quaternion. - fn from_array(a: [f64; 4]) -> Val { - let output: Val = bevy::math::DQuat::from_array(a).into(); + fn from_array(a: [f64; 4]) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = ::glam::DQuat::from_array(a).into(); output } /// Create a quaternion for a normalized rotation `axis` and `angle` (in radians). /// The axis must be a unit vector. /// # Panics /// Will panic if `axis` is not normalized when `glam_assert` is enabled. - fn from_axis_angle( - axis: Val, - angle: f64, - ) -> Val { - let output: Val = bevy::math::DQuat::from_axis_angle( + fn from_axis_angle(axis: Val<::glam::DVec3>, angle: f64) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = ::glam::DQuat::from_axis_angle( axis.into_inner(), angle, ) @@ -29515,12 +27173,12 @@ impl bevy::math::DQuat { } /// Creates a quaternion from the given Euler rotation sequence and the angles (in radians). fn from_euler( - euler: Val, + euler: Val<::glam::EulerRot>, a: f64, b: f64, c: f64, - ) -> Val { - let output: Val = bevy::math::DQuat::from_euler( + ) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = ::glam::DQuat::from_euler( euler.into_inner(), a, b, @@ -29534,8 +27192,8 @@ impl bevy::math::DQuat { /// the resulting quaternion will be ill-defined. /// # Panics /// Will panic if any input matrix column is not normalized when `glam_assert` is enabled. - fn from_mat3(mat: Ref) -> Val { - let output: Val = bevy::math::DQuat::from_mat3(&mat).into(); + fn from_mat3(mat: Ref<::glam::DMat3>) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = ::glam::DQuat::from_mat3(&mat).into(); output } /// Creates a quaternion from the upper 3x3 rotation matrix inside a homogeneous 4x4 matrix. @@ -29544,8 +27202,8 @@ impl bevy::math::DQuat { /// # Panics /// Will panic if any column of the upper 3x3 rotation matrix is not normalized when /// `glam_assert` is enabled. - fn from_mat4(mat: Ref) -> Val { - let output: Val = bevy::math::DQuat::from_mat4(&mat).into(); + fn from_mat4(mat: Ref<::glam::DMat4>) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = ::glam::DQuat::from_mat4(&mat).into(); output } /// Gets the minimal rotation for transforming `from` to `to`. The rotation is in the @@ -29557,10 +27215,10 @@ impl bevy::math::DQuat { /// # Panics /// Will panic if `from` or `to` are not normalized when `glam_assert` is enabled. fn from_rotation_arc( - from: Val, - to: Val, - ) -> Val { - let output: Val = bevy::math::DQuat::from_rotation_arc( + from: Val<::glam::DVec3>, + to: Val<::glam::DVec3>, + ) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = ::glam::DQuat::from_rotation_arc( from.into_inner(), to.into_inner(), ) @@ -29576,10 +27234,10 @@ impl bevy::math::DQuat { /// # Panics /// Will panic if `from` or `to` are not normalized when `glam_assert` is enabled. fn from_rotation_arc_2d( - from: Val, - to: Val, - ) -> Val { - let output: Val = bevy::math::DQuat::from_rotation_arc_2d( + from: Val<::glam::DVec2>, + to: Val<::glam::DVec2>, + ) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = ::glam::DQuat::from_rotation_arc_2d( from.into_inner(), to.into_inner(), ) @@ -29595,10 +27253,10 @@ impl bevy::math::DQuat { /// # Panics /// Will panic if `from` or `to` are not normalized when `glam_assert` is enabled. fn from_rotation_arc_colinear( - from: Val, - to: Val, - ) -> Val { - let output: Val = bevy::math::DQuat::from_rotation_arc_colinear( + from: Val<::glam::DVec3>, + to: Val<::glam::DVec3>, + ) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = ::glam::DQuat::from_rotation_arc_colinear( from.into_inner(), to.into_inner(), ) @@ -29606,29 +27264,24 @@ impl bevy::math::DQuat { output } /// Creates a quaternion from the `angle` (in radians) around the x axis. - fn from_rotation_x(angle: f64) -> Val { - let output: Val = bevy::math::DQuat::from_rotation_x(angle) - .into(); + fn from_rotation_x(angle: f64) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = ::glam::DQuat::from_rotation_x(angle).into(); output } /// Creates a quaternion from the `angle` (in radians) around the y axis. - fn from_rotation_y(angle: f64) -> Val { - let output: Val = bevy::math::DQuat::from_rotation_y(angle) - .into(); + fn from_rotation_y(angle: f64) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = ::glam::DQuat::from_rotation_y(angle).into(); output } /// Creates a quaternion from the `angle` (in radians) around the z axis. - fn from_rotation_z(angle: f64) -> Val { - let output: Val = bevy::math::DQuat::from_rotation_z(angle) - .into(); + fn from_rotation_z(angle: f64) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = ::glam::DQuat::from_rotation_z(angle).into(); output } /// Create a quaternion that rotates `v.length()` radians around `v.normalize()`. /// `from_scaled_axis(Vec3::ZERO)` results in the identity quaternion. - fn from_scaled_axis(v: Val) -> Val { - let output: Val = bevy::math::DQuat::from_scaled_axis( - v.into_inner(), - ) + fn from_scaled_axis(v: Val<::glam::DVec3>) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = ::glam::DQuat::from_scaled_axis(v.into_inner()) .into(); output } @@ -29636,9 +27289,8 @@ impl bevy::math::DQuat { /// # Preconditions /// This function does not check if the input is normalized, it is up to the user to /// provide normalized input or to normalized the resulting quaternion. - fn from_vec4(v: Val) -> Val { - let output: Val = bevy::math::DQuat::from_vec4(v.into_inner()) - .into(); + fn from_vec4(v: Val<::glam::DVec4>) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = ::glam::DQuat::from_vec4(v.into_inner()).into(); output } /// Creates a new rotation quaternion. @@ -29648,9 +27300,8 @@ impl bevy::math::DQuat { /// # Preconditions /// This function does not check if the input is normalized, it is up to the user to /// provide normalized input or to normalized the resulting quaternion. - fn from_xyzw(x: f64, y: f64, z: f64, w: f64) -> Val { - let output: Val = bevy::math::DQuat::from_xyzw(x, y, z, w) - .into(); + fn from_xyzw(x: f64, y: f64, z: f64, w: f64) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = ::glam::DQuat::from_xyzw(x, y, z, w).into(); output } /// Returns the inverse of a normalized quaternion. @@ -29659,51 +27310,48 @@ impl bevy::math::DQuat { /// before returning the conjugate. /// # Panics /// Will panic if `self` is not normalized when `glam_assert` is enabled. - fn inverse(_self: Val) -> Val { - let output: Val = bevy::math::DQuat::inverse( - _self.into_inner(), - ) + fn inverse(_self: Val<::glam::DQuat>) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = ::glam::DQuat::inverse(_self.into_inner()) .into(); output } /// Returns `true` if, and only if, all elements are finite. /// If any element is either `NaN`, positive or negative infinity, this will return `false`. - fn is_finite(_self: Val) -> bool { - let output: bool = bevy::math::DQuat::is_finite(_self.into_inner()).into(); + fn is_finite(_self: Val<::glam::DQuat>) -> bool { + let output: bool = ::glam::DQuat::is_finite(_self.into_inner()).into(); output } /// Returns `true` if any elements are `NAN`. - fn is_nan(_self: Val) -> bool { - let output: bool = bevy::math::DQuat::is_nan(_self.into_inner()).into(); + fn is_nan(_self: Val<::glam::DQuat>) -> bool { + let output: bool = ::glam::DQuat::is_nan(_self.into_inner()).into(); output } - fn is_near_identity(_self: Val) -> bool { - let output: bool = bevy::math::DQuat::is_near_identity(_self.into_inner()) - .into(); + fn is_near_identity(_self: Val<::glam::DQuat>) -> bool { + let output: bool = ::glam::DQuat::is_near_identity(_self.into_inner()).into(); output } /// Returns whether `self` of length `1.0` or not. /// Uses a precision threshold of `1e-6`. - fn is_normalized(_self: Val) -> bool { - let output: bool = bevy::math::DQuat::is_normalized(_self.into_inner()).into(); + fn is_normalized(_self: Val<::glam::DQuat>) -> bool { + let output: bool = ::glam::DQuat::is_normalized(_self.into_inner()).into(); output } /// Computes the length of `self`. - fn length(_self: Val) -> f64 { - let output: f64 = bevy::math::DQuat::length(_self.into_inner()).into(); + fn length(_self: Val<::glam::DQuat>) -> f64 { + let output: f64 = ::glam::DQuat::length(_self.into_inner()).into(); output } /// Computes `1.0 / length()`. /// For valid results, `self` must _not_ be of length zero. - fn length_recip(_self: Val) -> f64 { - let output: f64 = bevy::math::DQuat::length_recip(_self.into_inner()).into(); + fn length_recip(_self: Val<::glam::DQuat>) -> f64 { + let output: f64 = ::glam::DQuat::length_recip(_self.into_inner()).into(); output } /// Computes the squared length of `self`. /// This is generally faster than `length()` as it avoids a square /// root operation. - fn length_squared(_self: Val) -> f64 { - let output: f64 = bevy::math::DQuat::length_squared(_self.into_inner()).into(); + fn length_squared(_self: Val<::glam::DQuat>) -> f64 { + let output: f64 = ::glam::DQuat::length_squared(_self.into_inner()).into(); output } /// Performs a linear interpolation between `self` and `rhs` based on @@ -29713,11 +27361,11 @@ impl bevy::math::DQuat { /// # Panics /// Will panic if `self` or `end` are not normalized when `glam_assert` is enabled. fn lerp( - _self: Val, - end: Val, + _self: Val<::glam::DQuat>, + end: Val<::glam::DQuat>, s: f64, - ) -> Val { - let output: Val = bevy::math::DQuat::lerp( + ) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = ::glam::DQuat::lerp( _self.into_inner(), end.into_inner(), s, @@ -29731,12 +27379,9 @@ impl bevy::math::DQuat { /// normalized. /// # Panics /// Will panic if `self` or `rhs` are not normalized when `glam_assert` is enabled. - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DQuat>) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Mul< + ::glam::DQuat, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output @@ -29744,20 +27389,17 @@ impl bevy::math::DQuat { /// Multiplies a quaternion and a 3D vector, returning the rotated vector. /// # Panics /// Will panic if `self` is not normalized when `glam_assert` is enabled. - fn mul( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DVec3>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = <::glam::DQuat as ::core::ops::Mul< + ::glam::DVec3, >>::mul(_self.into_inner(), rhs.into_inner()) .into(); output } /// Multiplies a quaternion by a scalar value. /// The product is not guaranteed to be normalized. - fn mul(_self: Val, rhs: f64) -> Val { - let output: Val = , rhs: f64) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Mul< f64, >>::mul(_self.into_inner(), rhs) .into(); @@ -29769,10 +27411,10 @@ impl bevy::math::DQuat { /// # Panics /// Will panic if `self` or `rhs` are not normalized when `glam_assert` is enabled. fn mul_quat( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DQuat::mul_quat( + _self: Val<::glam::DQuat>, + rhs: Val<::glam::DQuat>, + ) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = ::glam::DQuat::mul_quat( _self.into_inner(), rhs.into_inner(), ) @@ -29783,18 +27425,18 @@ impl bevy::math::DQuat { /// # Panics /// Will panic if `self` is not normalized when `glam_assert` is enabled. fn mul_vec3( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = bevy::math::DQuat::mul_vec3( + _self: Val<::glam::DQuat>, + rhs: Val<::glam::DVec3>, + ) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DQuat::mul_vec3( _self.into_inner(), rhs.into_inner(), ) .into(); output } - fn neg(_self: Val) -> Val { - let output: Val = ::neg( + fn neg(_self: Val<::glam::DQuat>) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Neg>::neg( _self.into_inner(), ) .into(); @@ -29804,10 +27446,8 @@ impl bevy::math::DQuat { /// For valid results, `self` must _not_ be of length zero. /// Panics /// Will panic if `self` is zero length when `glam_assert` is enabled. - fn normalize(_self: Val) -> Val { - let output: Val = bevy::math::DQuat::normalize( - _self.into_inner(), - ) + fn normalize(_self: Val<::glam::DQuat>) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = ::glam::DQuat::normalize(_self.into_inner()) .into(); output } @@ -29819,11 +27459,11 @@ impl bevy::math::DQuat { /// # Panics /// Will panic if `self` or `rhs` are not normalized when `glam_assert` is enabled. fn rotate_towards( - _self: Ref, - rhs: Val, + _self: Ref<::glam::DQuat>, + rhs: Val<::glam::DQuat>, max_angle: f64, - ) -> Val { - let output: Val = bevy::math::DQuat::rotate_towards( + ) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = ::glam::DQuat::rotate_towards( &_self, rhs.into_inner(), max_angle, @@ -29838,11 +27478,11 @@ impl bevy::math::DQuat { /// # Panics /// Will panic if `self` or `end` are not normalized when `glam_assert` is enabled. fn slerp( - _self: Val, - end: Val, + _self: Val<::glam::DQuat>, + end: Val<::glam::DQuat>, s: f64, - ) -> Val { - let output: Val = bevy::math::DQuat::slerp( + ) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = ::glam::DQuat::slerp( _self.into_inner(), end.into_inner(), s, @@ -29852,27 +27492,24 @@ impl bevy::math::DQuat { } /// Subtracts the `rhs` quaternion from `self`. /// The difference is not guaranteed to be normalized. - fn sub( - _self: Val, - rhs: Val, - ) -> Val { - let output: Val = , rhs: Val<::glam::DQuat>) -> Val<::glam::DQuat> { + let output: Val<::glam::DQuat> = <::glam::DQuat as ::core::ops::Sub< + ::glam::DQuat, >>::sub(_self.into_inner(), rhs.into_inner()) .into(); output } /// `[x, y, z, w]` - fn to_array(_self: Ref) -> [f64; 4] { - let output: [f64; 4] = bevy::math::DQuat::to_array(&_self).into(); + fn to_array(_self: Ref<::glam::DQuat>) -> [f64; 4] { + let output: [f64; 4] = ::glam::DQuat::to_array(&_self).into(); output } /// Returns the rotation angles for the given euler rotation sequence. fn to_euler( - _self: Val, - order: Val, + _self: Val<::glam::DQuat>, + order: Val<::glam::EulerRot>, ) -> (f64, f64, f64) { - let output: (f64, f64, f64) = bevy::math::DQuat::to_euler( + let output: (f64, f64, f64) = ::glam::DQuat::to_euler( _self.into_inner(), order.into_inner(), ) @@ -29880,17 +27517,16 @@ impl bevy::math::DQuat { output } /// Returns the rotation axis scaled by the rotation in radians. - fn to_scaled_axis(_self: Val) -> Val { - let output: Val = bevy::math::DQuat::to_scaled_axis( + fn to_scaled_axis(_self: Val<::glam::DQuat>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DQuat::to_scaled_axis( _self.into_inner(), ) .into(); output } /// Returns the vector part of the quaternion. - fn xyz(_self: Val) -> Val { - let output: Val = bevy::math::DQuat::xyz(_self.into_inner()) - .into(); + fn xyz(_self: Val<::glam::DQuat>) -> Val<::glam::DVec3> { + let output: Val<::glam::DVec3> = ::glam::DQuat::xyz(_self.into_inner()).into(); output } } @@ -29900,24 +27536,24 @@ impl bevy::math::DQuat { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::EulerRot { - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( +impl ::glam::EulerRot { + fn assert_receiver_is_total_eq(_self: Ref<::glam::EulerRot>) -> () { + let output: () = <::glam::EulerRot as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::EulerRot>) -> Val<::glam::EulerRot> { + let output: Val<::glam::EulerRot> = <::glam::EulerRot as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , other: Ref<::glam::EulerRot>) -> bool { + let output: bool = <::glam::EulerRot as ::core::cmp::PartialEq< + ::glam::EulerRot, >>::eq(&_self, &other) .into(); output @@ -29929,63 +27565,63 @@ impl bevy::math::EulerRot { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::BVec3A { +impl ::glam::BVec3A { /// Returns true if all the elements are true, false otherwise. - fn all(_self: Val) -> bool { - let output: bool = bevy::math::BVec3A::all(_self.into_inner()).into(); + fn all(_self: Val<::glam::BVec3A>) -> bool { + let output: bool = ::glam::BVec3A::all(_self.into_inner()).into(); output } /// Returns true if any of the elements are true, false otherwise. - fn any(_self: Val) -> bool { - let output: bool = bevy::math::BVec3A::any(_self.into_inner()).into(); + fn any(_self: Val<::glam::BVec3A>) -> bool { + let output: bool = ::glam::BVec3A::any(_self.into_inner()).into(); output } /// Returns a bitmask with the lowest 3 bits set from the elements of `self`. /// A true element results in a `1` bit and a false element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::BVec3A::bitmask(_self.into_inner()).into(); + fn bitmask(_self: Val<::glam::BVec3A>) -> u32 { + let output: u32 = ::glam::BVec3A::bitmask(_self.into_inner()).into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::BVec3A>) -> Val<::glam::BVec3A> { + let output: Val<::glam::BVec3A> = <::glam::BVec3A as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); output } - fn eq(_self: Ref, rhs: Ref) -> bool { - let output: bool = , rhs: Ref<::glam::BVec3A>) -> bool { + let output: bool = <::glam::BVec3A as ::core::cmp::PartialEq< + ::glam::BVec3A, >>::eq(&_self, &rhs) .into(); output } /// Creates a new vector mask from a bool array. - fn from_array(a: [bool; 3]) -> Val { - let output: Val = bevy::math::BVec3A::from_array(a).into(); + fn from_array(a: [bool; 3]) -> Val<::glam::BVec3A> { + let output: Val<::glam::BVec3A> = ::glam::BVec3A::from_array(a).into(); output } /// Creates a new vector mask. - fn new(x: bool, y: bool, z: bool) -> Val { - let output: Val = bevy::math::BVec3A::new(x, y, z).into(); + fn new(x: bool, y: bool, z: bool) -> Val<::glam::BVec3A> { + let output: Val<::glam::BVec3A> = ::glam::BVec3A::new(x, y, z).into(); output } /// Sets the element at `index`. /// Panics if `index` is greater than 2. - fn set(mut _self: Mut, index: usize, value: bool) -> () { - let output: () = bevy::math::BVec3A::set(&mut _self, index, value).into(); + fn set(mut _self: Mut<::glam::BVec3A>, index: usize, value: bool) -> () { + let output: () = ::glam::BVec3A::set(&mut _self, index, value).into(); output } /// Creates a vector mask with all elements set to `v`. - fn splat(v: bool) -> Val { - let output: Val = bevy::math::BVec3A::splat(v).into(); + fn splat(v: bool) -> Val<::glam::BVec3A> { + let output: Val<::glam::BVec3A> = ::glam::BVec3A::splat(v).into(); output } /// Tests the value at `index`. /// Panics if `index` is greater than 2. - fn test(_self: Ref, index: usize) -> bool { - let output: bool = bevy::math::BVec3A::test(&_self, index).into(); + fn test(_self: Ref<::glam::BVec3A>, index: usize) -> bool { + let output: bool = ::glam::BVec3A::test(&_self, index).into(); output } } @@ -29995,63 +27631,63 @@ impl bevy::math::BVec3A { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::math::BVec4A { +impl ::glam::BVec4A { /// Returns true if all the elements are true, false otherwise. - fn all(_self: Val) -> bool { - let output: bool = bevy::math::BVec4A::all(_self.into_inner()).into(); + fn all(_self: Val<::glam::BVec4A>) -> bool { + let output: bool = ::glam::BVec4A::all(_self.into_inner()).into(); output } /// Returns true if any of the elements are true, false otherwise. - fn any(_self: Val) -> bool { - let output: bool = bevy::math::BVec4A::any(_self.into_inner()).into(); + fn any(_self: Val<::glam::BVec4A>) -> bool { + let output: bool = ::glam::BVec4A::any(_self.into_inner()).into(); output } /// Returns a bitmask with the lowest 4 bits set from the elements of `self`. /// A true element results in a `1` bit and a false element in a `0` bit. Element `x` goes /// into the first lowest bit, element `y` into the second, etc. - fn bitmask(_self: Val) -> u32 { - let output: u32 = bevy::math::BVec4A::bitmask(_self.into_inner()).into(); + fn bitmask(_self: Val<::glam::BVec4A>) -> u32 { + let output: u32 = ::glam::BVec4A::bitmask(_self.into_inner()).into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::glam::BVec4A>) -> Val<::glam::BVec4A> { + let output: Val<::glam::BVec4A> = <::glam::BVec4A as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); output } - fn eq(_self: Ref, rhs: Ref) -> bool { - let output: bool = , rhs: Ref<::glam::BVec4A>) -> bool { + let output: bool = <::glam::BVec4A as ::core::cmp::PartialEq< + ::glam::BVec4A, >>::eq(&_self, &rhs) .into(); output } /// Creates a new vector mask from a bool array. - fn from_array(a: [bool; 4]) -> Val { - let output: Val = bevy::math::BVec4A::from_array(a).into(); + fn from_array(a: [bool; 4]) -> Val<::glam::BVec4A> { + let output: Val<::glam::BVec4A> = ::glam::BVec4A::from_array(a).into(); output } /// Creates a new vector mask. - fn new(x: bool, y: bool, z: bool, w: bool) -> Val { - let output: Val = bevy::math::BVec4A::new(x, y, z, w).into(); + fn new(x: bool, y: bool, z: bool, w: bool) -> Val<::glam::BVec4A> { + let output: Val<::glam::BVec4A> = ::glam::BVec4A::new(x, y, z, w).into(); output } /// Sets the element at `index`. /// Panics if `index` is greater than 3. - fn set(mut _self: Mut, index: usize, value: bool) -> () { - let output: () = bevy::math::BVec4A::set(&mut _self, index, value).into(); + fn set(mut _self: Mut<::glam::BVec4A>, index: usize, value: bool) -> () { + let output: () = ::glam::BVec4A::set(&mut _self, index, value).into(); output } /// Creates a vector mask with all elements set to `v`. - fn splat(v: bool) -> Val { - let output: Val = bevy::math::BVec4A::splat(v).into(); + fn splat(v: bool) -> Val<::glam::BVec4A> { + let output: Val<::glam::BVec4A> = ::glam::BVec4A::splat(v).into(); output } /// Tests the value at `index`. /// Panics if `index` is greater than 3. - fn test(_self: Ref, index: usize) -> bool { - let output: bool = bevy::math::BVec4A::test(&_self, index).into(); + fn test(_self: Ref<::glam::BVec4A>, index: usize) -> bool { + let output: bool = ::glam::BVec4A::test(&_self, index).into(); output } } @@ -30063,7 +27699,7 @@ impl bevy::math::BVec4A { )] impl ::smol_str::SmolStr { fn clone(_self: Ref<::smol_str::SmolStr>) -> Val<::smol_str::SmolStr> { - let output: Val<::smol_str::SmolStr> = <::smol_str::SmolStr as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone( + let output: Val<::smol_str::SmolStr> = <::smol_str::SmolStr as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -30147,7 +27783,7 @@ impl ::uuid::Uuid { output } fn clone(_self: Ref<::uuid::Uuid>) -> Val<::uuid::Uuid> { - let output: Val<::uuid::Uuid> = <::uuid::Uuid as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone( + let output: Val<::uuid::Uuid> = <::uuid::Uuid as ::bevy_reflect::erased_serde::__private::serde::__private::Clone>::clone( &_self, ) .into(); @@ -30291,8 +27927,8 @@ impl ::uuid::Uuid { /// node value as a 6-byte array. For other versions this will return `None`. fn get_node_id( _self: Ref<::uuid::Uuid>, - ) -> bevy::reflect::erased_serde::__private::serde::__private::Option<[u8; 6]> { - let output: bevy::reflect::erased_serde::__private::serde::__private::Option< + ) -> ::bevy_reflect::erased_serde::__private::serde::__private::Option<[u8; 6]> { + let output: ::bevy_reflect::erased_serde::__private::serde::__private::Option< [u8; 6], > = ::uuid::Uuid::get_node_id(&_self).into(); output diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_time.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_time.rs index 49b603f93c..566420cfcb 100644 --- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_time.rs +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_time.rs @@ -18,9 +18,11 @@ pub struct BevyTimeScriptingPlugin; bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::time::prelude::Fixed { - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( +impl ::bevy_time::prelude::Fixed { + fn clone( + _self: Ref<::bevy_time::prelude::Fixed>, + ) -> Val<::bevy_time::prelude::Fixed> { + let output: Val<::bevy_time::prelude::Fixed> = <::bevy_time::prelude::Fixed as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -33,9 +35,9 @@ impl bevy::time::prelude::Fixed { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::time::prelude::Real { - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( +impl ::bevy_time::prelude::Real { + fn clone(_self: Ref<::bevy_time::prelude::Real>) -> Val<::bevy_time::prelude::Real> { + let output: Val<::bevy_time::prelude::Real> = <::bevy_time::prelude::Real as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -48,16 +50,18 @@ impl bevy::time::prelude::Real { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::time::prelude::Timer { - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( +impl ::bevy_time::prelude::Timer { + fn assert_receiver_is_total_eq(_self: Ref<::bevy_time::prelude::Timer>) -> () { + let output: () = <::bevy_time::prelude::Timer as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone( + _self: Ref<::bevy_time::prelude::Timer>, + ) -> Val<::bevy_time::prelude::Timer> { + let output: Val<::bevy_time::prelude::Timer> = <::bevy_time::prelude::Timer as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -71,8 +75,8 @@ impl bevy::time::prelude::Timer { /// let timer = Timer::new(Duration::from_secs(1), TimerMode::Once); /// assert_eq!(timer.duration(), Duration::from_secs(1)); /// ``` - fn duration(_self: Ref) -> Val<::core::time::Duration> { - let output: Val<::core::time::Duration> = bevy::time::prelude::Timer::duration( + fn duration(_self: Ref<::bevy_time::prelude::Timer>) -> Val<::core::time::Duration> { + let output: Val<::core::time::Duration> = ::bevy_time::prelude::Timer::duration( &_self, ) .into(); @@ -89,8 +93,8 @@ impl bevy::time::prelude::Timer { /// timer.tick(Duration::from_secs_f32(0.5)); /// assert_eq!(timer.elapsed(), Duration::from_secs_f32(0.5)); /// ``` - fn elapsed(_self: Ref) -> Val<::core::time::Duration> { - let output: Val<::core::time::Duration> = bevy::time::prelude::Timer::elapsed( + fn elapsed(_self: Ref<::bevy_time::prelude::Timer>) -> Val<::core::time::Duration> { + let output: Val<::core::time::Duration> = ::bevy_time::prelude::Timer::elapsed( &_self, ) .into(); @@ -98,22 +102,22 @@ impl bevy::time::prelude::Timer { } /// Returns the time elapsed on the timer as an `f32`. /// See also [`Timer::elapsed`](Timer::elapsed). - fn elapsed_secs(_self: Ref) -> f32 { - let output: f32 = bevy::time::prelude::Timer::elapsed_secs(&_self).into(); + fn elapsed_secs(_self: Ref<::bevy_time::prelude::Timer>) -> f32 { + let output: f32 = ::bevy_time::prelude::Timer::elapsed_secs(&_self).into(); output } /// Returns the time elapsed on the timer as an `f64`. /// See also [`Timer::elapsed`](Timer::elapsed). - fn elapsed_secs_f64(_self: Ref) -> f64 { - let output: f64 = bevy::time::prelude::Timer::elapsed_secs_f64(&_self).into(); + fn elapsed_secs_f64(_self: Ref<::bevy_time::prelude::Timer>) -> f64 { + let output: f64 = ::bevy_time::prelude::Timer::elapsed_secs_f64(&_self).into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_time::prelude::Timer>, + other: Ref<::bevy_time::prelude::Timer>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -137,8 +141,8 @@ impl bevy::time::prelude::Timer { /// timer_repeating.tick(Duration::from_secs_f32(0.6)); /// assert!(timer_repeating.finished()); /// ``` - fn finished(_self: Ref) -> bool { - let output: bool = bevy::time::prelude::Timer::finished(&_self).into(); + fn finished(_self: Ref<::bevy_time::prelude::Timer>) -> bool { + let output: bool = ::bevy_time::prelude::Timer::finished(&_self).into(); output } /// Returns the fraction of the timer elapsed time (goes from 0.0 to 1.0). @@ -150,8 +154,8 @@ impl bevy::time::prelude::Timer { /// timer.tick(Duration::from_secs_f32(0.5)); /// assert_eq!(timer.fraction(), 0.25); /// ``` - fn fraction(_self: Ref) -> f32 { - let output: f32 = bevy::time::prelude::Timer::fraction(&_self).into(); + fn fraction(_self: Ref<::bevy_time::prelude::Timer>) -> f32 { + let output: f32 = ::bevy_time::prelude::Timer::fraction(&_self).into(); output } /// Returns the fraction of the timer remaining time (goes from 1.0 to 0.0). @@ -163,8 +167,8 @@ impl bevy::time::prelude::Timer { /// timer.tick(Duration::from_secs_f32(0.5)); /// assert_eq!(timer.fraction_remaining(), 0.75); /// ``` - fn fraction_remaining(_self: Ref) -> f32 { - let output: f32 = bevy::time::prelude::Timer::fraction_remaining(&_self).into(); + fn fraction_remaining(_self: Ref<::bevy_time::prelude::Timer>) -> f32 { + let output: f32 = ::bevy_time::prelude::Timer::fraction_remaining(&_self).into(); output } /// Creates a new timer with a given duration in seconds. @@ -175,9 +179,9 @@ impl bevy::time::prelude::Timer { /// ``` fn from_seconds( duration: f32, - mode: Val, - ) -> Val { - let output: Val = bevy::time::prelude::Timer::from_seconds( + mode: Val<::bevy_time::prelude::TimerMode>, + ) -> Val<::bevy_time::prelude::Timer> { + let output: Val<::bevy_time::prelude::Timer> = ::bevy_time::prelude::Timer::from_seconds( duration, mode.into_inner(), ) @@ -195,8 +199,8 @@ impl bevy::time::prelude::Timer { /// timer.tick(Duration::from_secs_f32(0.5)); /// assert!(!timer.just_finished()); /// ``` - fn just_finished(_self: Ref) -> bool { - let output: bool = bevy::time::prelude::Timer::just_finished(&_self).into(); + fn just_finished(_self: Ref<::bevy_time::prelude::Timer>) -> bool { + let output: bool = ::bevy_time::prelude::Timer::just_finished(&_self).into(); output } /// Returns the mode of the timer. @@ -207,9 +211,9 @@ impl bevy::time::prelude::Timer { /// assert_eq!(timer.mode(), TimerMode::Repeating); /// ``` fn mode( - _self: Ref, - ) -> Val { - let output: Val = bevy::time::prelude::Timer::mode( + _self: Ref<::bevy_time::prelude::Timer>, + ) -> Val<::bevy_time::prelude::TimerMode> { + let output: Val<::bevy_time::prelude::TimerMode> = ::bevy_time::prelude::Timer::mode( &_self, ) .into(); @@ -219,9 +223,9 @@ impl bevy::time::prelude::Timer { /// See also [`Timer::from_seconds`](Timer::from_seconds). fn new( duration: Val<::core::time::Duration>, - mode: Val, - ) -> Val { - let output: Val = bevy::time::prelude::Timer::new( + mode: Val<::bevy_time::prelude::TimerMode>, + ) -> Val<::bevy_time::prelude::Timer> { + let output: Val<::bevy_time::prelude::Timer> = ::bevy_time::prelude::Timer::new( duration.into_inner(), mode.into_inner(), ) @@ -239,8 +243,8 @@ impl bevy::time::prelude::Timer { /// timer.tick(Duration::from_secs_f32(0.5)); /// assert_eq!(timer.elapsed_secs(), 0.0); /// ``` - fn pause(mut _self: Mut) -> () { - let output: () = bevy::time::prelude::Timer::pause(&mut _self).into(); + fn pause(mut _self: Mut<::bevy_time::prelude::Timer>) -> () { + let output: () = ::bevy_time::prelude::Timer::pause(&mut _self).into(); output } /// Returns `true` if the timer is paused. @@ -255,8 +259,8 @@ impl bevy::time::prelude::Timer { /// timer.unpause(); /// assert!(!timer.paused()); /// ``` - fn paused(_self: Ref) -> bool { - let output: bool = bevy::time::prelude::Timer::paused(&_self).into(); + fn paused(_self: Ref<::bevy_time::prelude::Timer>) -> bool { + let output: bool = ::bevy_time::prelude::Timer::paused(&_self).into(); output } /// Returns the remaining time using Duration @@ -268,8 +272,10 @@ impl bevy::time::prelude::Timer { /// timer.tick(Duration::from_secs_f32(0.5)); /// assert_eq!(timer.remaining(), Duration::from_secs_f32(1.5)); /// ``` - fn remaining(_self: Ref) -> Val<::core::time::Duration> { - let output: Val<::core::time::Duration> = bevy::time::prelude::Timer::remaining( + fn remaining( + _self: Ref<::bevy_time::prelude::Timer>, + ) -> Val<::core::time::Duration> { + let output: Val<::core::time::Duration> = ::bevy_time::prelude::Timer::remaining( &_self, ) .into(); @@ -286,8 +292,8 @@ impl bevy::time::prelude::Timer { /// let result = timer.remaining_secs().total_cmp(&1.5); /// assert_eq!(Ordering::Equal, result); /// ``` - fn remaining_secs(_self: Ref) -> f32 { - let output: f32 = bevy::time::prelude::Timer::remaining_secs(&_self).into(); + fn remaining_secs(_self: Ref<::bevy_time::prelude::Timer>) -> f32 { + let output: f32 = ::bevy_time::prelude::Timer::remaining_secs(&_self).into(); output } /// Resets the timer. The reset doesn't affect the `paused` state of the timer. @@ -303,8 +309,8 @@ impl bevy::time::prelude::Timer { /// assert!(!timer.just_finished()); /// assert_eq!(timer.elapsed_secs(), 0.0); /// ``` - fn reset(mut _self: Mut) -> () { - let output: () = bevy::time::prelude::Timer::reset(&mut _self).into(); + fn reset(mut _self: Mut<::bevy_time::prelude::Timer>) -> () { + let output: () = ::bevy_time::prelude::Timer::reset(&mut _self).into(); output } /// Sets the duration of the timer. @@ -317,10 +323,10 @@ impl bevy::time::prelude::Timer { /// assert_eq!(timer.duration(), Duration::from_secs(1)); /// ``` fn set_duration( - mut _self: Mut, + mut _self: Mut<::bevy_time::prelude::Timer>, duration: Val<::core::time::Duration>, ) -> () { - let output: () = bevy::time::prelude::Timer::set_duration( + let output: () = ::bevy_time::prelude::Timer::set_duration( &mut _self, duration.into_inner(), ) @@ -340,10 +346,10 @@ impl bevy::time::prelude::Timer { /// assert!(!timer.finished()); /// ``` fn set_elapsed( - mut _self: Mut, + mut _self: Mut<::bevy_time::prelude::Timer>, time: Val<::core::time::Duration>, ) -> () { - let output: () = bevy::time::prelude::Timer::set_elapsed( + let output: () = ::bevy_time::prelude::Timer::set_elapsed( &mut _self, time.into_inner(), ) @@ -359,10 +365,10 @@ impl bevy::time::prelude::Timer { /// assert_eq!(timer.mode(), TimerMode::Once); /// ``` fn set_mode( - mut _self: Mut, - mode: Val, + mut _self: Mut<::bevy_time::prelude::Timer>, + mode: Val<::bevy_time::prelude::TimerMode>, ) -> () { - let output: () = bevy::time::prelude::Timer::set_mode( + let output: () = ::bevy_time::prelude::Timer::set_mode( &mut _self, mode.into_inner(), ) @@ -385,8 +391,8 @@ impl bevy::time::prelude::Timer { /// timer.tick(Duration::from_secs_f32(0.5)); /// assert_eq!(timer.times_finished_this_tick(), 0); /// ``` - fn times_finished_this_tick(_self: Ref) -> u32 { - let output: u32 = bevy::time::prelude::Timer::times_finished_this_tick(&_self) + fn times_finished_this_tick(_self: Ref<::bevy_time::prelude::Timer>) -> u32 { + let output: u32 = ::bevy_time::prelude::Timer::times_finished_this_tick(&_self) .into(); output } @@ -403,8 +409,8 @@ impl bevy::time::prelude::Timer { /// timer.tick(Duration::from_secs_f32(0.5)); /// assert_eq!(timer.elapsed_secs(), 0.5); /// ``` - fn unpause(mut _self: Mut) -> () { - let output: () = bevy::time::prelude::Timer::unpause(&mut _self).into(); + fn unpause(mut _self: Mut<::bevy_time::prelude::Timer>) -> () { + let output: () = ::bevy_time::prelude::Timer::unpause(&mut _self).into(); output } } @@ -414,29 +420,29 @@ impl bevy::time::prelude::Timer { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::time::prelude::TimerMode { - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( +impl ::bevy_time::prelude::TimerMode { + fn assert_receiver_is_total_eq(_self: Ref<::bevy_time::prelude::TimerMode>) -> () { + let output: () = <::bevy_time::prelude::TimerMode as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_time::prelude::TimerMode>, + ) -> Val<::bevy_time::prelude::TimerMode> { + let output: Val<::bevy_time::prelude::TimerMode> = <::bevy_time::prelude::TimerMode as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_time::prelude::TimerMode>, + other: Ref<::bevy_time::prelude::TimerMode>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output @@ -448,11 +454,11 @@ impl bevy::time::prelude::TimerMode { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::time::prelude::Virtual { +impl ::bevy_time::prelude::Virtual { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_time::prelude::Virtual>, + ) -> Val<::bevy_time::prelude::Virtual> { + let output: Val<::bevy_time::prelude::Virtual> = <::bevy_time::prelude::Virtual as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -465,16 +471,16 @@ impl bevy::time::prelude::Virtual { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::time::Stopwatch { - fn assert_receiver_is_total_eq(_self: Ref) -> () { - let output: () = ::assert_receiver_is_total_eq( +impl ::bevy_time::Stopwatch { + fn assert_receiver_is_total_eq(_self: Ref<::bevy_time::Stopwatch>) -> () { + let output: () = <::bevy_time::Stopwatch as ::core::cmp::Eq>::assert_receiver_is_total_eq( &_self, ) .into(); output } - fn clone(_self: Ref) -> Val { - let output: Val = ::clone( + fn clone(_self: Ref<::bevy_time::Stopwatch>) -> Val<::bevy_time::Stopwatch> { + let output: Val<::bevy_time::Stopwatch> = <::bevy_time::Stopwatch as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -493,8 +499,8 @@ impl bevy::time::Stopwatch { /// # See Also /// [`elapsed_secs`](Stopwatch::elapsed_secs) - if an `f32` value is desirable instead. /// [`elapsed_secs_f64`](Stopwatch::elapsed_secs_f64) - if an `f64` is desirable instead. - fn elapsed(_self: Ref) -> Val<::core::time::Duration> { - let output: Val<::core::time::Duration> = bevy::time::Stopwatch::elapsed(&_self) + fn elapsed(_self: Ref<::bevy_time::Stopwatch>) -> Val<::core::time::Duration> { + let output: Val<::core::time::Duration> = ::bevy_time::Stopwatch::elapsed(&_self) .into(); output } @@ -511,8 +517,8 @@ impl bevy::time::Stopwatch { /// # See Also /// [`elapsed`](Stopwatch::elapsed) - if a `Duration` is desirable instead. /// [`elapsed_secs_f64`](Stopwatch::elapsed_secs_f64) - if an `f64` is desirable instead. - fn elapsed_secs(_self: Ref) -> f32 { - let output: f32 = bevy::time::Stopwatch::elapsed_secs(&_self).into(); + fn elapsed_secs(_self: Ref<::bevy_time::Stopwatch>) -> f32 { + let output: f32 = ::bevy_time::Stopwatch::elapsed_secs(&_self).into(); output } /// Returns the elapsed time since the last [`reset`](Stopwatch::reset) @@ -520,13 +526,16 @@ impl bevy::time::Stopwatch { /// # See Also /// [`elapsed`](Stopwatch::elapsed) - if a `Duration` is desirable instead. /// [`elapsed_secs`](Stopwatch::elapsed_secs) - if an `f32` is desirable instead. - fn elapsed_secs_f64(_self: Ref) -> f64 { - let output: f64 = bevy::time::Stopwatch::elapsed_secs_f64(&_self).into(); + fn elapsed_secs_f64(_self: Ref<::bevy_time::Stopwatch>) -> f64 { + let output: f64 = ::bevy_time::Stopwatch::elapsed_secs_f64(&_self).into(); output } - fn eq(_self: Ref, other: Ref) -> bool { - let output: bool = , + other: Ref<::bevy_time::Stopwatch>, + ) -> bool { + let output: bool = <::bevy_time::Stopwatch as ::core::cmp::PartialEq< + ::bevy_time::Stopwatch, >>::eq(&_self, &other) .into(); output @@ -542,8 +551,8 @@ impl bevy::time::Stopwatch { /// stopwatch.unpause(); /// assert!(!stopwatch.is_paused()); /// ``` - fn is_paused(_self: Ref) -> bool { - let output: bool = bevy::time::Stopwatch::is_paused(&_self).into(); + fn is_paused(_self: Ref<::bevy_time::Stopwatch>) -> bool { + let output: bool = ::bevy_time::Stopwatch::is_paused(&_self).into(); output } /// Create a new unpaused `Stopwatch` with no elapsed time. @@ -554,8 +563,8 @@ impl bevy::time::Stopwatch { /// assert_eq!(stopwatch.elapsed_secs(), 0.0); /// assert_eq!(stopwatch.is_paused(), false); /// ``` - fn new() -> Val { - let output: Val = bevy::time::Stopwatch::new().into(); + fn new() -> Val<::bevy_time::Stopwatch> { + let output: Val<::bevy_time::Stopwatch> = ::bevy_time::Stopwatch::new().into(); output } /// Pauses the stopwatch. Any call to [`tick`](Stopwatch::tick) while @@ -570,8 +579,8 @@ impl bevy::time::Stopwatch { /// assert!(stopwatch.is_paused()); /// assert_eq!(stopwatch.elapsed_secs(), 0.0); /// ``` - fn pause(mut _self: Mut) -> () { - let output: () = bevy::time::Stopwatch::pause(&mut _self).into(); + fn pause(mut _self: Mut<::bevy_time::Stopwatch>) -> () { + let output: () = ::bevy_time::Stopwatch::pause(&mut _self).into(); output } /// Resets the stopwatch. The reset doesn't affect the paused state of the stopwatch. @@ -584,8 +593,8 @@ impl bevy::time::Stopwatch { /// stopwatch.reset(); /// assert_eq!(stopwatch.elapsed_secs(), 0.0); /// ``` - fn reset(mut _self: Mut) -> () { - let output: () = bevy::time::Stopwatch::reset(&mut _self).into(); + fn reset(mut _self: Mut<::bevy_time::Stopwatch>) -> () { + let output: () = ::bevy_time::Stopwatch::reset(&mut _self).into(); output } /// Sets the elapsed time of the stopwatch. @@ -598,10 +607,10 @@ impl bevy::time::Stopwatch { /// assert_eq!(stopwatch.elapsed_secs(), 1.0); /// ``` fn set_elapsed( - mut _self: Mut, + mut _self: Mut<::bevy_time::Stopwatch>, time: Val<::core::time::Duration>, ) -> () { - let output: () = bevy::time::Stopwatch::set_elapsed( + let output: () = ::bevy_time::Stopwatch::set_elapsed( &mut _self, time.into_inner(), ) @@ -621,8 +630,8 @@ impl bevy::time::Stopwatch { /// assert!(!stopwatch.is_paused()); /// assert_eq!(stopwatch.elapsed_secs(), 1.0); /// ``` - fn unpause(mut _self: Mut) -> () { - let output: () = bevy::time::Stopwatch::unpause(&mut _self).into(); + fn unpause(mut _self: Mut<::bevy_time::Stopwatch>) -> () { + let output: () = ::bevy_time::Stopwatch::unpause(&mut _self).into(); output } } diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_transform.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_transform.rs index f52d646031..f927db1014 100644 --- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_transform.rs +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_transform.rs @@ -18,12 +18,12 @@ pub struct BevyTransformScriptingPlugin; bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::transform::components::GlobalTransform { +impl ::bevy_transform::components::GlobalTransform { /// Returns the 3d affine transformation matrix as an [`Affine3A`]. fn affine( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::GlobalTransform::affine( + _self: Ref<::bevy_transform::components::GlobalTransform>, + ) -> Val<::bevy_math::Affine3A> { + let output: Val<::bevy_math::Affine3A> = ::bevy_transform::components::GlobalTransform::affine( &_self, ) .into(); @@ -31,18 +31,18 @@ impl bevy::transform::components::GlobalTransform { } /// Return the local back vector (Z). fn back( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::GlobalTransform::back( + _self: Ref<::bevy_transform::components::GlobalTransform>, + ) -> Val<::bevy_math::Dir3> { + let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::GlobalTransform::back( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_transform::components::GlobalTransform>, + ) -> Val<::bevy_transform::components::GlobalTransform> { + let output: Val<::bevy_transform::components::GlobalTransform> = <::bevy_transform::components::GlobalTransform as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -50,9 +50,9 @@ impl bevy::transform::components::GlobalTransform { } /// Returns the 3d affine transformation matrix as a [`Mat4`]. fn compute_matrix( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::GlobalTransform::compute_matrix( + _self: Ref<::bevy_transform::components::GlobalTransform>, + ) -> Val<::bevy_math::Mat4> { + let output: Val<::bevy_math::Mat4> = ::bevy_transform::components::GlobalTransform::compute_matrix( &_self, ) .into(); @@ -62,9 +62,9 @@ impl bevy::transform::components::GlobalTransform { /// The transform is expected to be non-degenerate and without shearing, or the output /// will be invalid. fn compute_transform( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::GlobalTransform::compute_transform( + _self: Ref<::bevy_transform::components::GlobalTransform>, + ) -> Val<::bevy_transform::components::Transform> { + let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::GlobalTransform::compute_transform( &_self, ) .into(); @@ -72,65 +72,65 @@ impl bevy::transform::components::GlobalTransform { } /// Return the local down vector (-Y). fn down( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::GlobalTransform::down( + _self: Ref<::bevy_transform::components::GlobalTransform>, + ) -> Val<::bevy_math::Dir3> { + let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::GlobalTransform::down( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_transform::components::GlobalTransform>, + other: Ref<::bevy_transform::components::GlobalTransform>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Return the local forward vector (-Z). fn forward( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::GlobalTransform::forward( + _self: Ref<::bevy_transform::components::GlobalTransform>, + ) -> Val<::bevy_math::Dir3> { + let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::GlobalTransform::forward( &_self, ) .into(); output } fn from_isometry( - iso: Val, - ) -> Val { - let output: Val = bevy::transform::components::GlobalTransform::from_isometry( + iso: Val<::bevy_math::Isometry3d>, + ) -> Val<::bevy_transform::components::GlobalTransform> { + let output: Val<::bevy_transform::components::GlobalTransform> = ::bevy_transform::components::GlobalTransform::from_isometry( iso.into_inner(), ) .into(); output } fn from_rotation( - rotation: Val, - ) -> Val { - let output: Val = bevy::transform::components::GlobalTransform::from_rotation( + rotation: Val<::bevy_math::Quat>, + ) -> Val<::bevy_transform::components::GlobalTransform> { + let output: Val<::bevy_transform::components::GlobalTransform> = ::bevy_transform::components::GlobalTransform::from_rotation( rotation.into_inner(), ) .into(); output } fn from_scale( - scale: Val, - ) -> Val { - let output: Val = bevy::transform::components::GlobalTransform::from_scale( + scale: Val<::bevy_math::Vec3>, + ) -> Val<::bevy_transform::components::GlobalTransform> { + let output: Val<::bevy_transform::components::GlobalTransform> = ::bevy_transform::components::GlobalTransform::from_scale( scale.into_inner(), ) .into(); output } fn from_translation( - translation: Val, - ) -> Val { - let output: Val = bevy::transform::components::GlobalTransform::from_translation( + translation: Val<::bevy_math::Vec3>, + ) -> Val<::bevy_transform::components::GlobalTransform> { + let output: Val<::bevy_transform::components::GlobalTransform> = ::bevy_transform::components::GlobalTransform::from_translation( translation.into_inner(), ) .into(); @@ -140,8 +140,8 @@ impl bevy::transform::components::GlobalTransform { x: f32, y: f32, z: f32, - ) -> Val { - let output: Val = bevy::transform::components::GlobalTransform::from_xyz( + ) -> Val<::bevy_transform::components::GlobalTransform> { + let output: Val<::bevy_transform::components::GlobalTransform> = ::bevy_transform::components::GlobalTransform::from_xyz( x, y, z, @@ -151,40 +151,40 @@ impl bevy::transform::components::GlobalTransform { } /// Return the local left vector (-X). fn left( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::GlobalTransform::left( + _self: Ref<::bevy_transform::components::GlobalTransform>, + ) -> Val<::bevy_math::Dir3> { + let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::GlobalTransform::left( &_self, ) .into(); output } fn mul( - _self: Val, - value: Val, - ) -> Val { - let output: Val = , + value: Val<::bevy_math::Vec3>, + ) -> Val<::bevy_math::Vec3> { + let output: Val<::bevy_math::Vec3> = <::bevy_transform::components::GlobalTransform as ::core::ops::Mul< + ::bevy_math::Vec3, >>::mul(_self.into_inner(), value.into_inner()) .into(); output } fn mul( - _self: Val, - global_transform: Val, - ) -> Val { - let output: Val = , + global_transform: Val<::bevy_transform::components::GlobalTransform>, + ) -> Val<::bevy_transform::components::GlobalTransform> { + let output: Val<::bevy_transform::components::GlobalTransform> = <::bevy_transform::components::GlobalTransform as ::core::ops::Mul< + ::bevy_transform::components::GlobalTransform, >>::mul(_self.into_inner(), global_transform.into_inner()) .into(); output } fn mul( - _self: Val, - transform: Val, - ) -> Val { - let output: Val = , + transform: Val<::bevy_transform::components::Transform>, + ) -> Val<::bevy_transform::components::GlobalTransform> { + let output: Val<::bevy_transform::components::GlobalTransform> = <::bevy_transform::components::GlobalTransform as ::core::ops::Mul< + ::bevy_transform::components::Transform, >>::mul(_self.into_inner(), transform.into_inner()) .into(); output @@ -192,10 +192,10 @@ impl bevy::transform::components::GlobalTransform { /// Multiplies `self` with `transform` component by component, returning the /// resulting [`GlobalTransform`] fn mul_transform( - _self: Ref, - transform: Val, - ) -> Val { - let output: Val = bevy::transform::components::GlobalTransform::mul_transform( + _self: Ref<::bevy_transform::components::GlobalTransform>, + transform: Val<::bevy_transform::components::Transform>, + ) -> Val<::bevy_transform::components::GlobalTransform> { + let output: Val<::bevy_transform::components::GlobalTransform> = ::bevy_transform::components::GlobalTransform::mul_transform( &_self, transform.into_inner(), ) @@ -204,10 +204,10 @@ impl bevy::transform::components::GlobalTransform { } /// Get an upper bound of the radius from the given `extents`. fn radius_vec3a( - _self: Ref, - extents: Val, + _self: Ref<::bevy_transform::components::GlobalTransform>, + extents: Val<::bevy_math::Vec3A>, ) -> f32 { - let output: f32 = bevy::transform::components::GlobalTransform::radius_vec3a( + let output: f32 = ::bevy_transform::components::GlobalTransform::radius_vec3a( &_self, extents.into_inner(), ) @@ -244,10 +244,10 @@ impl bevy::transform::components::GlobalTransform { /// The transform is expected to be non-degenerate and without shearing, or the output /// will be invalid. fn reparented_to( - _self: Ref, - parent: Ref, - ) -> Val { - let output: Val = bevy::transform::components::GlobalTransform::reparented_to( + _self: Ref<::bevy_transform::components::GlobalTransform>, + parent: Ref<::bevy_transform::components::GlobalTransform>, + ) -> Val<::bevy_transform::components::Transform> { + let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::GlobalTransform::reparented_to( &_self, &parent, ) @@ -256,9 +256,9 @@ impl bevy::transform::components::GlobalTransform { } /// Return the local right vector (X). fn right( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::GlobalTransform::right( + _self: Ref<::bevy_transform::components::GlobalTransform>, + ) -> Val<::bevy_math::Dir3> { + let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::GlobalTransform::right( &_self, ) .into(); @@ -270,9 +270,9 @@ impl bevy::transform::components::GlobalTransform { /// This is calculated using `to_scale_rotation_translation`, meaning that you /// should probably use it directly if you also need translation or scale. fn rotation( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::GlobalTransform::rotation( + _self: Ref<::bevy_transform::components::GlobalTransform>, + ) -> Val<::bevy_math::Quat> { + let output: Val<::bevy_math::Quat> = ::bevy_transform::components::GlobalTransform::rotation( &_self, ) .into(); @@ -283,9 +283,9 @@ impl bevy::transform::components::GlobalTransform { /// Some of the computations overlap with `to_scale_rotation_translation`, which means you should use /// it instead if you also need rotation. fn scale( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::GlobalTransform::scale( + _self: Ref<::bevy_transform::components::GlobalTransform>, + ) -> Val<::bevy_math::Vec3> { + let output: Val<::bevy_math::Vec3> = ::bevy_transform::components::GlobalTransform::scale( &_self, ) .into(); @@ -297,9 +297,9 @@ impl bevy::transform::components::GlobalTransform { /// will be invalid. /// [isometry]: Isometry3d fn to_isometry( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::GlobalTransform::to_isometry( + _self: Ref<::bevy_transform::components::GlobalTransform>, + ) -> Val<::bevy_math::Isometry3d> { + let output: Val<::bevy_math::Isometry3d> = ::bevy_transform::components::GlobalTransform::to_isometry( &_self, ) .into(); @@ -335,10 +335,10 @@ impl bevy::transform::components::GlobalTransform { /// assert_eq!(roundtripped_local_direction, local_direction); /// ``` fn transform_point( - _self: Ref, - point: Val, - ) -> Val { - let output: Val = bevy::transform::components::GlobalTransform::transform_point( + _self: Ref<::bevy_transform::components::GlobalTransform>, + point: Val<::bevy_math::Vec3>, + ) -> Val<::bevy_math::Vec3> { + let output: Val<::bevy_math::Vec3> = ::bevy_transform::components::GlobalTransform::transform_point( &_self, point.into_inner(), ) @@ -347,9 +347,9 @@ impl bevy::transform::components::GlobalTransform { } /// Get the translation as a [`Vec3`]. fn translation( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::GlobalTransform::translation( + _self: Ref<::bevy_transform::components::GlobalTransform>, + ) -> Val<::bevy_math::Vec3> { + let output: Val<::bevy_math::Vec3> = ::bevy_transform::components::GlobalTransform::translation( &_self, ) .into(); @@ -357,9 +357,9 @@ impl bevy::transform::components::GlobalTransform { } /// Get the translation as a [`Vec3A`]. fn translation_vec3a( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::GlobalTransform::translation_vec3a( + _self: Ref<::bevy_transform::components::GlobalTransform>, + ) -> Val<::bevy_math::Vec3A> { + let output: Val<::bevy_math::Vec3A> = ::bevy_transform::components::GlobalTransform::translation_vec3a( &_self, ) .into(); @@ -367,9 +367,9 @@ impl bevy::transform::components::GlobalTransform { } /// Return the local up vector (Y). fn up( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::GlobalTransform::up( + _self: Ref<::bevy_transform::components::GlobalTransform>, + ) -> Val<::bevy_math::Dir3> { + let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::GlobalTransform::up( &_self, ) .into(); @@ -382,21 +382,21 @@ impl bevy::transform::components::GlobalTransform { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::transform::components::Transform { +impl ::bevy_transform::components::Transform { /// Equivalent to [`local_z()`][Transform::local_z] fn back( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::Transform::back( + _self: Ref<::bevy_transform::components::Transform>, + ) -> Val<::bevy_math::Dir3> { + let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::Transform::back( &_self, ) .into(); output } fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_transform::components::Transform>, + ) -> Val<::bevy_transform::components::Transform> { + let output: Val<::bevy_transform::components::Transform> = <::bevy_transform::components::Transform as ::core::clone::Clone>::clone( &_self, ) .into(); @@ -405,9 +405,9 @@ impl bevy::transform::components::Transform { /// Returns the 3d affine transformation matrix from this transforms translation, /// rotation, and scale. fn compute_affine( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::Transform::compute_affine( + _self: Ref<::bevy_transform::components::Transform>, + ) -> Val<::bevy_math::Affine3A> { + let output: Val<::bevy_math::Affine3A> = ::bevy_transform::components::Transform::compute_affine( &_self, ) .into(); @@ -416,9 +416,9 @@ impl bevy::transform::components::Transform { /// Returns the 3d affine transformation matrix from this transforms translation, /// rotation, and scale. fn compute_matrix( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::Transform::compute_matrix( + _self: Ref<::bevy_transform::components::Transform>, + ) -> Val<::bevy_math::Mat4> { + let output: Val<::bevy_math::Mat4> = ::bevy_transform::components::Transform::compute_matrix( &_self, ) .into(); @@ -426,29 +426,29 @@ impl bevy::transform::components::Transform { } /// Equivalent to [`-local_y()`][Transform::local_y] fn down( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::Transform::down( + _self: Ref<::bevy_transform::components::Transform>, + ) -> Val<::bevy_math::Dir3> { + let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::Transform::down( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_transform::components::Transform>, + other: Ref<::bevy_transform::components::Transform>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output } /// Equivalent to [`-local_z()`][Transform::local_z] fn forward( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::Transform::forward( + _self: Ref<::bevy_transform::components::Transform>, + ) -> Val<::bevy_math::Dir3> { + let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::Transform::forward( &_self, ) .into(); @@ -457,9 +457,9 @@ impl bevy::transform::components::Transform { /// Creates a new [`Transform`] that is equivalent to the given [isometry]. /// [isometry]: Isometry3d fn from_isometry( - iso: Val, - ) -> Val { - let output: Val = bevy::transform::components::Transform::from_isometry( + iso: Val<::bevy_math::Isometry3d>, + ) -> Val<::bevy_transform::components::Transform> { + let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::from_isometry( iso.into_inner(), ) .into(); @@ -468,9 +468,9 @@ impl bevy::transform::components::Transform { /// Extracts the translation, rotation, and scale from `matrix`. It must be a 3d affine /// transformation matrix. fn from_matrix( - world_from_local: Val, - ) -> Val { - let output: Val = bevy::transform::components::Transform::from_matrix( + world_from_local: Val<::bevy_math::Mat4>, + ) -> Val<::bevy_transform::components::Transform> { + let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::from_matrix( world_from_local.into_inner(), ) .into(); @@ -479,9 +479,9 @@ impl bevy::transform::components::Transform { /// Creates a new [`Transform`], with `rotation`. Translation will be 0 and scale 1 on /// all axes. fn from_rotation( - rotation: Val, - ) -> Val { - let output: Val = bevy::transform::components::Transform::from_rotation( + rotation: Val<::bevy_math::Quat>, + ) -> Val<::bevy_transform::components::Transform> { + let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::from_rotation( rotation.into_inner(), ) .into(); @@ -490,9 +490,9 @@ impl bevy::transform::components::Transform { /// Creates a new [`Transform`], with `scale`. Translation will be 0 and rotation 0 on /// all axes. fn from_scale( - scale: Val, - ) -> Val { - let output: Val = bevy::transform::components::Transform::from_scale( + scale: Val<::bevy_math::Vec3>, + ) -> Val<::bevy_transform::components::Transform> { + let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::from_scale( scale.into_inner(), ) .into(); @@ -501,9 +501,9 @@ impl bevy::transform::components::Transform { /// Creates a new [`Transform`], with `translation`. Rotation will be 0 and scale 1 on /// all axes. fn from_translation( - translation: Val, - ) -> Val { - let output: Val = bevy::transform::components::Transform::from_translation( + translation: Val<::bevy_math::Vec3>, + ) -> Val<::bevy_transform::components::Transform> { + let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::from_translation( translation.into_inner(), ) .into(); @@ -512,8 +512,8 @@ impl bevy::transform::components::Transform { /// Creates a new [`Transform`] at the position `(x, y, z)`. In 2d, the `z` component /// is used for z-ordering elements: higher `z`-value will be in front of lower /// `z`-value. - fn from_xyz(x: f32, y: f32, z: f32) -> Val { - let output: Val = bevy::transform::components::Transform::from_xyz( + fn from_xyz(x: f32, y: f32, z: f32) -> Val<::bevy_transform::components::Transform> { + let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::from_xyz( x, y, z, @@ -524,16 +524,16 @@ impl bevy::transform::components::Transform { /// Returns `true` if, and only if, translation, rotation and scale all are /// finite. If any of them contains a `NaN`, positive or negative infinity, /// this will return `false`. - fn is_finite(_self: Ref) -> bool { - let output: bool = bevy::transform::components::Transform::is_finite(&_self) + fn is_finite(_self: Ref<::bevy_transform::components::Transform>) -> bool { + let output: bool = ::bevy_transform::components::Transform::is_finite(&_self) .into(); output } /// Equivalent to [`-local_x()`][Transform::local_x()] fn left( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::Transform::left( + _self: Ref<::bevy_transform::components::Transform>, + ) -> Val<::bevy_math::Dir3> { + let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::Transform::left( &_self, ) .into(); @@ -541,9 +541,9 @@ impl bevy::transform::components::Transform { } /// Get the unit vector in the local `X` direction. fn local_x( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::Transform::local_x( + _self: Ref<::bevy_transform::components::Transform>, + ) -> Val<::bevy_math::Dir3> { + let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::Transform::local_x( &_self, ) .into(); @@ -551,9 +551,9 @@ impl bevy::transform::components::Transform { } /// Get the unit vector in the local `Y` direction. fn local_y( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::Transform::local_y( + _self: Ref<::bevy_transform::components::Transform>, + ) -> Val<::bevy_math::Dir3> { + let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::Transform::local_y( &_self, ) .into(); @@ -561,40 +561,40 @@ impl bevy::transform::components::Transform { } /// Get the unit vector in the local `Z` direction. fn local_z( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::Transform::local_z( + _self: Ref<::bevy_transform::components::Transform>, + ) -> Val<::bevy_math::Dir3> { + let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::Transform::local_z( &_self, ) .into(); output } fn mul( - _self: Val, - value: Val, - ) -> Val { - let output: Val = , + value: Val<::bevy_math::Vec3>, + ) -> Val<::bevy_math::Vec3> { + let output: Val<::bevy_math::Vec3> = <::bevy_transform::components::Transform as ::core::ops::Mul< + ::bevy_math::Vec3, >>::mul(_self.into_inner(), value.into_inner()) .into(); output } fn mul( - _self: Val, - global_transform: Val, - ) -> Val { - let output: Val = , + global_transform: Val<::bevy_transform::components::GlobalTransform>, + ) -> Val<::bevy_transform::components::GlobalTransform> { + let output: Val<::bevy_transform::components::GlobalTransform> = <::bevy_transform::components::Transform as ::core::ops::Mul< + ::bevy_transform::components::GlobalTransform, >>::mul(_self.into_inner(), global_transform.into_inner()) .into(); output } fn mul( - _self: Val, - transform: Val, - ) -> Val { - let output: Val = , + transform: Val<::bevy_transform::components::Transform>, + ) -> Val<::bevy_transform::components::Transform> { + let output: Val<::bevy_transform::components::Transform> = <::bevy_transform::components::Transform as ::core::ops::Mul< + ::bevy_transform::components::Transform, >>::mul(_self.into_inner(), transform.into_inner()) .into(); output @@ -602,10 +602,10 @@ impl bevy::transform::components::Transform { /// Multiplies `self` with `transform` component by component, returning the /// resulting [`Transform`] fn mul_transform( - _self: Ref, - transform: Val, - ) -> Val { - let output: Val = bevy::transform::components::Transform::mul_transform( + _self: Ref<::bevy_transform::components::Transform>, + transform: Val<::bevy_transform::components::Transform>, + ) -> Val<::bevy_transform::components::Transform> { + let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::mul_transform( &_self, transform.into_inner(), ) @@ -614,9 +614,9 @@ impl bevy::transform::components::Transform { } /// Equivalent to [`local_x()`][Transform::local_x()] fn right( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::Transform::right( + _self: Ref<::bevy_transform::components::Transform>, + ) -> Val<::bevy_math::Dir3> { + let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::Transform::right( &_self, ) .into(); @@ -628,10 +628,10 @@ impl bevy::transform::components::Transform { /// - [`3d_rotation`] /// [`3d_rotation`]: https://github.com/bevyengine/bevy/blob/latest/examples/transforms/3d_rotation.rs fn rotate( - mut _self: Mut, - rotation: Val, + mut _self: Mut<::bevy_transform::components::Transform>, + rotation: Val<::bevy_math::Quat>, ) -> () { - let output: () = bevy::transform::components::Transform::rotate( + let output: () = ::bevy_transform::components::Transform::rotate( &mut _self, rotation.into_inner(), ) @@ -641,11 +641,11 @@ impl bevy::transform::components::Transform { /// Rotates this [`Transform`] around a `point` in space. /// If this [`Transform`] has a parent, the `point` is relative to the [`Transform`] of the parent. fn rotate_around( - mut _self: Mut, - point: Val, - rotation: Val, + mut _self: Mut<::bevy_transform::components::Transform>, + point: Val<::bevy_math::Vec3>, + rotation: Val<::bevy_math::Quat>, ) -> () { - let output: () = bevy::transform::components::Transform::rotate_around( + let output: () = ::bevy_transform::components::Transform::rotate_around( &mut _self, point.into_inner(), rotation.into_inner(), @@ -661,11 +661,11 @@ impl bevy::transform::components::Transform { /// result in a denormalized rotation. In this case, it is recommended to normalize the [`Transform::rotation`] after /// each call to this method. fn rotate_axis( - mut _self: Mut, - axis: Val, + mut _self: Mut<::bevy_transform::components::Transform>, + axis: Val<::bevy_math::Dir3>, angle: f32, ) -> () { - let output: () = bevy::transform::components::Transform::rotate_axis( + let output: () = ::bevy_transform::components::Transform::rotate_axis( &mut _self, axis.into_inner(), angle, @@ -676,10 +676,10 @@ impl bevy::transform::components::Transform { /// Rotates this [`Transform`] by the given `rotation`. /// The `rotation` is relative to this [`Transform`]'s current rotation. fn rotate_local( - mut _self: Mut, - rotation: Val, + mut _self: Mut<::bevy_transform::components::Transform>, + rotation: Val<::bevy_math::Quat>, ) -> () { - let output: () = bevy::transform::components::Transform::rotate_local( + let output: () = ::bevy_transform::components::Transform::rotate_local( &mut _self, rotation.into_inner(), ) @@ -693,11 +693,11 @@ impl bevy::transform::components::Transform { /// result in a denormalized rotation. In this case, it is recommended to normalize the [`Transform::rotation`] after /// each call to this method. fn rotate_local_axis( - mut _self: Mut, - axis: Val, + mut _self: Mut<::bevy_transform::components::Transform>, + axis: Val<::bevy_math::Dir3>, angle: f32, ) -> () { - let output: () = bevy::transform::components::Transform::rotate_local_axis( + let output: () = ::bevy_transform::components::Transform::rotate_local_axis( &mut _self, axis.into_inner(), angle, @@ -707,10 +707,10 @@ impl bevy::transform::components::Transform { } /// Rotates this [`Transform`] around its local `X` axis by `angle` (in radians). fn rotate_local_x( - mut _self: Mut, + mut _self: Mut<::bevy_transform::components::Transform>, angle: f32, ) -> () { - let output: () = bevy::transform::components::Transform::rotate_local_x( + let output: () = ::bevy_transform::components::Transform::rotate_local_x( &mut _self, angle, ) @@ -719,10 +719,10 @@ impl bevy::transform::components::Transform { } /// Rotates this [`Transform`] around its local `Y` axis by `angle` (in radians). fn rotate_local_y( - mut _self: Mut, + mut _self: Mut<::bevy_transform::components::Transform>, angle: f32, ) -> () { - let output: () = bevy::transform::components::Transform::rotate_local_y( + let output: () = ::bevy_transform::components::Transform::rotate_local_y( &mut _self, angle, ) @@ -731,10 +731,10 @@ impl bevy::transform::components::Transform { } /// Rotates this [`Transform`] around its local `Z` axis by `angle` (in radians). fn rotate_local_z( - mut _self: Mut, + mut _self: Mut<::bevy_transform::components::Transform>, angle: f32, ) -> () { - let output: () = bevy::transform::components::Transform::rotate_local_z( + let output: () = ::bevy_transform::components::Transform::rotate_local_z( &mut _self, angle, ) @@ -744,10 +744,10 @@ impl bevy::transform::components::Transform { /// Rotates this [`Transform`] around the `X` axis by `angle` (in radians). /// If this [`Transform`] has a parent, the axis is relative to the rotation of the parent. fn rotate_x( - mut _self: Mut, + mut _self: Mut<::bevy_transform::components::Transform>, angle: f32, ) -> () { - let output: () = bevy::transform::components::Transform::rotate_x( + let output: () = ::bevy_transform::components::Transform::rotate_x( &mut _self, angle, ) @@ -757,10 +757,10 @@ impl bevy::transform::components::Transform { /// Rotates this [`Transform`] around the `Y` axis by `angle` (in radians). /// If this [`Transform`] has a parent, the axis is relative to the rotation of the parent. fn rotate_y( - mut _self: Mut, + mut _self: Mut<::bevy_transform::components::Transform>, angle: f32, ) -> () { - let output: () = bevy::transform::components::Transform::rotate_y( + let output: () = ::bevy_transform::components::Transform::rotate_y( &mut _self, angle, ) @@ -770,10 +770,10 @@ impl bevy::transform::components::Transform { /// Rotates this [`Transform`] around the `Z` axis by `angle` (in radians). /// If this [`Transform`] has a parent, the axis is relative to the rotation of the parent. fn rotate_z( - mut _self: Mut, + mut _self: Mut<::bevy_transform::components::Transform>, angle: f32, ) -> () { - let output: () = bevy::transform::components::Transform::rotate_z( + let output: () = ::bevy_transform::components::Transform::rotate_z( &mut _self, angle, ) @@ -783,9 +783,9 @@ impl bevy::transform::components::Transform { /// Get the [isometry] defined by this transform's rotation and translation, ignoring scale. /// [isometry]: Isometry3d fn to_isometry( - _self: Ref, - ) -> Val { - let output: Val = bevy::transform::components::Transform::to_isometry( + _self: Ref<::bevy_transform::components::Transform>, + ) -> Val<::bevy_math::Isometry3d> { + let output: Val<::bevy_math::Isometry3d> = ::bevy_transform::components::Transform::to_isometry( &_self, ) .into(); @@ -800,10 +800,10 @@ impl bevy::transform::components::Transform { /// If you always want to transform a point in local space to worldspace, or if you need /// the inverse transformations, see [`GlobalTransform::transform_point()`]. fn transform_point( - _self: Ref, - point: Val, - ) -> Val { - let output: Val = bevy::transform::components::Transform::transform_point( + _self: Ref<::bevy_transform::components::Transform>, + point: Val<::bevy_math::Vec3>, + ) -> Val<::bevy_math::Vec3> { + let output: Val<::bevy_math::Vec3> = ::bevy_transform::components::Transform::transform_point( &_self, point.into_inner(), ) @@ -813,11 +813,11 @@ impl bevy::transform::components::Transform { /// Translates this [`Transform`] around a `point` in space. /// If this [`Transform`] has a parent, the `point` is relative to the [`Transform`] of the parent. fn translate_around( - mut _self: Mut, - point: Val, - rotation: Val, + mut _self: Mut<::bevy_transform::components::Transform>, + point: Val<::bevy_math::Vec3>, + rotation: Val<::bevy_math::Quat>, ) -> () { - let output: () = bevy::transform::components::Transform::translate_around( + let output: () = ::bevy_transform::components::Transform::translate_around( &mut _self, point.into_inner(), rotation.into_inner(), @@ -826,8 +826,10 @@ impl bevy::transform::components::Transform { output } /// Equivalent to [`local_y()`][Transform::local_y] - fn up(_self: Ref) -> Val { - let output: Val = bevy::transform::components::Transform::up( + fn up( + _self: Ref<::bevy_transform::components::Transform>, + ) -> Val<::bevy_math::Dir3> { + let output: Val<::bevy_math::Dir3> = ::bevy_transform::components::Transform::up( &_self, ) .into(); @@ -835,10 +837,10 @@ impl bevy::transform::components::Transform { } /// Returns this [`Transform`] with a new rotation. fn with_rotation( - _self: Val, - rotation: Val, - ) -> Val { - let output: Val = bevy::transform::components::Transform::with_rotation( + _self: Val<::bevy_transform::components::Transform>, + rotation: Val<::bevy_math::Quat>, + ) -> Val<::bevy_transform::components::Transform> { + let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::with_rotation( _self.into_inner(), rotation.into_inner(), ) @@ -847,10 +849,10 @@ impl bevy::transform::components::Transform { } /// Returns this [`Transform`] with a new scale. fn with_scale( - _self: Val, - scale: Val, - ) -> Val { - let output: Val = bevy::transform::components::Transform::with_scale( + _self: Val<::bevy_transform::components::Transform>, + scale: Val<::bevy_math::Vec3>, + ) -> Val<::bevy_transform::components::Transform> { + let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::with_scale( _self.into_inner(), scale.into_inner(), ) @@ -859,10 +861,10 @@ impl bevy::transform::components::Transform { } /// Returns this [`Transform`] with a new translation. fn with_translation( - _self: Val, - translation: Val, - ) -> Val { - let output: Val = bevy::transform::components::Transform::with_translation( + _self: Val<::bevy_transform::components::Transform>, + translation: Val<::bevy_math::Vec3>, + ) -> Val<::bevy_transform::components::Transform> { + let output: Val<::bevy_transform::components::Transform> = ::bevy_transform::components::Transform::with_translation( _self.into_inner(), translation.into_inner(), ) @@ -876,22 +878,22 @@ impl bevy::transform::components::Transform { bms_core_path = "bevy_mod_scripting_core", generated )] -impl bevy::transform::components::TransformTreeChanged { +impl ::bevy_transform::components::TransformTreeChanged { fn clone( - _self: Ref, - ) -> Val { - let output: Val = ::clone( + _self: Ref<::bevy_transform::components::TransformTreeChanged>, + ) -> Val<::bevy_transform::components::TransformTreeChanged> { + let output: Val<::bevy_transform::components::TransformTreeChanged> = <::bevy_transform::components::TransformTreeChanged as ::core::clone::Clone>::clone( &_self, ) .into(); output } fn eq( - _self: Ref, - other: Ref, + _self: Ref<::bevy_transform::components::TransformTreeChanged>, + other: Ref<::bevy_transform::components::TransformTreeChanged>, ) -> bool { - let output: bool = >::eq(&_self, &other) .into(); output diff --git a/crates/bevy_system_reflection/Cargo.toml b/crates/bevy_system_reflection/Cargo.toml index 36e24dc1aa..2899c6d6ab 100644 --- a/crates/bevy_system_reflection/Cargo.toml +++ b/crates/bevy_system_reflection/Cargo.toml @@ -12,12 +12,17 @@ categories = ["game-development"] readme = "readme.md" [dependencies] -bevy = { workspace = true, default-features = false, features = ["bevy_log"]} -dot-writer = "0.1.4" +bevy_ecs = { workspace = true, default-features = false, features = [] } +bevy_reflect = { workspace = true, default-features = false, features = [] } +bevy_platform = { workspace = true, default-features = false, features = [] } +bevy_log = { workspace = true, default-features = false, features = [] } +dot-writer = { workspace = true } [dev-dependencies] -pretty_assertions = "1.4" -manifest-dir-macros = "0.1.18" +bevy_app = { workspace = true, default-features = false, features = [] } +pretty_assertions = { workspace = true } +manifest-dir-macros = { workspace = true } + [lints] workspace = true diff --git a/crates/bevy_system_reflection/src/lib.rs b/crates/bevy_system_reflection/src/lib.rs index 6184321178..932a22a672 100644 --- a/crates/bevy_system_reflection/src/lib.rs +++ b/crates/bevy_system_reflection/src/lib.rs @@ -1,16 +1,17 @@ //! A visualiser for bevy system schedules, as well as utilities for querying them via reflection use std::{any::TypeId, borrow::Cow, ops::Deref}; -use bevy::{ - ecs::{ +use ::{ + bevy_ecs::{ schedule::{ InternedScheduleLabel, InternedSystemSet, NodeId, Schedule, ScheduleLabel, SystemSet, }, system::{System, SystemInput}, }, - platform::collections::{HashMap, HashSet}, - reflect::Reflect, + bevy_platform::collections::{HashMap, HashSet}, + bevy_reflect::Reflect, }; +use bevy_log::warn; use dot_writer::{Attributes, DotWriter}; #[derive(Reflect, Debug, Clone)] @@ -281,7 +282,7 @@ pub fn schedule_to_reflect_graph(schedule: &Schedule) -> ReflectSystemGraph { continue; } - bevy::log::warn!("Found uncovered node {node_id:?}"); + warn!("Found uncovered node {node_id:?}"); } let dependencies = dependency @@ -469,7 +470,10 @@ pub struct Edge { #[cfg(test)] mod test { - use bevy::{app::Update, ecs::world::World, prelude::IntoScheduleConfigs}; + use ::{ + bevy_app::Update, + bevy_ecs::{schedule::IntoScheduleConfigs, world::World}, + }; use super::*; diff --git a/crates/lad_backends/mdbook_lad_preprocessor/Cargo.toml b/crates/lad_backends/mdbook_lad_preprocessor/Cargo.toml index 9b6c1c1594..93264441e9 100644 --- a/crates/lad_backends/mdbook_lad_preprocessor/Cargo.toml +++ b/crates/lad_backends/mdbook_lad_preprocessor/Cargo.toml @@ -13,17 +13,17 @@ include = ["readme.md", "/src"] readme = "readme.md" [dependencies] -clap = "4" -mdbook = "0.4" -ladfile = { path = "../../ladfile", version = "0.5.0" } -env_logger = "0.11" -log = "0.4" -serde_json = "1.0" -regex = "1.11" +env_logger = { workspace = true } +clap = { workspace = true } +ladfile = { workspace = true } +mdbook = { workspace = true } +log = { workspace = true } +serde_json = { workspace = true } +regex = { workspace = true } [dev-dependencies] -assert_cmd = "2.0" -pretty_assertions = "1.4.1" +assert_cmd = { workspace = true } +pretty_assertions = { workspace = true } [lints] workspace = true diff --git a/crates/ladfile/Cargo.toml b/crates/ladfile/Cargo.toml index bc2fa1442e..01b2845579 100644 --- a/crates/ladfile/Cargo.toml +++ b/crates/ladfile/Cargo.toml @@ -13,9 +13,9 @@ include = ["readme.md", "/src", "/test_assets"] readme = "readme.md" [dependencies] -serde = { version = "1.0", features = ["derive"] } -serde_json = "1.0" -indexmap = { version = "2.7", features = ["serde"] } +serde = { workspace = true, features = ["derive"] } +serde_json = { workspace = true } +indexmap = { workspace = true, features = ["serde"] } [features] diff --git a/crates/ladfile_builder/Cargo.toml b/crates/ladfile_builder/Cargo.toml index 47e0ad56b9..80bd326c3f 100644 --- a/crates/ladfile_builder/Cargo.toml +++ b/crates/ladfile_builder/Cargo.toml @@ -13,15 +13,17 @@ include = ["readme.md", "/src", "/test_assets"] readme = "readme.md" [dependencies] +bevy_app = { workspace = true, default-features = false, features = [] } +bevy_ecs = { workspace = true, default-features = false, features = [] } +bevy_platform = { workspace = true, default-features = false, features = [] } +bevy_log = { workspace = true, default-features = false, features = [] } bevy_mod_scripting_core = { workspace = true } -# I don't think bevy has a top level feature for this :C -bevy = { workspace = true } -bevy_reflect = { version = "0.16.0", features = ["documentation"] } -ladfile = { version = "0.5.0", path = "../ladfile" } -regex = "1.11" +bevy_reflect = { workspace = true, features = ["documentation"] } +ladfile = { workspace = true } +regex = { workspace = true } [dev-dependencies] -pretty_assertions = "1.4" +pretty_assertions = { workspace = true } [lints] workspace = true diff --git a/crates/ladfile_builder/src/lib.rs b/crates/ladfile_builder/src/lib.rs index 036aee195c..42cbb6de6a 100644 --- a/crates/ladfile_builder/src/lib.rs +++ b/crates/ladfile_builder/src/lib.rs @@ -5,12 +5,12 @@ use std::{ any::TypeId, borrow::Cow, cmp::{max, min}, - collections::HashMap, ffi::OsString, path::PathBuf, }; -use bevy::{ecs::world::World, log, platform::collections::HashSet}; +use bevy_ecs::world::World; +use bevy_log::warn; use bevy_mod_scripting_core::{ bindings::{ MarkAsCore, MarkAsGenerated, MarkAsSignificant, ReflectReference, @@ -28,6 +28,7 @@ use bevy_mod_scripting_core::{ }, match_by_type, }; +use bevy_platform::collections::{HashMap, HashSet}; use bevy_reflect::{NamedField, TypeInfo, TypeRegistry, Typed, UnnamedField}; use ladfile::*; @@ -493,10 +494,9 @@ impl<'t> LadFileBuilder<'t> { if let Some(t) = file.types.get_mut(type_id) { t.associated_functions.push(function_id.clone()); } else { - log::warn!( + warn!( "Function {} is on type {}, but the type is not registered in the LAD file.", - function_id, - type_id + function_id, type_id ); } } diff --git a/crates/ladfile_builder/src/plugin.rs b/crates/ladfile_builder/src/plugin.rs index 984a47542c..97a3db29e5 100644 --- a/crates/ladfile_builder/src/plugin.rs +++ b/crates/ladfile_builder/src/plugin.rs @@ -2,10 +2,11 @@ use std::path::PathBuf; -use bevy::{ - app::{App, Plugin, Startup}, - ecs::{prelude::Resource, reflect::AppTypeRegistry, system::Res, world::World}, +use ::{ + bevy_app::{App, Plugin, Startup}, + bevy_ecs::{prelude::Resource, reflect::AppTypeRegistry, system::Res, world::World}, }; +use bevy_log::{error, info}; use bevy_mod_scripting_core::bindings::{ IntoNamespace, function::{namespace::Namespace, script_function::AppScriptFunctionRegistry}, @@ -151,7 +152,7 @@ pub fn generate_lad_file( let file = match ladfile::serialize_lad_file(&file, settings.pretty) { Ok(file) => file, Err(e) => { - bevy::log::error!("Error serializing LAD file: {}", e); + error!("Error serializing LAD file: {}", e); return; } }; @@ -159,10 +160,10 @@ pub fn generate_lad_file( // save match std::fs::write(&path, file) { Ok(_) => { - bevy::log::info!("Successfully generated LAD file at {:?}", path); + info!("Successfully generated LAD file at {:?}", path); } Err(e) => { - bevy::log::error!("Error saving LAD file to {:?}: {}", path, e); + error!("Error saving LAD file to {:?}: {}", path, e); } } } diff --git a/crates/languages/bevy_mod_scripting_lua/Cargo.toml b/crates/languages/bevy_mod_scripting_lua/Cargo.toml index 87cf7a56cc..53b5e69f0a 100644 --- a/crates/languages/bevy_mod_scripting_lua/Cargo.toml +++ b/crates/languages/bevy_mod_scripting_lua/Cargo.toml @@ -37,9 +37,13 @@ name = "bevy_mod_scripting_lua" path = "src/lib.rs" [dependencies] -bevy = { workspace = true, default-features = false } +bevy_app = { workspace = true, default-features = false, features = [] } +bevy_ecs = { workspace = true, default-features = false, features = [] } +bevy_asset = { workspace = true, default-features = false, features = [] } +bevy_log = { workspace = true, default-features = false, features = [] } +bevy_platform = { workspace = true, default-features = false, features = [] } bevy_mod_scripting_core = { workspace = true, features = ["mlua_impls"] } -mlua = { version = "0.10", features = ["vendored", "send", "macros"] } +mlua = { workspace = true, features = ["vendored", "send", "macros"] } profiling = { workspace = true } [lints] diff --git a/crates/languages/bevy_mod_scripting_lua/src/bindings/script_value.rs b/crates/languages/bevy_mod_scripting_lua/src/bindings/script_value.rs index 8eff8e51bd..11a326054b 100644 --- a/crates/languages/bevy_mod_scripting_lua/src/bindings/script_value.rs +++ b/crates/languages/bevy_mod_scripting_lua/src/bindings/script_value.rs @@ -1,5 +1,5 @@ use std::{ - collections::{HashMap, VecDeque}, + collections::VecDeque, ops::{Deref, DerefMut}, }; @@ -8,6 +8,7 @@ use bevy_mod_scripting_core::{ bindings::{function::script_function::FunctionCallContext, script_value::ScriptValue}, error::InteropError, }; +use bevy_platform::collections::HashMap; use mlua::{FromLua, IntoLua, Value, Variadic}; use super::reference::LuaReflectReference; @@ -162,7 +163,7 @@ impl IntoLua for LuaScriptValue { Value::Table(table) } ScriptValue::Map(map) => { - let hashmap: HashMap = map + let hashmap: std::collections::HashMap = map .into_iter() .map(|(k, v)| Ok((k, LuaScriptValue::from(v).into_lua(lua)?))) .collect::>()?; diff --git a/crates/languages/bevy_mod_scripting_lua/src/lib.rs b/crates/languages/bevy_mod_scripting_lua/src/lib.rs index 60c38478b5..423fb5cb11 100644 --- a/crates/languages/bevy_mod_scripting_lua/src/lib.rs +++ b/crates/languages/bevy_mod_scripting_lua/src/lib.rs @@ -1,9 +1,11 @@ //! Lua integration for the bevy_mod_scripting system. -use bevy::{ - app::Plugin, - asset::Handle, - ecs::{entity::Entity, world::World}, +use ::{ + bevy_app::Plugin, + bevy_asset::Handle, + bevy_ecs::{entity::Entity, world::World}, }; +use bevy_app::App; +use bevy_log::trace; use bevy_mod_scripting_core::{ IntoScriptPluginParams, ScriptingPlugin, asset::{Language, ScriptAsset}, @@ -159,11 +161,11 @@ impl Default for LuaScriptingPlugin { } impl Plugin for LuaScriptingPlugin { - fn build(&self, app: &mut bevy::prelude::App) { + fn build(&self, app: &mut App) { self.scripting_plugin.build(app); } - fn finish(&self, app: &mut bevy::app::App) { + fn finish(&self, app: &mut App) { self.scripting_plugin.finish(app); } } @@ -254,7 +256,7 @@ pub fn lua_handler( Ok(handler) => handler, // not subscribed to this event type Err(_) => { - bevy::log::trace!( + trace!( "Context {} is not subscribed to callback {}", context_key, callback_label.as_ref() @@ -275,10 +277,7 @@ pub fn lua_handler( #[cfg(test)] mod test { - use bevy::{ - asset::{AssetId, AssetIndex}, - prelude::Handle, - }; + use ::bevy_asset::{AssetId, AssetIndex, Handle}; use mlua::Value; use super::*; diff --git a/crates/languages/bevy_mod_scripting_rhai/Cargo.toml b/crates/languages/bevy_mod_scripting_rhai/Cargo.toml index 3fd4aab11c..22571ed9f3 100644 --- a/crates/languages/bevy_mod_scripting_rhai/Cargo.toml +++ b/crates/languages/bevy_mod_scripting_rhai/Cargo.toml @@ -16,11 +16,14 @@ name = "bevy_mod_scripting_rhai" path = "src/lib.rs" [dependencies] -bevy = { workspace = true, default-features = false } -rhai = { version = "1.21" } +bevy_ecs = { workspace = true, default-features = false, features = [] } +bevy_asset = { workspace = true, default-features = false, features = [] } +bevy_app = { workspace = true, default-features = false, features = [] } +bevy_log = { workspace = true, default-features = false, features = [] } +rhai = { workspace = true } bevy_mod_scripting_core = { workspace = true, features = ["rhai_impls"] } -strum = { version = "0.26", features = ["derive"] } -parking_lot = "0.12.1" +strum = { workspace = true } +parking_lot = { workspace = true } [lints] workspace = true diff --git a/crates/languages/bevy_mod_scripting_rhai/src/lib.rs b/crates/languages/bevy_mod_scripting_rhai/src/lib.rs index acbbd201fd..ca713fdcf4 100644 --- a/crates/languages/bevy_mod_scripting_rhai/src/lib.rs +++ b/crates/languages/bevy_mod_scripting_rhai/src/lib.rs @@ -2,11 +2,13 @@ use std::ops::Deref; -use bevy::{ - app::Plugin, - asset::Handle, - ecs::{entity::Entity, world::World}, +use ::{ + bevy_app::Plugin, + bevy_asset::Handle, + bevy_ecs::{entity::Entity, world::World}, }; +use bevy_app::App; +use bevy_log::trace; use bevy_mod_scripting_core::{ IntoScriptPluginParams, ScriptingPlugin, asset::{Language, ScriptAsset}, @@ -188,11 +190,11 @@ impl Default for RhaiScriptingPlugin { } impl Plugin for RhaiScriptingPlugin { - fn build(&self, app: &mut bevy::prelude::App) { + fn build(&self, app: &mut App) { self.scripting_plugin.build(app); } - fn finish(&self, app: &mut bevy::app::App) { + fn finish(&self, app: &mut App) { self.scripting_plugin.finish(app); } } @@ -289,11 +291,9 @@ pub fn rhai_callback_handler( .map(|v| v.into_dynamic()) .collect::, _>>()?; - bevy::log::trace!( + trace!( "Calling callback {} in context {} with args: {:?}", - callback, - context_key, - args + callback, context_key, args ); let runtime = runtime.read(); @@ -307,10 +307,9 @@ pub fn rhai_callback_handler( Ok(v) => Ok(ScriptValue::from_dynamic(v)?), Err(e) => { if let EvalAltResult::ErrorFunctionNotFound(_, _) = e.unwrap_inner() { - bevy::log::trace!( + trace!( "Context {} is not subscribed to callback {} with the provided arguments.", - context_key, - callback + context_key, callback ); Ok(ScriptValue::Unit) } else { diff --git a/crates/testing_crates/script_integration_test_harness/Cargo.toml b/crates/testing_crates/script_integration_test_harness/Cargo.toml index feeecc9212..ec056f2394 100644 --- a/crates/testing_crates/script_integration_test_harness/Cargo.toml +++ b/crates/testing_crates/script_integration_test_harness/Cargo.toml @@ -20,14 +20,14 @@ bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_functions = { workspace = true, features = [ "core_functions", ] } -regex = { version = "1.11" } -pretty_assertions = "1.*" -bevy_mod_scripting_lua = { path = "../../languages/bevy_mod_scripting_lua", optional = true } -bevy_mod_scripting_rhai = { path = "../../languages/bevy_mod_scripting_rhai", optional = true } -criterion = "0.5" -rand = "0.9" -rand_chacha = "0.9" -uuid = "1.11" -anyhow = "1.0" -serde = { version = "1.0", features = ["derive"] } -serde_json = "1.0" +regex = { workspace = true } +pretty_assertions = { workspace = true } +bevy_mod_scripting_lua = { workspace = true, optional = true } +bevy_mod_scripting_rhai = { workspace = true, optional = true } +criterion = { workspace = true } +rand = { workspace = true } +rand_chacha = { workspace = true } +uuid = { workspace = true } +anyhow = { workspace = true } +serde = { workspace = true, features = ["derive"] } +serde_json = { workspace = true } diff --git a/crates/testing_crates/test_utils/Cargo.toml b/crates/testing_crates/test_utils/Cargo.toml index dbb4e24c35..a474cedc0b 100644 --- a/crates/testing_crates/test_utils/Cargo.toml +++ b/crates/testing_crates/test_utils/Cargo.toml @@ -5,7 +5,14 @@ edition = "2024" publish = false [dependencies] -bevy = { workspace = true, features = ["bevy_asset"] } +bevy_ecs = { workspace = true, default-features = false, features = [] } +bevy_app = { workspace = true, default-features = false, features = [] } +bevy_asset = { workspace = true, default-features = false, features = [] } +bevy_log = { workspace = true, default-features = false, features = [] } +bevy_diagnostic = { workspace = true, default-features = false, features = [] } +bevy_reflect = { workspace = true, default-features = false, features = [] } +bevy_time = { workspace = true, default-features = false, features = [] } + [lib] path = "src/lib.rs" diff --git a/crates/testing_crates/test_utils/src/test_data.rs b/crates/testing_crates/test_utils/src/test_data.rs index 86acbcc7ca..5cadbaf63f 100644 --- a/crates/testing_crates/test_utils/src/test_data.rs +++ b/crates/testing_crates/test_utils/src/test_data.rs @@ -1,11 +1,15 @@ use std::{alloc::Layout, collections::HashMap}; -use bevy::{ - asset::AssetPlugin, - diagnostic::DiagnosticsPlugin, - ecs::{component::*, world::World}, - prelude::*, - reflect::*, +use bevy_app::{App, ScheduleRunnerPlugin, TaskPoolPlugin}; +use bevy_diagnostic::FrameCountPlugin; +use bevy_log::LogPlugin; +use bevy_time::TimePlugin; + +use ::{ + bevy_asset::AssetPlugin, + bevy_diagnostic::DiagnosticsPlugin, + bevy_ecs::{component::*, prelude::*, world::World}, + bevy_reflect::{prelude::*, *}, }; /// Test component with Reflect and ReflectComponent registered @@ -346,10 +350,13 @@ pub fn setup_integration_test(init: F) std::env::var("RUST_LOG").unwrap_or_else(|_| "bevy_mod_scripting_core=debug".to_string()); app.add_plugins(( - MinimalPlugins, + TaskPoolPlugin::default(), + FrameCountPlugin, + TimePlugin, + ScheduleRunnerPlugin::default(), AssetPlugin::default(), DiagnosticsPlugin, - bevy::log::LogPlugin { + LogPlugin { filter: log_level, ..Default::default() }, diff --git a/crates/testing_crates/test_utils/src/test_plugin.rs b/crates/testing_crates/test_utils/src/test_plugin.rs index 335f2bc203..b1c25aacc3 100644 --- a/crates/testing_crates/test_utils/src/test_plugin.rs +++ b/crates/testing_crates/test_utils/src/test_plugin.rs @@ -12,8 +12,8 @@ macro_rules! make_test_plugin { } } - impl bevy::app::Plugin for TestPlugin { - fn build(&self, app: &mut bevy::app::App) { + impl Plugin for TestPlugin { + fn build(&self, app: &mut App) { self.0.build(app); } } @@ -63,12 +63,8 @@ macro_rules! make_test_plugin { #[derive(Default, std::fmt::Debug)] struct TestRuntime { - pub invocations: parking_lot::Mutex< - Vec<( - Option, - Option<$ident::script::ScriptId>, - )>, - >, + pub invocations: + parking_lot::Mutex, Option<$ident::script::ScriptId>)>>, } #[derive(Default, std::fmt::Debug, Clone)] From 75a3d7aadaf479062d0419979037865f75bcf924 Mon Sep 17 00:00:00 2001 From: makspll Date: Sat, 23 Aug 2025 20:14:33 +0100 Subject: [PATCH 02/10] rest of the fixes --- Cargo.toml | 19 +- benches/benchmarks.rs | 3 +- codegen/templates/footer.tera | 4 +- codegen/templates/header.tera | 2 + codegen/templates/macros.tera | 2 +- crates/bevy_mod_scripting_core/Cargo.toml | 2 +- crates/bevy_mod_scripting_core/src/asset.rs | 203 +++++++++--------- .../src/bindings/function/from.rs | 63 +++--- .../bevy_mod_scripting_functions/Cargo.toml | 19 +- .../src/bevy_bindings/bevy_ecs.rs | 5 +- .../src/bevy_bindings/bevy_input.rs | 5 +- .../src/bevy_bindings/bevy_math.rs | 5 +- .../src/bevy_bindings/bevy_reflect.rs | 5 +- .../src/bevy_bindings/bevy_time.rs | 5 +- .../src/bevy_bindings/bevy_transform.rs | 5 +- .../bevy_mod_scripting_functions/src/core.rs | 9 +- .../bevy_mod_scripting_functions/src/lib.rs | 4 +- .../bevy_mod_scripting_rhai/Cargo.toml | 2 +- .../Cargo.toml | 6 +- .../src/lib.rs | 24 +-- .../src/scenario.rs | 91 ++++---- .../src/test_functions.rs | 9 +- src/lib.rs | 9 +- 23 files changed, 268 insertions(+), 233 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 2b3a94f960..5d6aaea71c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -71,8 +71,7 @@ profile_with_tracy = ["bevy?/trace_tracy", "dep:bevy"] [dependencies] bevy = { workspace = true, optional = true } -bevy_math = { workspace = true } -bevy_reflect = { workspace = true } +bevy_app = { workspace = true } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_lua = { workspace = true, optional = true } bevy_mod_scripting_rhai = { workspace = true, optional = true } @@ -106,14 +105,16 @@ bevy_diagnostic = { version = "0.16.0", default-features = false } bevy_platform = { version = "0.16.0", default-features = false } bevy_time = { version = "0.16.0", default-features = false } bevy_input = { version = "0.16.0", default-features = false } -glam = { version = "0.30.0", default-features = false } +glam = { version = "0.29.3", default-features = false } uuid = { version = "1.11", default-features = false } smol_str = { version = "0.2.0", default-features = false } # other serde_json = { version = "1.0", default-features = false } indexmap = { version = "2.7", default-features = false } -profiling = { version = "1.0", default-features = false } +profiling = { version = "1.0", default-features = false, features = [ + "procmacros", +] } regex = { version = "1.11", default-features = false } serde = { version = "1.0", default-features = false } dot-writer = { version = "0.1.4", default-features = false } @@ -149,8 +150,16 @@ rand = { version = "0.9", default-features = false } rand_chacha = { version = "0.9", default-features = false } [dev-dependencies] +bevy = { workspace = true, features = [ + "bevy_render", + "bevy_window", + "bevy_asset", + "bevy_core_pipeline", + "bevy_sprite", +] } +bevy_platform = { workspace = true } clap = { workspace = true, features = ["derive"] } -rand = { workspace = true } +rand = { workspace = true, features = ["thread_rng"] } criterion = { workspace = true } ladfile_builder = { workspace = true } script_integration_test_harness = { workspace = true } diff --git a/benches/benchmarks.rs b/benches/benchmarks.rs index 427bea3e63..e4e90436b0 100644 --- a/benches/benchmarks.rs +++ b/benches/benchmarks.rs @@ -1,7 +1,8 @@ extern crate bevy_mod_scripting; extern crate script_integration_test_harness; extern crate test_utils; -use std::{collections::HashMap, path::PathBuf, sync::LazyLock, time::Duration}; +use bevy_platform::collections::HashMap; +use std::{path::PathBuf, sync::LazyLock, time::Duration}; use bevy::{ log::{ diff --git a/codegen/templates/footer.tera b/codegen/templates/footer.tera index 4c8ea6ada3..3e238de676 100644 --- a/codegen/templates/footer.tera +++ b/codegen/templates/footer.tera @@ -52,8 +52,8 @@ impl {{item.import_path}} { } {% endfor %} -impl ::bevy::app::Plugin for {{ "ScriptingPlugin" | prefix_cratename | convert_case(case="upper_camel")}} { - fn build(&self, app: &mut ::bevy::prelude::App) { +impl Plugin for {{ "ScriptingPlugin" | prefix_cratename | convert_case(case="upper_camel")}} { + fn build(&self, app: &mut App) { let mut world = app.world_mut(); {% for item in items %} diff --git a/codegen/templates/header.tera b/codegen/templates/header.tera index 2351731544..4b0c658c2d 100644 --- a/codegen/templates/header.tera +++ b/codegen/templates/header.tera @@ -8,6 +8,8 @@ use bevy_mod_scripting_core::{ function::{from::{Ref, Mut, Val}, namespace::{NamespaceBuilder}} } }; +use bevy_ecs::{prelude::*}; + use bevy_mod_scripting_derive::script_bindings; diff --git a/codegen/templates/macros.tera b/codegen/templates/macros.tera index 5297a43694..561dee898f 100644 --- a/codegen/templates/macros.tera +++ b/codegen/templates/macros.tera @@ -25,7 +25,7 @@ fn index(_self: Self, idx: usize, lua: &tealr::mlu::mlua::Lua) -> Result "unknown_axis" }; - let parsed_path = ::bevy::reflect::ParsedPath::parse_static(path).expect("invariant"); + let parsed_path = ::bevy_reflect::ParsedPath::parse_static(path).expect("invariant"); curr_ref.index_path(bevy_mod_scripting_core::bindings::ReflectionPathElem::new_reflection(parsed_path)); crate::bindings::reference::LuaReflectReference(curr_ref).to_lua_proxy(lua) } diff --git a/crates/bevy_mod_scripting_core/Cargo.toml b/crates/bevy_mod_scripting_core/Cargo.toml index 57d8ed1aab..1a88236531 100644 --- a/crates/bevy_mod_scripting_core/Cargo.toml +++ b/crates/bevy_mod_scripting_core/Cargo.toml @@ -50,7 +50,7 @@ variadics_please = { workspace = true } [dev-dependencies] test_utils = { workspace = true } tokio = { workspace = true, features = ["rt", "macros"] } -pretty_assertions = { workspace = true } +pretty_assertions = { workspace = true, features = ["alloc"] } [lints] workspace = true diff --git a/crates/bevy_mod_scripting_core/src/asset.rs b/crates/bevy_mod_scripting_core/src/asset.rs index ef2e07937e..6b25e26f1c 100644 --- a/crates/bevy_mod_scripting_core/src/asset.rs +++ b/crates/bevy_mod_scripting_core/src/asset.rs @@ -357,104 +357,105 @@ pub(crate) fn configure_asset_systems_for_plugin(app: ); } -#[cfg(test)] -mod tests { - - use ::{ - bevy_app::App, - bevy_asset::{AssetServer, Handle, LoadState}, - }; - - use super::*; - - // fn init_loader_test(loader: ScriptAssetLoader) -> App { - // let mut app = App::new(); - // app.add_plugins((MinimalPlugins, AssetPlugin::default())); - // app.init_asset::(); - // app.register_asset_loader(loader); - // app - // } - - // fn for_extension(extension: &'static str) -> ScriptAssetLoader { - // let mut language_extensions = LanguageExtensions::default(); - // language_extensions.insert(extension, Language::Unknown); - // ScriptAssetLoader::new(language_extensions) - // } - - // fn load_asset(app: &mut App, path: &str) -> Handle { - // let handle = app.world_mut().resource::().load(path); - - // loop { - // let state = app - // .world() - // .resource::() - // .get_load_state(&handle) - // .unwrap(); - // if !matches!(state, LoadState::Loading) { - // break; - // } - // app.update(); - // } - - // match app - // .world() - // .resource::() - // .get_load_state(&handle) - // .unwrap() - // { - // LoadState::NotLoaded => panic!("Asset not loaded"), - // LoadState::Loaded => {} - // LoadState::Failed(asset_load_error) => { - // panic!("Asset load failed: {asset_load_error:?}") - // } - // _ => panic!("Unexpected load state"), - // } - - // handle - // } - - // #[test] - // fn test_asset_loader_loads() { - // let loader = for_extension("script"); - // let mut app = init_loader_test(loader); - - // let handle = load_asset(&mut app, "test_assets/test_script.script"); - // let asset = app - // .world() - // .get_resource::>() - // .unwrap() - // .get(&handle) - // .unwrap(); - - // assert_eq!( - // String::from_utf8(asset.content.clone().to_vec()).unwrap(), - // "test script".to_string() - // ); - // } - - // #[test] - // fn test_asset_loader_applies_preprocessor() { - // let loader = for_extension("script").with_preprocessor(Box::new(|content| { - // content[0] = b'p'; - // Ok(()) - // })); - // let mut app = init_loader_test(loader); - - // let handle = load_asset(&mut app, "test_assets/test_script.script"); - // let asset = app - // .world() - // .get_resource::>() - // .unwrap() - // .get(&handle) - // .unwrap(); - - // assert_eq!( - // handle.path().unwrap(), - // &AssetPath::from(PathBuf::from("test_assets/test_script.script")) - // ); - // assert_eq!( - // String::from_utf8(asset.content.clone().to_vec()).unwrap(), - // "pest script".to_string() - // ); - // } -} +// #[cfg(test)] +// mod tests { + +// use ::{ +// bevy_app::App, +// bevy_asset::{AssetServer, Handle, LoadState}, +// }; + +// use super::*; + +// // fn init_loader_test(loader: ScriptAssetLoader) -> App { +// // let mut app = App::new(); +// // app.add_plugins((MinimalPlugins, AssetPlugin::default())); +// // app.init_asset::(); +// // app.register_asset_loader(loader); +// // app +// // } + +// // fn for_extension(extension: &'static str) -> ScriptAssetLoader { +// // let mut language_extensions = LanguageExtensions::default(); +// // language_extensions.insert(extension, Language::Unknown); +// // ScriptAssetLoader::new(language_extensions) +// // } + +// // fn load_asset(app: &mut App, path: &str) -> Handle { +// // let handle = app.world_mut().resource::().load(path); + +// // loop { +// // let state = app +// // .world() +// // .resource::() +// // .get_load_state(&handle) +// // .unwrap(); +// // if !matches!(state, LoadState::Loading) { +// // break; +// // } +// // app.update(); +// // } + +// // match app +// // .world() +// // .resource::() +// // .get_load_state(&handle) +// // .unwrap() +// // { +// // LoadState::NotLoaded => panic!("Asset not loaded"), +// // LoadState::Loaded => {} +// // LoadState::Failed(asset_load_error) => { +// // panic!("Asset load failed: {asset_load_error:?}") +// // } +// // _ => panic!("Unexpected load state"), +// // } + +// // handle +// // } + +// // #[test] +// // fn test_asset_loader_loads() { +// // let loader = for_extension("script"); +// // let mut app = init_loader_test(loader); + +// // let handle = load_asset(&mut app, "test_assets/test_script.script"); +// // let asset = app +// // .world() +// // .get_resource::>() +// // .unwrap() +// // .get(&handle) +// // .unwrap(); + +// // assert_eq!( +// // String::from_utf8(asset.content.clone().to_vec()).unwrap(), +// // "test script".to_string() +// // ); +// // } + +// // #[test] +// // fn test_asset_loader_applies_preprocessor() { +// // let loader = for_extension("script").with_preprocessor(Box::new(|content| { +// // content[0] = b'p'; +// // Ok(()) +// // })); +// // let mut app = init_loader_test(loader); + +// // let handle = load_asset(&mut app, "test_assets/test_script.script"); +// // let asset = app +// // .world() +// // .get_resource::>() +// // .unwrap() +// // .get(&handle) +// // .unwrap(); + +// // assert_eq!( +// // handle.path().unwrap(), +// // &AssetPath::from(PathBuf::from("test_assets/test_script.script")) +// // ); +// // assert_eq!( +// // String::from_utf8(asset.content.clone().to_vec()).unwrap(), +// // "pest script".to_string() +// // ); +// // } +// } + diff --git a/crates/bevy_mod_scripting_core/src/bindings/function/from.rs b/crates/bevy_mod_scripting_core/src/bindings/function/from.rs index ed9b14c66e..3cb1d933cd 100644 --- a/crates/bevy_mod_scripting_core/src/bindings/function/from.rs +++ b/crates/bevy_mod_scripting_core/src/bindings/function/from.rs @@ -452,39 +452,46 @@ impl FromScript for DynamicScriptFunction { } } -#[profiling::all_functions] -impl FromScript for HashMap -where - V: FromScript + 'static, - for<'w> V::This<'w>: Into, -{ - type This<'w> = Self; - #[profiling::function] - fn from_script(value: ScriptValue, world: WorldGuard) -> Result { - match value { - ScriptValue::Map(map) => { - let mut hashmap = HashMap::new(); - for (key, value) in map { - hashmap.insert(key, V::from_script(value, world.clone())?.into()); - } - Ok(hashmap) - } - ScriptValue::List(list) => { - let mut hashmap = HashMap::new(); - for elem in list { - let (key, val) = <(String, V)>::from_script(elem, world.clone())?; - hashmap.insert(key, val); +macro_rules! impl_from_script_hashmap { + ($hashmap_type:path) => { + #[profiling::all_functions] + impl FromScript for $hashmap_type + where + V: FromScript + 'static, + for<'w> V::This<'w>: Into, + { + type This<'w> = Self; + #[profiling::function] + fn from_script(value: ScriptValue, world: WorldGuard) -> Result { + match value { + ScriptValue::Map(map) => { + let mut hashmap = <$hashmap_type>::new(); + for (key, value) in map { + hashmap.insert(key, V::from_script(value, world.clone())?.into()); + } + Ok(hashmap) + } + ScriptValue::List(list) => { + let mut hashmap = <$hashmap_type>::new(); + for elem in list { + let (key, val) = <(String, V)>::from_script(elem, world.clone())?; + hashmap.insert(key, val); + } + Ok(hashmap) + } + _ => Err(InteropError::value_mismatch( + std::any::TypeId::of::<$hashmap_type>(), + value, + )), } - Ok(hashmap) } - _ => Err(InteropError::value_mismatch( - std::any::TypeId::of::>(), - value, - )), } - } + }; } +impl_from_script_hashmap!(HashMap); +impl_from_script_hashmap!(std::collections::HashMap); + /// A union of two or more (by nesting unions) types. pub struct Union(Result); diff --git a/crates/bevy_mod_scripting_functions/Cargo.toml b/crates/bevy_mod_scripting_functions/Cargo.toml index 674aa6a72f..8084931942 100644 --- a/crates/bevy_mod_scripting_functions/Cargo.toml +++ b/crates/bevy_mod_scripting_functions/Cargo.toml @@ -12,7 +12,7 @@ categories = ["game-development"] readme = "readme.md" [features] -bevy_ecs = ["dep:bevy_ecs"] +bevy_ecs = [] bevy_input = ["dep:bevy_input"] bevy_math = ["dep:bevy_math"] bevy_reflect = ["dep:bevy_reflect", "dep:glam", "dep:uuid", "dep:smol_str"] @@ -25,17 +25,24 @@ rhai_bindings = ["bevy_mod_scripting_rhai"] [dependencies] -# required since curve has no top level bevy features for these -bevy_ecs = { workspace = true, optional = true } +bevy_ecs = { workspace = true } +bevy_app = { workspace = true } +bevy_asset = { workspace = true } +bevy_platform = { workspace = true } bevy_input = { workspace = true, optional = true } bevy_math = { workspace = true, features = ["curve"], optional = true } -bevy_reflect = { workspace = true, features = ["smol_str"], optional = true } +bevy_reflect = { workspace = true, features = [ + "smol_str", + "glam", + "uuid", + "std", + "debug_stack", +], optional = true } uuid = { workspace = true, optional = true } smol_str = { workspace = true, optional = true } bevy_time = { workspace = true, optional = true } bevy_transform = { workspace = true, optional = true } -bevy_app = { workspace = true, optional = true } -glam = { workspace = true, optional = true } +glam = { workspace = true, optional = true, features = ["serde", "std"] } profiling = { workspace = true } diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_ecs.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_ecs.rs index 7af5984df4..d6c9de7b1d 100644 --- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_ecs.rs +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_ecs.rs @@ -9,6 +9,7 @@ use bevy_mod_scripting_core::bindings::{ namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; use bevy_mod_scripting_derive::script_bindings; use crate::*; pub struct BevyEcsScriptingPlugin; @@ -656,8 +657,8 @@ impl ::bevy_ecs::system::SystemIdMarker {} generated )] impl ::bevy_ecs::world::OnDespawn {} -impl ::bevy::app::Plugin for BevyEcsScriptingPlugin { - fn build(&self, app: &mut ::bevy::prelude::App) { +impl Plugin for BevyEcsScriptingPlugin { + fn build(&self, app: &mut App) { let mut world = app.world_mut(); register_entity_functions(&mut world); register_child_of_functions(&mut world); diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_input.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_input.rs index 66c1c40f88..0fbcbba30f 100644 --- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_input.rs +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_input.rs @@ -9,6 +9,7 @@ use bevy_mod_scripting_core::bindings::{ namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; use bevy_mod_scripting_derive::script_bindings; use crate::*; pub struct BevyInputScriptingPlugin; @@ -1567,8 +1568,8 @@ impl ::bevy_input::touch::ForceTouch { output } } -impl ::bevy::app::Plugin for BevyInputScriptingPlugin { - fn build(&self, app: &mut ::bevy::prelude::App) { +impl Plugin for BevyInputScriptingPlugin { + fn build(&self, app: &mut App) { let mut world = app.world_mut(); register_gamepad_functions(&mut world); register_gamepad_axis_functions(&mut world); diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_math.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_math.rs index a0ab749712..e856c5e03a 100644 --- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_math.rs +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_math.rs @@ -9,6 +9,7 @@ use bevy_mod_scripting_core::bindings::{ namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; use bevy_mod_scripting_derive::script_bindings; use crate::*; pub struct BevyMathScriptingPlugin; @@ -5415,8 +5416,8 @@ impl ::bevy_math::curve::easing::JumpAt { output } } -impl ::bevy::app::Plugin for BevyMathScriptingPlugin { - fn build(&self, app: &mut ::bevy::prelude::App) { +impl Plugin for BevyMathScriptingPlugin { + fn build(&self, app: &mut App) { let mut world = app.world_mut(); register_aspect_ratio_functions(&mut world); register_compass_octant_functions(&mut world); diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_reflect.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_reflect.rs index bbdd1da621..efdaf9faad 100644 --- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_reflect.rs +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_reflect.rs @@ -9,6 +9,7 @@ use bevy_mod_scripting_core::bindings::{ namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; use bevy_mod_scripting_derive::script_bindings; use crate::*; pub struct BevyReflectScriptingPlugin; @@ -28089,8 +28090,8 @@ impl ::uuid::Uuid { output } } -impl ::bevy::app::Plugin for BevyReflectScriptingPlugin { - fn build(&self, app: &mut ::bevy::prelude::App) { +impl Plugin for BevyReflectScriptingPlugin { + fn build(&self, app: &mut App) { let mut world = app.world_mut(); register_atomic_bool_functions(&mut world); register_atomic_i_16_functions(&mut world); diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_time.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_time.rs index 566420cfcb..c19c29ccf4 100644 --- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_time.rs +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_time.rs @@ -9,6 +9,7 @@ use bevy_mod_scripting_core::bindings::{ namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; use bevy_mod_scripting_derive::script_bindings; use crate::*; pub struct BevyTimeScriptingPlugin; @@ -635,8 +636,8 @@ impl ::bevy_time::Stopwatch { output } } -impl ::bevy::app::Plugin for BevyTimeScriptingPlugin { - fn build(&self, app: &mut ::bevy::prelude::App) { +impl Plugin for BevyTimeScriptingPlugin { + fn build(&self, app: &mut App) { let mut world = app.world_mut(); register_fixed_functions(&mut world); register_real_functions(&mut world); diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_transform.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_transform.rs index f927db1014..97d5a0f5ed 100644 --- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_transform.rs +++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_transform.rs @@ -9,6 +9,7 @@ use bevy_mod_scripting_core::bindings::{ namespace::NamespaceBuilder, }, }; +use bevy_ecs::prelude::*; use bevy_mod_scripting_derive::script_bindings; use crate::*; pub struct BevyTransformScriptingPlugin; @@ -899,8 +900,8 @@ impl ::bevy_transform::components::TransformTreeChanged { output } } -impl ::bevy::app::Plugin for BevyTransformScriptingPlugin { - fn build(&self, app: &mut ::bevy::prelude::App) { +impl Plugin for BevyTransformScriptingPlugin { + fn build(&self, app: &mut App) { let mut world = app.world_mut(); register_global_transform_functions(&mut world); register_transform_functions(&mut world); diff --git a/crates/bevy_mod_scripting_functions/src/core.rs b/crates/bevy_mod_scripting_functions/src/core.rs index 3eefea720a..d35b10aa80 100644 --- a/crates/bevy_mod_scripting_functions/src/core.rs +++ b/crates/bevy_mod_scripting_functions/src/core.rs @@ -1,8 +1,11 @@ //! Contains functions defined by the [`bevy_mod_scripting_core`] crate -use std::{collections::HashMap, ops::Deref}; +use bevy_platform::collections::HashMap; +use std::ops::Deref; -use bevy::prelude::*; +use bevy_app::App; +use bevy_asset::{AssetServer, Handle}; +use bevy_ecs::{entity::Entity, prelude::AppTypeRegistry, schedule::Schedules, world::World}; use bevy_mod_scripting_core::{ asset::ScriptAsset, bindings::{ @@ -16,6 +19,7 @@ use bevy_mod_scripting_core::{ *, }; use bevy_mod_scripting_derive::script_bindings; +use bevy_reflect::PartialReflect; use bevy_system_reflection::{ReflectSchedule, ReflectSystem}; use bindings::{ ReflectReference, ScriptComponentRegistration, ScriptQueryBuilder, ScriptQueryResult, @@ -1357,6 +1361,7 @@ pub fn register_core_functions(app: &mut App) { register_script_system_builder_functions(world); register_script_attachment_functions(world); + register_script_handle_functions(world); register_global_namespace_functions(world); diff --git a/crates/bevy_mod_scripting_functions/src/lib.rs b/crates/bevy_mod_scripting_functions/src/lib.rs index a30e0fffd0..3b6c8d8390 100644 --- a/crates/bevy_mod_scripting_functions/src/lib.rs +++ b/crates/bevy_mod_scripting_functions/src/lib.rs @@ -1,10 +1,12 @@ #![allow(missing_docs)] -use bevy::prelude::*; pub mod bevy_bindings; pub mod core; pub use core::*; +use bevy_app::{App, Plugin}; +use bevy_ecs::hierarchy::{ChildOf, Children}; + /// A plugin that registers the core scripting functions. #[derive(Default)] pub struct ScriptFunctionsPlugin; diff --git a/crates/languages/bevy_mod_scripting_rhai/Cargo.toml b/crates/languages/bevy_mod_scripting_rhai/Cargo.toml index 22571ed9f3..6abccd50c9 100644 --- a/crates/languages/bevy_mod_scripting_rhai/Cargo.toml +++ b/crates/languages/bevy_mod_scripting_rhai/Cargo.toml @@ -20,7 +20,7 @@ bevy_ecs = { workspace = true, default-features = false, features = [] } bevy_asset = { workspace = true, default-features = false, features = [] } bevy_app = { workspace = true, default-features = false, features = [] } bevy_log = { workspace = true, default-features = false, features = [] } -rhai = { workspace = true } +rhai = { workspace = true, features = ["std"] } bevy_mod_scripting_core = { workspace = true, features = ["rhai_impls"] } strum = { workspace = true } parking_lot = { workspace = true } diff --git a/crates/testing_crates/script_integration_test_harness/Cargo.toml b/crates/testing_crates/script_integration_test_harness/Cargo.toml index ec056f2394..ad959930d0 100644 --- a/crates/testing_crates/script_integration_test_harness/Cargo.toml +++ b/crates/testing_crates/script_integration_test_harness/Cargo.toml @@ -14,8 +14,12 @@ lua = [ rhai = ["bevy_mod_scripting_rhai", "bevy_mod_scripting_functions/rhai_bindings"] [dependencies] -bevy = { workspace = true } +bevy_asset = { workspace = true } +bevy_ecs = { workspace = true } +bevy_app = { workspace = true } test_utils = { workspace = true } +bevy_reflect = { workspace = true } +bevy_log = { workspace = true } bevy_mod_scripting_core = { workspace = true } bevy_mod_scripting_functions = { workspace = true, features = [ "core_functions", diff --git a/crates/testing_crates/script_integration_test_harness/src/lib.rs b/crates/testing_crates/script_integration_test_harness/src/lib.rs index aa422e8415..0c7f18cfb0 100644 --- a/crates/testing_crates/script_integration_test_harness/src/lib.rs +++ b/crates/testing_crates/script_integration_test_harness/src/lib.rs @@ -7,18 +7,18 @@ use std::{ time::{Duration, Instant}, }; -use bevy::{ - app::{App, Plugin, PostUpdate, Startup, Update}, - asset::{AssetPath, AssetServer, Handle, LoadState}, - ecs::{ +use ::{ + bevy_app::{App, Plugin, PostUpdate, Startup, Update}, + bevy_asset::{AssetPath, AssetServer, Handle, LoadState}, + bevy_ecs::{ component::Component, resource::Resource, schedule::IntoScheduleConfigs, system::Command, world::FromWorld, }, - log::{ + bevy_log::{ Level, tracing::{self, event}, }, - reflect::Reflect, + bevy_reflect::Reflect, }; use bevy_mod_scripting_core::{ BMSScriptingInfrastructurePlugin, IntoScriptPluginParams, @@ -44,7 +44,7 @@ fn dummy_startup_system() {} fn dummy_before_post_update_system() {} fn dummy_post_update_system() {} -pub fn install_test_plugin(app: &mut bevy::app::App, include_test_functions: bool) { +pub fn install_test_plugin(app: &mut App, include_test_functions: bool) { app.add_plugins(( ScriptFunctionsPlugin, CoreScriptGlobalsPlugin::default(), @@ -205,9 +205,7 @@ pub fn run_lua_benchmark( pre_bencher.call::<()>(()).unwrap(); } c.iter(|| { - use bevy::log::{Level, tracing}; - - tracing::event!(Level::TRACE, "profiling_iter {}", label); + event!(Level::TRACE, "profiling_iter {}", label); bencher.call::<()>(()).unwrap(); }) }); @@ -243,9 +241,7 @@ pub fn run_rhai_benchmark( } c.iter(|| { - use bevy::log::{Level, tracing}; - - tracing::event!(Level::TRACE, "profiling_iter {}", label); + event!(Level::TRACE, "profiling_iter {}", label); let _ = runtime .call_fn::(&mut ctxt.scope, &ctxt.ast, "bench", ARGS) .unwrap(); @@ -443,7 +439,7 @@ pub fn perform_benchmark_with_generator< ) }, |(i, w)| { - event!(bevy::log::Level::TRACE, "profiling_iter {}", label); + event!(Level::TRACE, "profiling_iter {}", label); bench_fn(w, i) }, batch_size, diff --git a/crates/testing_crates/script_integration_test_harness/src/scenario.rs b/crates/testing_crates/script_integration_test_harness/src/scenario.rs index e50e2b34b5..b734b726c1 100644 --- a/crates/testing_crates/script_integration_test_harness/src/scenario.rs +++ b/crates/testing_crates/script_integration_test_harness/src/scenario.rs @@ -5,19 +5,22 @@ use std::{ time::Instant, }; -use anyhow::{Context, Error, anyhow}; -use bevy::{ - app::App, - asset::{AssetEvent, Handle, LoadState}, - ecs::{ +use ::{ + bevy_app::App, + bevy_asset::{AssetEvent, Handle, LoadState}, + bevy_ecs::{ entity::Entity, event::{Event, EventCursor, Events}, schedule::ScheduleLabel, system::Command, + system::IntoSystem, world::World, }, - prelude::IntoSystem, }; +use anyhow::{Context, Error, anyhow}; +use bevy_app::{DynEq, FixedUpdate, Last, PostUpdate, Startup, Update}; +use bevy_asset::{AssetServer, Assets}; +use bevy_log::info; use bevy_mod_scripting_core::{ ConfigureScriptPlugin, LanguageExtensions, asset::{Language, ScriptAsset}, @@ -121,7 +124,7 @@ impl Scenario { pub fn execute(mut self, mut app: App) -> Result<(), Error> { let original_steps = self.steps.clone(); for (i, step) in self.steps.into_iter().enumerate() { - bevy::log::info!( + info!( "Executing step #{i}: {}", step.to_flat_string().unwrap_or_default() ); @@ -141,7 +144,7 @@ impl Scenario { #[derive(Debug, Clone)] pub struct ScenarioContext { pub script_handles: HashMap>, - pub entities: HashMap, + pub entities: HashMap, pub scenario_time_started: Instant, pub this_script_asset_relative_path: PathBuf, pub event_log: InterestingEventWatcher, @@ -160,7 +163,7 @@ pub struct InterestingEventWatcher { } impl InterestingEventWatcher { - pub fn log_events(&mut self, step_no: usize, world: &bevy::ecs::world::World) { + pub fn log_events(&mut self, step_no: usize, world: &World) { let asset_events = world.resource::>>(); let script_events = world.resource::>(); let script_responses = world.resource::>(); @@ -228,7 +231,7 @@ impl ScenarioContext { .ok_or_else(|| anyhow!("Script with name '{name}' not found in context. Did you miss a `LoadScriptAs` step?")) } - pub fn get_entity(&self, name: &str) -> Result { + pub fn get_entity(&self, name: &str) -> Result { self .entities .get(name) @@ -270,31 +273,31 @@ impl ScenarioSchedule { impl ScheduleLabel for ScenarioSchedule { fn dyn_clone(&self) -> Box { match self { - ScenarioSchedule::Startup => bevy::app::Startup.dyn_clone(), - ScenarioSchedule::Update => bevy::app::Update.dyn_clone(), - ScenarioSchedule::FixedUpdate => bevy::app::FixedUpdate.dyn_clone(), - ScenarioSchedule::PostUpdate => bevy::app::PostUpdate.dyn_clone(), - ScenarioSchedule::Last => bevy::app::Last.dyn_clone(), + ScenarioSchedule::Startup => Startup.dyn_clone(), + ScenarioSchedule::Update => Update.dyn_clone(), + ScenarioSchedule::FixedUpdate => FixedUpdate.dyn_clone(), + ScenarioSchedule::PostUpdate => PostUpdate.dyn_clone(), + ScenarioSchedule::Last => Last.dyn_clone(), } } - fn as_dyn_eq(&self) -> &dyn bevy::ecs::label::DynEq { + fn as_dyn_eq(&self) -> &dyn DynEq { match self { - ScenarioSchedule::Startup => bevy::app::Startup.as_dyn_eq(), - ScenarioSchedule::Update => bevy::app::Update.as_dyn_eq(), - ScenarioSchedule::FixedUpdate => bevy::app::FixedUpdate.as_dyn_eq(), - ScenarioSchedule::PostUpdate => bevy::app::PostUpdate.as_dyn_eq(), - ScenarioSchedule::Last => bevy::app::Last.as_dyn_eq(), + ScenarioSchedule::Startup => Startup.as_dyn_eq(), + ScenarioSchedule::Update => Update.as_dyn_eq(), + ScenarioSchedule::FixedUpdate => FixedUpdate.as_dyn_eq(), + ScenarioSchedule::PostUpdate => PostUpdate.as_dyn_eq(), + ScenarioSchedule::Last => Last.as_dyn_eq(), } } fn dyn_hash(&self, state: &mut dyn ::core::hash::Hasher) { match self { - ScenarioSchedule::Startup => bevy::app::Startup.dyn_hash(state), - ScenarioSchedule::Update => bevy::app::Update.dyn_hash(state), - ScenarioSchedule::FixedUpdate => bevy::app::FixedUpdate.dyn_hash(state), - ScenarioSchedule::PostUpdate => bevy::app::PostUpdate.dyn_hash(state), - ScenarioSchedule::Last => bevy::app::Last.dyn_hash(state), + ScenarioSchedule::Startup => Startup.dyn_hash(state), + ScenarioSchedule::Update => Update.dyn_hash(state), + ScenarioSchedule::FixedUpdate => FixedUpdate.dyn_hash(state), + ScenarioSchedule::PostUpdate => PostUpdate.dyn_hash(state), + ScenarioSchedule::Last => Last.dyn_hash(state), } } } @@ -428,7 +431,7 @@ impl ScenarioStep { loop { { let world = app.world_mut(); - let events = world.resource::>(); + let events = world.resource::>(); let events = event_cursor .read(events) @@ -473,7 +476,7 @@ impl ScenarioStep { }; context.current_script_language = Some(language); - bevy::log::info!( + info!( "Set current script language to: {:?}", context.current_script_language ); @@ -481,7 +484,7 @@ impl ScenarioStep { ScenarioStep::FinalizeApp => { app.finish(); app.cleanup(); - bevy::log::info!("App finalized and cleaned up"); + info!("App finalized and cleaned up"); } ScenarioStep::InstallPlugin { context_policy, @@ -533,13 +536,13 @@ impl ScenarioStep { } else { path.clone() }; - let asset_server = app.world_mut().resource::(); + let asset_server = app.world_mut().resource::(); let script_handle = asset_server.load(context.scenario_path(&path)); context .script_handles .insert(as_name.to_string(), script_handle); - bevy::log::info!( + info!( "Script '{}' marked for loading from path '{}'", as_name, path.display() @@ -551,7 +554,7 @@ impl ScenarioStep { app, |e| e.is_added(script.id()), |w| { - let server = w.resource::(); + let server = w.resource::(); if let LoadState::Failed(r) = server.load_state(script.id()) { Some(r) } else { @@ -564,7 +567,7 @@ impl ScenarioStep { return Err(anyhow!("Failed to load script: {e}")); } - bevy::log::info!("Script '{}' loaded successfully", script.id()); + info!("Script '{}' loaded successfully", script.id()); } ScenarioStep::SetupHandler { schedule, label } => { match label.to_string().as_str() { @@ -601,7 +604,7 @@ impl ScenarioStep { .id(); context.entities.insert(name.to_string(), entity); - bevy::log::info!("Spawned entity '{}' with script '{}'", entity, script.id()); + info!("Spawned entity '{}' with script '{}'", entity, script.id()); } ScenarioStep::EmitScriptCallbackEvent { event } => { app.world_mut().send_event(event.clone()); @@ -627,7 +630,7 @@ impl ScenarioStep { match &event.response { Ok(val) => { - bevy::log::info!( + info!( "Callback '{}' for attachment: '{}' succeeded, with value: {:?}", label, script.to_string(), @@ -687,12 +690,10 @@ impl ScenarioStep { script.id() ) })?; - bevy::log::info!("Dropped script asset '{}' from context", name); + info!("Dropped script asset '{}' from context", name); } ScenarioStep::ReloadScriptFrom { script, path } => { - let mut assets = app - .world_mut() - .resource_mut::>(); + let mut assets = app.world_mut().resource_mut::>(); let absolute_path = context.absolute_scenario_path(&path); @@ -721,7 +722,7 @@ impl ScenarioStep { next_event )); } else { - bevy::log::info!("No callback responses emitted as expected"); + info!("No callback responses emitted as expected"); } } ScenarioStep::DespawnEntity { entity } => { @@ -732,16 +733,16 @@ impl ScenarioStep { entity )); } else { - bevy::log::info!("Despawning entity with name '{}'", entity); + info!("Despawning entity with name '{}'", entity); } } ScenarioStep::AttachStaticScript { script } => { AddStaticScript::new(script.clone()).apply(app.world_mut()); - bevy::log::info!("Attached static script with handle: {}", script.id()); + info!("Attached static script with handle: {}", script.id()); } ScenarioStep::DetachStaticScript { script } => { RemoveStaticScript::new(script.clone()).apply(app.world_mut()); - bevy::log::info!("Detached static script with handle: {}", script.id()); + info!("Detached static script with handle: {}", script.id()); } ScenarioStep::AssertContextResidents { script, @@ -773,7 +774,7 @@ impl ScenarioStep { residents )); } else { - bevy::log::info!( + info!( "Script attachment: {} has {} residents as expected", script.to_string(), residents @@ -782,7 +783,7 @@ impl ScenarioStep { } ScenarioStep::Comment { comment } => { // Comments are ignored, do nothing, log it though for debugging - bevy::log::info!("Comment: {}", comment); + info!("Comment: {}", comment); } } Ok(()) diff --git a/crates/testing_crates/script_integration_test_harness/src/test_functions.rs b/crates/testing_crates/script_integration_test_harness/src/test_functions.rs index a73aa6e39b..d7204671d3 100644 --- a/crates/testing_crates/script_integration_test_harness/src/test_functions.rs +++ b/crates/testing_crates/script_integration_test_harness/src/test_functions.rs @@ -3,11 +3,10 @@ use std::{ sync::{Arc, Mutex}, }; -use bevy::{ - app::App, - ecs::component::ComponentId, - prelude::{Entity, World}, - reflect::{Reflect, TypeRegistration}, +use ::{ + bevy_app::App, + bevy_ecs::{component::ComponentId, entity::Entity, world::World}, + bevy_reflect::{Reflect, TypeRegistration}, }; use bevy_mod_scripting_core::{ asset::Language, diff --git a/src/lib.rs b/src/lib.rs index 6f6e83fd94..8f12006566 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -16,14 +16,9 @@ pub mod rhai { pub use bevy_mod_scripting_rhai::*; } -// #[cfg(feature = "rune")] -// pub mod rune { -// pub use bevy_mod_scripting_rune::*; -// } - -use bevy::app::plugin_group; +use bevy_app::plugin_group; use bevy_mod_scripting_core::{ - BMSScriptingInfrastructurePlugin, bindings::CoreScriptGlobalsPlugin, + bindings::CoreScriptGlobalsPlugin, BMSScriptingInfrastructurePlugin, }; pub use bevy_mod_scripting_derive::*; pub use bevy_mod_scripting_functions::*; From 414d9bb6772feed855e9eb7cbd36ad83587db41e Mon Sep 17 00:00:00 2001 From: makspll Date: Sat, 23 Aug 2025 20:14:47 +0100 Subject: [PATCH 03/10] reformat --- crates/bevy_mod_scripting_core/src/asset.rs | 1 - src/lib.rs | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/crates/bevy_mod_scripting_core/src/asset.rs b/crates/bevy_mod_scripting_core/src/asset.rs index 6b25e26f1c..d34a7ff79f 100644 --- a/crates/bevy_mod_scripting_core/src/asset.rs +++ b/crates/bevy_mod_scripting_core/src/asset.rs @@ -458,4 +458,3 @@ pub(crate) fn configure_asset_systems_for_plugin(app: // // ); // // } // } - diff --git a/src/lib.rs b/src/lib.rs index 8f12006566..6ea28406fe 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -18,7 +18,7 @@ pub mod rhai { use bevy_app::plugin_group; use bevy_mod_scripting_core::{ - bindings::CoreScriptGlobalsPlugin, BMSScriptingInfrastructurePlugin, + BMSScriptingInfrastructurePlugin, bindings::CoreScriptGlobalsPlugin, }; pub use bevy_mod_scripting_derive::*; pub use bevy_mod_scripting_functions::*; From 1973eec7d80154aa3202886e05b128bd2adb8614 Mon Sep 17 00:00:00 2001 From: makspll Date: Sat, 23 Aug 2025 20:35:14 +0100 Subject: [PATCH 04/10] fix indexmap compilation error --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 5d6aaea71c..71558c2563 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -111,7 +111,7 @@ smol_str = { version = "0.2.0", default-features = false } # other serde_json = { version = "1.0", default-features = false } -indexmap = { version = "2.7", default-features = false } +indexmap = { version = "2.7", default-features = false, features = ["std"] } profiling = { version = "1.0", default-features = false, features = [ "procmacros", ] } From 63194e08acbe754bbbcd17c5e819b8d23cf596f5 Mon Sep 17 00:00:00 2001 From: makspll Date: Sat, 23 Aug 2025 20:37:06 +0100 Subject: [PATCH 05/10] add more features --- crates/lad_backends/mdbook_lad_preprocessor/Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/lad_backends/mdbook_lad_preprocessor/Cargo.toml b/crates/lad_backends/mdbook_lad_preprocessor/Cargo.toml index 93264441e9..939873041c 100644 --- a/crates/lad_backends/mdbook_lad_preprocessor/Cargo.toml +++ b/crates/lad_backends/mdbook_lad_preprocessor/Cargo.toml @@ -16,7 +16,7 @@ readme = "readme.md" env_logger = { workspace = true } clap = { workspace = true } ladfile = { workspace = true } -mdbook = { workspace = true } +mdbook = { workspace = true, features = ["search"] } log = { workspace = true } serde_json = { workspace = true } regex = { workspace = true } From 9aa1e427cd8bf4f6be344f74d1f76d010518a102 Mon Sep 17 00:00:00 2001 From: makspll Date: Sat, 23 Aug 2025 21:07:35 +0100 Subject: [PATCH 06/10] fix benchmarks --- .../script_integration_test_harness/src/lib.rs | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/crates/testing_crates/script_integration_test_harness/src/lib.rs b/crates/testing_crates/script_integration_test_harness/src/lib.rs index 0c7f18cfb0..78ba1ba67a 100644 --- a/crates/testing_crates/script_integration_test_harness/src/lib.rs +++ b/crates/testing_crates/script_integration_test_harness/src/lib.rs @@ -271,6 +271,11 @@ where install_test_plugin(&mut app, true); app.add_plugins(plugin); + + // finalize + app.cleanup(); + app.finish(); + let script_path = script_path.into(); let script_handle = app.world().resource::().load(script_path); let script_id = script_handle.id(); @@ -279,10 +284,6 @@ where .spawn(ScriptComponent(vec![script_handle.clone()])) .id(); - // finalize - app.cleanup(); - app.finish(); - let timer = Instant::now(); // Wait until script is loaded. From c719d687e2c9434696a80560b55497e290aad00e Mon Sep 17 00:00:00 2001 From: Maksymilian Mozolewski Date: Sat, 23 Aug 2025 21:29:38 +0100 Subject: [PATCH 07/10] Add 'std' feature to pretty_assertions dependency --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 71558c2563..808b4bd043 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -138,7 +138,7 @@ anyhow = { version = "1.0", default-features = false } # development and testing -pretty_assertions = { version = "1.4", default-features = false } +pretty_assertions = { version = "1.4", default-features = false, features=["std"] } manifest-dir-macros = { version = "0.1.18", default-features = false } assert_cmd = { version = "2.0", default-features = false } tokio = { version = "1", default-features = false } From 818c903f0909ef06c63d1478f5cf42e52e07f06e Mon Sep 17 00:00:00 2001 From: makspll Date: Sat, 23 Aug 2025 23:23:55 +0100 Subject: [PATCH 08/10] fix codegen --- xtask/src/main.rs | 25 +++++++++++++------------ 1 file changed, 13 insertions(+), 12 deletions(-) diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 654e088322..b304e3aba1 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -1256,20 +1256,21 @@ impl Xtasks { "crates/bevy_mod_scripting_functions", )?; - let expand_crates = std::fs::read_dir(&output_dir)?; - for entry in expand_crates { - let entry = entry?; - let path = entry.path(); - if path.extension().and_then(|s| s.to_str()) != Some("rs") || path.ends_with("mod.rs") { - continue; - } - - let without_extension = path.file_stem().unwrap().to_str().unwrap(); + let expand_crates = (std::fs::read_dir(&output_dir)?).collect::, _>>()?; + let crate_names = expand_crates + .iter() + .filter(|s| { + s.path().is_file() && s.path().ends_with(".rs") && !s.path().ends_with("mod.rs") + }) + .map(|s| s.path().file_stem().unwrap().to_str().unwrap().to_owned()) + .collect::>(); + let features = crate_names.join(","); + for entry in crate_names { let args = vec![ String::from("expand"), - format!("bevy_bindings::{without_extension}"), + format!("bevy_bindings::{entry}"), String::from("--features"), - String::from(without_extension), + features.clone(), ]; let expand_cmd = Self::run_system_command( &main_workspace_app_settings, @@ -1288,7 +1289,7 @@ impl Xtasks { .take(output.lines().count() - 2) .collect::>() .join("\n"); - + let path = output_dir.join(format!("{entry}.rs")); std::fs::write(&path, output) .with_context(|| format!("writing expanded code to {path:?}"))?; info!("Wrote expanded code to {path:?}"); From 73a2049087f41a6406523931fdff0e62804b5518 Mon Sep 17 00:00:00 2001 From: makspll Date: Sun, 24 Aug 2025 00:01:51 +0100 Subject: [PATCH 09/10] add more features for docs --- .../bevy_mod_scripting_functions/Cargo.toml | 26 ++++++++++++++----- 1 file changed, 20 insertions(+), 6 deletions(-) diff --git a/crates/bevy_mod_scripting_functions/Cargo.toml b/crates/bevy_mod_scripting_functions/Cargo.toml index 931b4c70ef..75313f411f 100644 --- a/crates/bevy_mod_scripting_functions/Cargo.toml +++ b/crates/bevy_mod_scripting_functions/Cargo.toml @@ -27,10 +27,17 @@ rhai_bindings = ["bevy_mod_scripting_rhai"] [dependencies] bevy_ecs = { workspace = true } bevy_app = { workspace = true } -bevy_asset = { workspace = true } -bevy_platform = { workspace = true } -bevy_input = { workspace = true, optional = true } -bevy_math = { workspace = true, features = ["curve"], optional = true } +bevy_asset = { workspace = true, features = ["std", "bevy_reflect"] } +bevy_platform = { workspace = true, features = ["std"] } +bevy_input = { workspace = true, optional = true, features = [ + "std", + "bevy_reflect", +] } +bevy_math = { workspace = true, features = [ + "std", + "rand", + "curve", +], optional = true } bevy_reflect = { workspace = true, features = [ "smol_str", "glam", @@ -40,8 +47,15 @@ bevy_reflect = { workspace = true, features = [ ], optional = true } uuid = { workspace = true, optional = true } smol_str = { workspace = true, optional = true } -bevy_time = { workspace = true, optional = true } -bevy_transform = { workspace = true, optional = true } +bevy_time = { workspace = true, optional = true, features = [ + "std", + "bevy_reflect", +] } +bevy_transform = { workspace = true, optional = true, features = [ + "bevy_reflect", + "std", + "bevy-support", +] } glam = { workspace = true, optional = true, features = ["serde", "std"] } From ec8ccf039cc0496995a49bde9ba6c4f9347011ff Mon Sep 17 00:00:00 2001 From: makspll Date: Sun, 24 Aug 2025 00:04:22 +0100 Subject: [PATCH 10/10] fix --- crates/bevy_mod_scripting_functions/Cargo.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/bevy_mod_scripting_functions/Cargo.toml b/crates/bevy_mod_scripting_functions/Cargo.toml index 75313f411f..734757010d 100644 --- a/crates/bevy_mod_scripting_functions/Cargo.toml +++ b/crates/bevy_mod_scripting_functions/Cargo.toml @@ -25,9 +25,9 @@ rhai_bindings = ["bevy_mod_scripting_rhai"] [dependencies] -bevy_ecs = { workspace = true } +bevy_ecs = { workspace = true, features = ["std", "bevy_reflect"] } bevy_app = { workspace = true } -bevy_asset = { workspace = true, features = ["std", "bevy_reflect"] } +bevy_asset = { workspace = true } bevy_platform = { workspace = true, features = ["std"] } bevy_input = { workspace = true, optional = true, features = [ "std",