feat: bevy 0.19 by makspll · Pull Request #547 · makspll/bevy_mod_scripting

makspll · 2026-07-29T15:38:48Z

Summary

Bumps bevy version, adds more codegen side tests, verifying our trait solving is working as expected via separate rustc plugin and crate

semanticdiff-com · 2026-07-29T15:38:51Z

Review changes with

Changed Files

File	Status
crates/bevy_mod_scripting_bindings/src/reference.rs	99% smaller
codegen/src/passes/find_trait_impls.rs	91% smaller
crates/bevy_mod_scripting_core/src/handler.rs	85% smaller
crates/bevy_mod_scripting_bindings/src/path/mod.rs	83% smaller
crates/bindings/bevy_picking_bms_bindings/src/lib.rs	78% smaller
crates/bindings/bevy_a11y_bms_bindings/src/lib.rs	74% smaller
crates/bindings/bevy_input_bms_bindings/src/lib.rs	72% smaller
crates/bindings/bevy_pbr_bms_bindings/src/lib.rs	71% smaller
crates/bevy_mod_scripting_display/src/printer/mod.rs	71% smaller
crates/bindings/bevy_ecs_bms_bindings/src/lib.rs	68% smaller
codegen/src/passes/populate_template_data.rs	66% smaller
crates/bevy_mod_scripting_bindings/src/world_extensions.rs	60% smaller
crates/bindings/bevy_animation_bms_bindings/src/lib.rs	60% smaller
crates/bevy_mod_scripting_core/src/commands.rs	57% smaller
examples/game_of_life.rs	51% smaller
crates/bindings/bevy_ui_render_bms_bindings/src/lib.rs	50% smaller
crates/bindings/bevy_camera_bms_bindings/src/lib.rs	48% smaller
codegen/src/bin/main.rs	43% smaller
crates/bindings/bevy_render_bms_bindings/src/lib.rs	43% smaller
crates/testing_crates/test_utils/src/test_data.rs	38% smaller
crates/bindings/bevy_sprite_render_bms_bindings/src/lib.rs	35% smaller
xtask/src/benches.rs	31% smaller
crates/bevy_mod_scripting_core/src/pipeline/mod.rs	30% smaller
crates/bevy_mod_scripting_world/src/world.rs	30% smaller
crates/bevy_mod_scripting_bindings/src/function/from_ref.rs	26% smaller
crates/testing_crates/script_integration_test_harness/src/scenario.rs	25% smaller
crates/bindings/bevy_gizmos_bms_bindings/src/lib.rs	25% smaller
crates/bindings/bevy_core_pipeline_bms_bindings/src/lib.rs	24% smaller
crates/bindings/bevy_light_bms_bindings/src/lib.rs	22% smaller
codegen/src/passes/find_methods_and_fields.rs	21% smaller
codegen/src/passes/cache_traits.rs	21% smaller
crates/bindings/bevy_image_bms_bindings/src/lib.rs	19% smaller
codegen/src/bin/driver.rs	16% smaller
crates/bindings/bevy_ui_bms_bindings/src/lib.rs	16% smaller
crates/bevy_mod_scripting_core/src/script_system.rs	15% smaller
codegen/crates/bevy_mod_scripting_rustc_driver/src/lib.rs	14% smaller
crates/bindings/bevy_scene_bms_bindings/src/lib.rs	13% smaller
codegen/crates/bevy_mod_scripting_rustc_driver/src/plugin.rs	11% smaller
crates/bindings/bevy_text_bms_bindings/src/lib.rs	8% smaller
crates/bindings/bevy_asset_bms_bindings/src/lib.rs	4% smaller
codegen/src/plugin.rs	2% smaller
crates/bindings/bevy_time_bms_bindings/src/lib.rs	2% smaller
codegen/src/candidate.rs	1% smaller
codegen/src/callback.rs	1% smaller
crates/bindings/bevy_post_process_bms_bindings/src/lib.rs	1% smaller
codegen/src/passes/find_reflect_types.rs	1% smaller
Cargo.toml	Unsupported file format
assets/scripts/game_of_life.lua	0% smaller
check.ps1	Unsupported file format
codegen/Cargo.bootstrap.toml	Unsupported file format
codegen/Cargo.toml	Unsupported file format
codegen/crates/bevy_mod_scripting_rustc_driver/Cargo.toml	Unsupported file format
codegen/crates/bevy_mod_scripting_rustc_driver/build.rs	0% smaller
codegen/crates/bevy_mod_scripting_rustc_driver/src/license	Unsupported file format
codegen/crates/bevy_mod_scripting_rustc_utils/Cargo.toml	Unsupported file format
codegen/crates/bevy_mod_scripting_rustc_utils/src/args.rs	0% smaller
codegen/crates/bevy_mod_scripting_rustc_utils/src/bin/driver.rs	0% smaller
codegen/crates/bevy_mod_scripting_rustc_utils/src/bin/main.rs	0% smaller
codegen/crates/bevy_mod_scripting_rustc_utils/src/emitter.rs	0% smaller
codegen/crates/bevy_mod_scripting_rustc_utils/src/lib.rs	0% smaller
codegen/crates/bevy_mod_scripting_rustc_utils/src/plugin.rs	0% smaller
codegen/crates/bevy_mod_scripting_rustc_utils/src/query.rs	0% smaller
codegen/crates/bevy_mod_scripting_rustc_utils/tests/integration_tests.rs	0% smaller
codegen/crates/crate_feature_graph/src/feature.rs	0% smaller
codegen/crates/test_crates/rust_lib_tests/Cargo.toml	Unsupported file format
codegen/crates/test_crates/rust_lib_tests/src/lib.rs	0% smaller
codegen/crates/test_crates/workspace/root/Cargo.toml	Unsupported file format
codegen/rust-toolchain.toml	Unsupported file format
codegen/src/args.rs	0% smaller
codegen/src/context.rs	0% smaller
codegen/src/lib.rs	0% smaller
codegen/src/modifying_file_loader.rs	0% smaller
crates/bevy_mod_scripting_bindings/src/reflection_extensions.rs	0% smaller
crates/bevy_mod_scripting_bindings/src/schedule.rs	0% smaller
crates/bevy_mod_scripting_core/src/extractors.rs	Unsupported file format
crates/bevy_system_reflection/src/lib.rs	0% smaller
crates/bindings/bevy_a11y_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_animation_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_app_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_app_bms_bindings/README.md	Unsupported file format
crates/bindings/bevy_app_bms_bindings/src/lib.rs	0% smaller
crates/bindings/bevy_asset_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_camera_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_color_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_color_bms_bindings/src/lib.rs	0% smaller
crates/bindings/bevy_core_pipeline_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_ecs_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_gizmos_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_gizmos_render_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_gizmos_render_bms_bindings/README.md	Unsupported file format
crates/bindings/bevy_gizmos_render_bms_bindings/src/lib.rs	0% smaller
crates/bindings/bevy_gltf_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_gltf_bms_bindings/src/lib.rs	0% smaller
crates/bindings/bevy_image_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_input_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_input_focus_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_input_focus_bms_bindings/src/lib.rs	0% smaller
crates/bindings/bevy_light_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_material_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_material_bms_bindings/README.md	Unsupported file format
crates/bindings/bevy_material_bms_bindings/src/lib.rs	0% smaller
crates/bindings/bevy_math_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_math_bms_bindings/src/lib.rs	0% smaller
crates/bindings/bevy_mesh_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_mesh_bms_bindings/src/lib.rs	0% smaller
crates/bindings/bevy_pbr_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_picking_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_post_process_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_reflect_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_reflect_bms_bindings/src/lib.rs	Unsupported file format
crates/bindings/bevy_render_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_scene_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_sprite_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_sprite_bms_bindings/src/lib.rs	0% smaller
crates/bindings/bevy_sprite_render_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_text_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_time_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_transform_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_transform_bms_bindings/src/lib.rs	0% smaller
crates/bindings/bevy_ui_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_ui_render_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_ui_widgets_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_ui_widgets_bms_bindings/README.md	Unsupported file format
crates/bindings/bevy_ui_widgets_bms_bindings/src/lib.rs	0% smaller
crates/bindings/bevy_world_serialization_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_world_serialization_bms_bindings/README.md	Unsupported file format
crates/bindings/bevy_world_serialization_bms_bindings/src/lib.rs	0% smaller
crates/lad_backends/lua_language_server_lad_backend/tests/example_ladfile/bindings.lua	0% smaller
crates/ladfile_builder/src/lib.rs	0% smaller
crates/testing_crates/script_integration_test_harness/src/lib.rs	0% smaller
examples/script_loading.rs	0% smaller
rust-toolchain.toml	Unsupported file format
xtask/Cargo.toml	Unsupported file format
xtask/test_assets/cargo_timings_cut.html	Unsupported file format

github-actions · 2026-07-29T16:03:03Z

🔍 Binding Differences Detected

The following changes were detected in generated bindings:

b/crates/bindings/bevy_a11y_bms_bindings/src/lib.rs

index 4491beb..02ccba3 100644
--- a/crates/bindings/bevy_a11y_bms_bindings/src/lib.rs
+++ b/crates/bindings/bevy_a11y_bms_bindings/src/lib.rs
@@ -1,18 +1,16 @@
-
 #![allow(clippy::all)]
 #![allow(unused, deprecated, dead_code)]
 extern crate std;



+use bevy_app::{App, Plugin};

+use bevy_ecs::prelude::*;

use bevy_mod_scripting_bindings::{

ReflectReference,

function::{


   from::{R, M, V},





   from::{M, R, V},
   namespace::NamespaceBuilder,

},

};

-use bevy_ecs::prelude::*;

-use bevy_app::{App, Plugin};

use bevy_mod_scripting_derive::script_bindings;

pub struct BevyA11YScriptingPlugin;

pub(crate) fn register_accessibility_requested_functions(world: &mut World) {

@@ -83,58 +81,53 @@ pub(crate) fn register_manage_accessibility_updates_functions(world: &mut World)

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_a11y::ManageAccessibilityUpdates,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_a11y::ManageAccessibilityUpdates>| {



           let output: V<::bevy_a11y::ManageAccessibilityUpdates> = {



               {



                   let output: V<::bevy_a11y::ManageAccessibilityUpdates> = <::bevy_a11y::ManageAccessibilityUpdates as ::core::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "get",



       |_self: R<::bevy_a11y::ManageAccessibilityUpdates>| {



           let output: bool = {



               {



                   let output: bool = ::bevy_a11y::ManageAccessibilityUpdates::get(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Returns `true` if Bevy's ECS should update the accessibility tree.",



       &["_self"],



   )



   .register_documented(



       "set",



       |mut _self: M<::bevy_a11y::ManageAccessibilityUpdates>, value: bool| {



           let output: () = {



               {



                   let output: () = ::bevy_a11y::ManageAccessibilityUpdates::set(



                           &mut _self,



                           value,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Sets whether Bevy's ECS should update the accessibility tree.",



       &["_self", "value"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_a11y::ManageAccessibilityUpdates>| {



       let output: V<::bevy_a11y::ManageAccessibilityUpdates> = {



           {



               let output: V<::bevy_a11y::ManageAccessibilityUpdates> =



                   <::bevy_a11y::ManageAccessibilityUpdates as ::core::clone::Clone>::clone(



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "get",



   |_self: R<::bevy_a11y::ManageAccessibilityUpdates>| {



       let output: bool = {



           {



               let output: bool = ::bevy_a11y::ManageAccessibilityUpdates::get(&_self).into();



               output



           }



       };



       output



   },



   " Returns `true` if Bevy's ECS should update the accessibility tree.",



   &["_self"],


)
.register_documented(

   "set",



   |mut _self: M<::bevy_a11y::ManageAccessibilityUpdates>, value: bool| {



       let output: () = {



           {



               let output: () =



                   ::bevy_a11y::ManageAccessibilityUpdates::set(&mut _self, value).into();



               output



           }



       };



       output



   },



   " Sets whether Bevy's ECS should update the accessibility tree.",



   &["_self", "value"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

b/crates/bindings/bevy_animation_bms_bindings/src/lib.rs

index 15c8369..cb7c515 100644
--- a/crates/bindings/bevy_animation_bms_bindings/src/lib.rs
+++ b/crates/bindings/bevy_animation_bms_bindings/src/lib.rs
@@ -1,41 +1,40 @@
-
 #![allow(clippy::all)]
 #![allow(unused, deprecated, dead_code)]
 extern crate std;



+use bevy_app::{App, Plugin};

+use bevy_ecs::prelude::*;

use bevy_mod_scripting_bindings::{

ReflectReference,

function::{


   from::{R, M, V},





   from::{M, R, V},
   namespace::NamespaceBuilder,

},

};

-use bevy_ecs::prelude::*;

-use bevy_app::{App, Plugin};

use bevy_mod_scripting_derive::script_bindings;

pub struct BevyAnimationScriptingPlugin;

pub(crate) fn register_animation_node_type_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_animation::graph::AnimationNodeType,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_animation::graph::AnimationNodeType>| {



           let output: V<::bevy_animation::graph::AnimationNodeType> = {



               {



                   let output: V<::bevy_animation::graph::AnimationNodeType> = <::bevy_animation::graph::AnimationNodeType as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_animation::graph::AnimationNodeType>| {



       let output: V<::bevy_animation::graph::AnimationNodeType> = {



           {



               let output: V<::bevy_animation::graph::AnimationNodeType> =



                   <::bevy_animation::graph::AnimationNodeType as ::std::clone::Clone>::clone(



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -126,58 +125,52 @@ pub(crate) fn register_animation_clip_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_animation::AnimationClip,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_animation::AnimationClip>| {



           let output: V<::bevy_animation::AnimationClip> = {



               {



                   let output: V<::bevy_animation::AnimationClip> = <::bevy_animation::AnimationClip as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "duration",



       |_self: R<::bevy_animation::AnimationClip>| {



           let output: f32 = {



               {



                   let output: f32 = ::bevy_animation::AnimationClip::duration(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Duration of the clip, represented in seconds.",



       &["_self"],



   )



   .register_documented(



       "set_duration",



       |mut _self: M<::bevy_animation::AnimationClip>, duration_sec: f32| {



           let output: () = {



               {



                   let output: () = ::bevy_animation::AnimationClip::set_duration(



                           &mut _self,



                           duration_sec,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Set the duration of the clip in seconds.",



       &["_self", "duration_sec"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_animation::AnimationClip>| {



       let output: V<::bevy_animation::AnimationClip> = {



           {



               let output: V<::bevy_animation::AnimationClip> =



                   <::bevy_animation::AnimationClip as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "duration",



   |_self: R<::bevy_animation::AnimationClip>| {



       let output: f32 = {



           {



               let output: f32 = ::bevy_animation::AnimationClip::duration(&_self).into();



               output



           }



       };



       output



   },



   " Duration of the clip, represented in seconds.",



   &["_self"],


)
.register_documented(

   "set_duration",



   |mut _self: M<::bevy_animation::AnimationClip>, duration_sec: f32| {



       let output: () = {



           {



               let output: () =



                   ::bevy_animation::AnimationClip::set_duration(&mut _self, duration_sec)



                       .into();



               output



           }



       };



       output



   },



   " Set the duration of the clip in seconds.",



   &["_self", "duration_sec"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -190,78 +183,70 @@ pub(crate) fn register_animation_player_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_animation::AnimationPlayer,

::new(world)





   .register_documented(



       "all_finished",



       |_self: R<::bevy_animation::AnimationPlayer>| {



           let output: bool = {



               {



                   let output: bool = ::bevy_animation::AnimationPlayer::all_finished(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Check if all playing animations have finished, according to the repetition behavior.",



       &["_self"],



   )



   .register_documented(



       "all_paused",



       |_self: R<::bevy_animation::AnimationPlayer>| {



           let output: bool = {



               {



                   let output: bool = ::bevy_animation::AnimationPlayer::all_paused(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Check if all playing animations are paused.",



       &["_self"],



   )



   .register_documented(



       "clone",



       |_self: R<::bevy_animation::AnimationPlayer>| {



           let output: V<::bevy_animation::AnimationPlayer> = {



               {



                   let output: V<::bevy_animation::AnimationPlayer> = <::bevy_animation::AnimationPlayer as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "clone_from",



       |



           mut _self: M<::bevy_animation::AnimationPlayer>,



           source: R<::bevy_animation::AnimationPlayer>|



       {



           let output: () = {



               {



                   let output: () = <::bevy_animation::AnimationPlayer as ::std::clone::Clone>::clone_from(



                           &mut _self,



                           &source,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "source"],



   );




.register_documented(

   "all_finished",



   |_self: R<::bevy_animation::AnimationPlayer>| {



       let output: bool = {



           {



               let output: bool =



                   ::bevy_animation::AnimationPlayer::all_finished(&_self).into();



               output



           }



       };



       output



   },



   " Check if all playing animations have finished, according to the repetition behavior.",



   &["_self"],


)
.register_documented(

   "all_paused",



   |_self: R<::bevy_animation::AnimationPlayer>| {



       let output: bool = {



           {



               let output: bool = ::bevy_animation::AnimationPlayer::all_paused(&_self).into();



               output



           }



       };



       output



   },



   " Check if all playing animations are paused.",



   &["_self"],


)
.register_documented(

   "clone",



   |_self: R<::bevy_animation::AnimationPlayer>| {



       let output: V<::bevy_animation::AnimationPlayer> = {



           {



               let output: V<::bevy_animation::AnimationPlayer> =



                   <::bevy_animation::AnimationPlayer as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "clone_from",



   |mut _self: M<::bevy_animation::AnimationPlayer>,



    source: R<::bevy_animation::AnimationPlayer>| {



       let output: () = {



           {



               let output: () =



                   <::bevy_animation::AnimationPlayer as ::std::clone::Clone>::clone_from(



                       &mut _self, &source,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "source"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -424,23 +409,21 @@ pub(crate) fn register_animated_by_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_animation::AnimatedBy,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_animation::AnimatedBy>| {



           let output: V<::bevy_animation::AnimatedBy> = {



               {



                   let output: V<::bevy_animation::AnimatedBy> = <::bevy_animation::AnimatedBy as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_animation::AnimatedBy>| {



       let output: V<::bevy_animation::AnimatedBy> = {



           {



               let output: V<::bevy_animation::AnimatedBy> =



                   <::bevy_animation::AnimatedBy as ::std::clone::Clone>::clone(&_self).into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

b/crates/bindings/bevy_app_bms_bindings/src/lib.rs

index 85fa5a5..9ffebff 100644
--- a/crates/bindings/bevy_app_bms_bindings/src/lib.rs
+++ b/crates/bindings/bevy_app_bms_bindings/src/lib.rs
@@ -1,18 +1,16 @@
-
 #![allow(clippy::all)]
 #![allow(unused, deprecated, dead_code)]
 extern crate std;



+use bevy_app::{App, Plugin};

+use bevy_ecs::prelude::*;

use bevy_mod_scripting_bindings::{

ReflectReference,

function::{


   from::{R, M, V},





   from::{M, R, V},
   namespace::NamespaceBuilder,

},

};

-use bevy_ecs::prelude::*;

-use bevy_app::{App, Plugin};

use bevy_mod_scripting_derive::script_bindings;

pub struct BevyAppScriptingPlugin;

pub(crate) fn register_app_exit_functions(world: &mut World) {

@@ -134,10 +132,7 @@ pub(crate) fn register_app_exit_functions(world: &mut World) {

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry



   .register_type_data::<



       ::bevy_app::AppExit,



       bevy_mod_scripting_bindings::MarkAsGenerated,



   >();





   .register_type_data::<::bevy_app::AppExit, bevy_mod_scripting_bindings::MarkAsGenerated>();



}

impl Plugin for BevyAppScriptingPlugin {

fn build(&self, app: &mut App) {

b/crates/bindings/bevy_asset_bms_bindings/src/lib.rs

index 5847d77..e5fe5fc 100644
--- a/crates/bindings/bevy_asset_bms_bindings/src/lib.rs
+++ b/crates/bindings/bevy_asset_bms_bindings/src/lib.rs
@@ -1,18 +1,16 @@
-
 #![allow(clippy::all)]
 #![allow(unused, deprecated, dead_code)]
 extern crate std;



+use bevy_app::{App, Plugin};

+use bevy_ecs::prelude::*;

use bevy_mod_scripting_bindings::{

ReflectReference,

function::{


   from::{R, M, V},





   from::{M, R, V},
   namespace::NamespaceBuilder,

},

};

-use bevy_ecs::prelude::*;

-use bevy_app::{App, Plugin};

use bevy_mod_scripting_derive::script_bindings;

pub struct BevyAssetScriptingPlugin;

pub(crate) fn register_untyped_handle_functions(world: &mut World) {

@@ -119,60 +117,54 @@ pub(crate) fn register_untyped_asset_id_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_asset::UntypedAssetId,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_asset::UntypedAssetId>| {



           let output: V<::bevy_asset::UntypedAssetId> = {



               {



                   let output: V<::bevy_asset::UntypedAssetId> = <::bevy_asset::UntypedAssetId as ::core::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: R<::bevy_asset::UntypedAssetId>,



           other: R<::bevy_asset::UntypedAssetId>|



       {



           let output: bool = {



               {



                   let output: bool = <::bevy_asset::UntypedAssetId as ::core::cmp::PartialEq<



                       ::bevy_asset::UntypedAssetId,



                   >>::eq(&_self, &other)



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   )



   .register_documented(



       "type_id",



       |_self: R<::bevy_asset::UntypedAssetId>| {



           let output: V<::core::any::TypeId> = {



               {



                   let output: V<::core::any::TypeId> = ::bevy_asset::UntypedAssetId::type_id(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Returns the stored [`TypeId`] of the referenced [`Asset`].",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_asset::UntypedAssetId>| {



       let output: V<::bevy_asset::UntypedAssetId> = {



           {



               let output: V<::bevy_asset::UntypedAssetId> =



                   <::bevy_asset::UntypedAssetId as ::core::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: R<::bevy_asset::UntypedAssetId>, other: R<::bevy_asset::UntypedAssetId>| {



       let output: bool = {



           {



               let output: bool = <::bevy_asset::UntypedAssetId as ::core::cmp::PartialEq<



                   ::bevy_asset::UntypedAssetId,



               >>::eq(&_self, &other)



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


)
.register_documented(

   "type_id",



   |_self: R<::bevy_asset::UntypedAssetId>| {



       let output: V<::core::any::TypeId> = {



           {



               let output: V<::core::any::TypeId> =



                   ::bevy_asset::UntypedAssetId::type_id(&_self).into();



               output



           }



       };



       output



   },



   " Returns the stored [`TypeId`] of the referenced [`Asset`].",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

b/crates/bindings/bevy_camera_bms_bindings/src/lib.rs

index ae4245b..a8003ff 100644
--- a/crates/bindings/bevy_camera_bms_bindings/src/lib.rs
+++ b/crates/bindings/bevy_camera_bms_bindings/src/lib.rs
@@ -1,18 +1,16 @@
-
 #![allow(clippy::all)]
 #![allow(unused, deprecated, dead_code)]
 extern crate std;



+use bevy_app::{App, Plugin};

+use bevy_ecs::prelude::*;

use bevy_mod_scripting_bindings::{

ReflectReference,

function::{


   from::{R, M, V},





   from::{M, R, V},
   namespace::NamespaceBuilder,

},

};

-use bevy_ecs::prelude::*;

-use bevy_app::{App, Plugin};

use bevy_mod_scripting_derive::script_bindings;

pub struct BevyCameraScriptingPlugin;

pub(crate) fn register_clear_color_functions(world: &mut World) {

@@ -466,10 +464,8 @@ pub(crate) fn register_camera_functions(world: &mut World) {

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry



   .register_type_data::<



       ::bevy_camera::Camera,



       bevy_mod_scripting_bindings::MarkAsGenerated,



   >();





   .register_type_data::<::bevy_camera::Camera, bevy_mod_scripting_bindings::MarkAsGenerated>(



   );



}

pub(crate) fn register_camera_2_d_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

@@ -533,23 +529,22 @@ pub(crate) fn register_clear_color_config_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::ClearColorConfig,

>::new(world)


   .register_documented(



       "clone",



       |_self: R<::bevy_camera::ClearColorConfig>| {



           let output: V<::bevy_camera::ClearColorConfig> = {



               {



                   let output: V<::bevy_camera::ClearColorConfig> = <::bevy_camera::ClearColorConfig as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::ClearColorConfig>| {



       let output: V<::bevy_camera::ClearColorConfig> = {



           {



               let output: V<::bevy_camera::ClearColorConfig> =



                   <::bevy_camera::ClearColorConfig as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -562,60 +557,57 @@ pub(crate) fn register_compositing_space_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::CompositingSpace,

::new(world)





   .register_documented(



       "assert_fields_are_eq",



       |_self: R<::bevy_camera::CompositingSpace>| {



           let output: () = {



               {



                   let output: () = <::bevy_camera::CompositingSpace as ::std::cmp::Eq>::assert_fields_are_eq(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "clone",



       |_self: R<::bevy_camera::CompositingSpace>| {



           let output: V<::bevy_camera::CompositingSpace> = {



               {



                   let output: V<::bevy_camera::CompositingSpace> = <::bevy_camera::CompositingSpace as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: R<::bevy_camera::CompositingSpace>,



           other: R<::bevy_camera::CompositingSpace>|



       {



           let output: bool = {



               {



                   let output: bool = <::bevy_camera::CompositingSpace as ::std::cmp::PartialEq<



                       ::bevy_camera::CompositingSpace,



                   >>::eq(&_self, &other)



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   );




.register_documented(

   "assert_fields_are_eq",



   |_self: R<::bevy_camera::CompositingSpace>| {



       let output: () = {



           {



               let output: () =



                   <::bevy_camera::CompositingSpace as ::std::cmp::Eq>::assert_fields_are_eq(



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "clone",



   |_self: R<::bevy_camera::CompositingSpace>| {



       let output: V<::bevy_camera::CompositingSpace> = {



           {



               let output: V<::bevy_camera::CompositingSpace> =



                   <::bevy_camera::CompositingSpace as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: R<::bevy_camera::CompositingSpace>, other: R<::bevy_camera::CompositingSpace>| {



       let output: bool = {



           {



               let output: bool = <::bevy_camera::CompositingSpace as ::std::cmp::PartialEq<



                   ::bevy_camera::CompositingSpace,



               >>::eq(&_self, &other)



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -628,60 +620,56 @@ pub(crate) fn register_msaa_writeback_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::MsaaWriteback,

::new(world)





   .register_documented(



       "assert_fields_are_eq",



       |_self: R<::bevy_camera::MsaaWriteback>| {



           let output: () = {



               {



                   let output: () = <::bevy_camera::MsaaWriteback as ::std::cmp::Eq>::assert_fields_are_eq(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "clone",



       |_self: R<::bevy_camera::MsaaWriteback>| {



           let output: V<::bevy_camera::MsaaWriteback> = {



               {



                   let output: V<::bevy_camera::MsaaWriteback> = <::bevy_camera::MsaaWriteback as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: R<::bevy_camera::MsaaWriteback>,



           other: R<::bevy_camera::MsaaWriteback>|



       {



           let output: bool = {



               {



                   let output: bool = <::bevy_camera::MsaaWriteback as ::std::cmp::PartialEq<



                       ::bevy_camera::MsaaWriteback,



                   >>::eq(&_self, &other)



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   );




.register_documented(

   "assert_fields_are_eq",



   |_self: R<::bevy_camera::MsaaWriteback>| {



       let output: () = {



           {



               let output: () =



                   <::bevy_camera::MsaaWriteback as ::std::cmp::Eq>::assert_fields_are_eq(



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "clone",



   |_self: R<::bevy_camera::MsaaWriteback>| {



       let output: V<::bevy_camera::MsaaWriteback> = {



           {



               let output: V<::bevy_camera::MsaaWriteback> =



                   <::bevy_camera::MsaaWriteback as ::std::clone::Clone>::clone(&_self).into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: R<::bevy_camera::MsaaWriteback>, other: R<::bevy_camera::MsaaWriteback>| {



       let output: bool = {



           {



               let output: bool = <::bevy_camera::MsaaWriteback as ::std::cmp::PartialEq<



                   ::bevy_camera::MsaaWriteback,



               >>::eq(&_self, &other)



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -753,23 +741,24 @@ pub(crate) fn register_perspective_projection_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::PerspectiveProjection,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::PerspectiveProjection>| {



           let output: V<::bevy_camera::PerspectiveProjection> = {



               {



                   let output: V<::bevy_camera::PerspectiveProjection> = <::bevy_camera::PerspectiveProjection as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::PerspectiveProjection>| {



       let output: V<::bevy_camera::PerspectiveProjection> = {



           {



               let output: V<::bevy_camera::PerspectiveProjection> =



                   <::bevy_camera::PerspectiveProjection as ::std::clone::Clone>::clone(



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -972,126 +961,115 @@ pub(crate) fn register_visible_entities_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::visibility::VisibleEntities,

::new(world)





   .register_documented(



       "clear",



       |



           mut _self: M<::bevy_camera::visibility::VisibleEntities>,



           type_id: V<::std::any::TypeId>|



       {



           let output: () = {



               {



                   let output: () = ::bevy_camera::visibility::VisibleEntities::clear(



                           &mut _self,



                           type_id.into_inner(),



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "type_id"],



   )



   .register_documented(



       "clear_all",



       |mut _self: M<::bevy_camera::visibility::VisibleEntities>| {



           let output: () = {



               {



                   let output: () = ::bevy_camera::visibility::VisibleEntities::clear_all(



                           &mut _self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "clone",



       |_self: R<::bevy_camera::visibility::VisibleEntities>| {



           let output: V<::bevy_camera::visibility::VisibleEntities> = {



               {



                   let output: V<::bevy_camera::visibility::VisibleEntities> = <::bevy_camera::visibility::VisibleEntities as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "is_empty",



       |



           _self: R<::bevy_camera::visibility::VisibleEntities>,



           type_id: V<::std::any::TypeId>|



       {



           let output: bool = {



               {



                   let output: bool = ::bevy_camera::visibility::VisibleEntities::is_empty(



                           &_self,



                           type_id.into_inner(),



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "type_id"],



   )



   .register_documented(



       "len",



       |



           _self: R<::bevy_camera::visibility::VisibleEntities>,



           type_id: V<::std::any::TypeId>|



       {



           let output: usize = {



               {



                   let output: usize = ::bevy_camera::visibility::VisibleEntities::len(



                           &_self,



                           type_id.into_inner(),



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "type_id"],



   )



   .register_documented(



       "push",



       |



           mut _self: M<::bevy_camera::visibility::VisibleEntities>,



           entity: V<::bevy_ecs::entity::Entity>,



           type_id: V<::std::any::TypeId>|



       {



           let output: () = {



               {



                   let output: () = ::bevy_camera::visibility::VisibleEntities::push(



                           &mut _self,



                           entity.into_inner(),



                           type_id.into_inner(),



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "entity", "type_id"],



   );




.register_documented(

   "clear",



   |mut _self: M<::bevy_camera::visibility::VisibleEntities>,



    type_id: V<::std::any::TypeId>| {



       let output: () = {



           {



               let output: () = ::bevy_camera::visibility::VisibleEntities::clear(



                   &mut _self,



                   type_id.into_inner(),



               )



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "type_id"],


)
.register_documented(

   "clear_all",



   |mut _self: M<::bevy_camera::visibility::VisibleEntities>| {



       let output: () = {



           {



               let output: () =



                   ::bevy_camera::visibility::VisibleEntities::clear_all(&mut _self).into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "clone",



   |_self: R<::bevy_camera::visibility::VisibleEntities>| {



       let output: V<::bevy_camera::visibility::VisibleEntities> = {



           {



               let output: V<::bevy_camera::visibility::VisibleEntities> =



                   <::bevy_camera::visibility::VisibleEntities as ::std::clone::Clone>::clone(



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "is_empty",



   |_self: R<::bevy_camera::visibility::VisibleEntities>, type_id: V<::std::any::TypeId>| {



       let output: bool = {



           {



               let output: bool = ::bevy_camera::visibility::VisibleEntities::is_empty(



                   &_self,



                   type_id.into_inner(),



               )



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "type_id"],


)
.register_documented(

   "len",



   |_self: R<::bevy_camera::visibility::VisibleEntities>, type_id: V<::std::any::TypeId>| {



       let output: usize = {



           {



               let output: usize = ::bevy_camera::visibility::VisibleEntities::len(



                   &_self,



                   type_id.into_inner(),



               )



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "type_id"],


)
.register_documented(

   "push",



   |mut _self: M<::bevy_camera::visibility::VisibleEntities>,



    entity: V<::bevy_ecs::entity::Entity>,



    type_id: V<::std::any::TypeId>| {



       let output: () = {



           {



               let output: () = ::bevy_camera::visibility::VisibleEntities::push(



                   &mut _self,



                   entity.into_inner(),



                   type_id.into_inner(),



               )



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "entity", "type_id"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1163,43 +1141,38 @@ pub(crate) fn register_sub_camera_view_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::SubCameraView,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::SubCameraView>| {



           let output: V<::bevy_camera::SubCameraView> = {



               {



                   let output: V<::bevy_camera::SubCameraView> = <::bevy_camera::SubCameraView as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: R<::bevy_camera::SubCameraView>,



           other: R<::bevy_camera::SubCameraView>|



       {



           let output: bool = {



               {



                   let output: bool = <::bevy_camera::SubCameraView as ::std::cmp::PartialEq<



                       ::bevy_camera::SubCameraView,



                   >>::eq(&_self, &other)



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::SubCameraView>| {



       let output: V<::bevy_camera::SubCameraView> = {



           {



               let output: V<::bevy_camera::SubCameraView> =



                   <::bevy_camera::SubCameraView as ::std::clone::Clone>::clone(&_self).into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: R<::bevy_camera::SubCameraView>, other: R<::bevy_camera::SubCameraView>| {



       let output: bool = {



           {



               let output: bool = <::bevy_camera::SubCameraView as ::std::cmp::PartialEq<



                   ::bevy_camera::SubCameraView,



               >>::eq(&_self, &other)



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1212,23 +1185,22 @@ pub(crate) fn register_render_target_info_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::RenderTargetInfo,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::RenderTargetInfo>| {



           let output: V<::bevy_camera::RenderTargetInfo> = {



               {



                   let output: V<::bevy_camera::RenderTargetInfo> = <::bevy_camera::RenderTargetInfo as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::RenderTargetInfo>| {



       let output: V<::bevy_camera::RenderTargetInfo> = {



           {



               let output: V<::bevy_camera::RenderTargetInfo> =



                   <::bevy_camera::RenderTargetInfo as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1241,23 +1213,22 @@ pub(crate) fn register_computed_camera_values_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::ComputedCameraValues,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::ComputedCameraValues>| {



           let output: V<::bevy_camera::ComputedCameraValues> = {



               {



                   let output: V<::bevy_camera::ComputedCameraValues> = <::bevy_camera::ComputedCameraValues as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::ComputedCameraValues>| {



       let output: V<::bevy_camera::ComputedCameraValues> = {



           {



               let output: V<::bevy_camera::ComputedCameraValues> =



                   <::bevy_camera::ComputedCameraValues as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1314,23 +1285,24 @@ pub(crate) fn register_camera_main_texture_usages_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::CameraMainTextureUsages,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::CameraMainTextureUsages>| {



           let output: V<::bevy_camera::CameraMainTextureUsages> = {



               {



                   let output: V<::bevy_camera::CameraMainTextureUsages> = <::bevy_camera::CameraMainTextureUsages as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::CameraMainTextureUsages>| {



       let output: V<::bevy_camera::CameraMainTextureUsages> = {



           {



               let output: V<::bevy_camera::CameraMainTextureUsages> =



                   <::bevy_camera::CameraMainTextureUsages as ::std::clone::Clone>::clone(



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1372,23 +1344,22 @@ pub(crate) fn register_camera_output_mode_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::CameraOutputMode,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::CameraOutputMode>| {



           let output: V<::bevy_camera::CameraOutputMode> = {



               {



                   let output: V<::bevy_camera::CameraOutputMode> = <::bevy_camera::CameraOutputMode as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::CameraOutputMode>| {



       let output: V<::bevy_camera::CameraOutputMode> = {



           {



               let output: V<::bevy_camera::CameraOutputMode> =



                   <::bevy_camera::CameraOutputMode as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1401,23 +1372,22 @@ pub(crate) fn register_shadow_lod_origin_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::ShadowLodOrigin,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::ShadowLodOrigin>| {



           let output: V<::bevy_camera::ShadowLodOrigin> = {



               {



                   let output: V<::bevy_camera::ShadowLodOrigin> = <::bevy_camera::ShadowLodOrigin as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::ShadowLodOrigin>| {



       let output: V<::bevy_camera::ShadowLodOrigin> = {



           {



               let output: V<::bevy_camera::ShadowLodOrigin> =



                   <::bevy_camera::ShadowLodOrigin as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1430,43 +1400,40 @@ pub(crate) fn register_image_render_target_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::ImageRenderTarget,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::ImageRenderTarget>| {



           let output: V<::bevy_camera::ImageRenderTarget> = {



               {



                   let output: V<::bevy_camera::ImageRenderTarget> = <::bevy_camera::ImageRenderTarget as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: R<::bevy_camera::ImageRenderTarget>,



           other: R<::bevy_camera::ImageRenderTarget>|



       {



           let output: bool = {



               {



                   let output: bool = <::bevy_camera::ImageRenderTarget as ::std::cmp::PartialEq<




.register_documented(

   "clone",



   |_self: R<::bevy_camera::ImageRenderTarget>| {



       let output: V<::bevy_camera::ImageRenderTarget> = {



           {



               let output: V<::bevy_camera::ImageRenderTarget> =



                   <::bevy_camera::ImageRenderTarget as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: R<::bevy_camera::ImageRenderTarget>, other: R<::bevy_camera::ImageRenderTarget>| {



       let output: bool = {



           {



               let output: bool =



                   <::bevy_camera::ImageRenderTarget as ::std::cmp::PartialEq<
                       ::bevy_camera::ImageRenderTarget,
                   >>::eq(&_self, &other)





                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   );





                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1611,23 +1578,22 @@ pub(crate) fn register_camera_3_d_depth_load_op_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::Camera3dDepthLoadOp,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::Camera3dDepthLoadOp>| {



           let output: V<::bevy_camera::Camera3dDepthLoadOp> = {



               {



                   let output: V<::bevy_camera::Camera3dDepthLoadOp> = <::bevy_camera::Camera3dDepthLoadOp as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::Camera3dDepthLoadOp>| {



       let output: V<::bevy_camera::Camera3dDepthLoadOp> = {



           {



               let output: V<::bevy_camera::Camera3dDepthLoadOp> =



                   <::bevy_camera::Camera3dDepthLoadOp as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1640,23 +1606,24 @@ pub(crate) fn register_camera_3_d_depth_texture_usage_functions(world: &mut Worl

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::Camera3dDepthTextureUsage,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::Camera3dDepthTextureUsage>| {



           let output: V<::bevy_camera::Camera3dDepthTextureUsage> = {



               {



                   let output: V<::bevy_camera::Camera3dDepthTextureUsage> = <::bevy_camera::Camera3dDepthTextureUsage as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::Camera3dDepthTextureUsage>| {



       let output: V<::bevy_camera::Camera3dDepthTextureUsage> = {



           {



               let output: V<::bevy_camera::Camera3dDepthTextureUsage> =



                   <::bevy_camera::Camera3dDepthTextureUsage as ::std::clone::Clone>::clone(



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1666,67 +1633,60 @@ pub(crate) fn register_camera_3_d_depth_texture_usage_functions(world: &mut Worl

>();

}

pub(crate) fn register_hdr_functions(world: &mut World) {


bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

   ::bevy_camera::Hdr,




::new(world)



   .register_documented(



       "assert_fields_are_eq",



       |_self: R<::bevy_camera::Hdr>| {



           let output: () = {



               {



                   let output: () = <::bevy_camera::Hdr as ::std::cmp::Eq>::assert_fields_are_eq(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "clone",



       |_self: R<::bevy_camera::Hdr>| {



           let output: V<::bevy_camera::Hdr> = {



               {



                   let output: V<::bevy_camera::Hdr> = <::bevy_camera::Hdr as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |_self: R<::bevy_camera::Hdr>, other: R<::bevy_camera::Hdr>| {



           let output: bool = {



               {



                   let output: bool = <::bevy_camera::Hdr as ::std::cmp::PartialEq<



                       ::bevy_camera::Hdr,



                   >>::eq(&_self, &other)



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   );




bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<::bevy_camera::Hdr>::new(

   world,


)
.register_documented(

   "assert_fields_are_eq",



   |_self: R<::bevy_camera::Hdr>| {



       let output: () = {



           {



               let output: () =



                   <::bevy_camera::Hdr as ::std::cmp::Eq>::assert_fields_are_eq(&_self).into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "clone",



   |_self: R<::bevy_camera::Hdr>| {



       let output: V<::bevy_camera::Hdr> = {



           {



               let output: V<::bevy_camera::Hdr> =



                   <::bevy_camera::Hdr as ::std::clone::Clone>::clone(&_self).into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: R<::bevy_camera::Hdr>, other: R<::bevy_camera::Hdr>| {



       let output: bool = {



           {



               let output: bool = <::bevy_camera::Hdr as ::std::cmp::PartialEq<



                   ::bevy_camera::Hdr,



               >>::eq(&_self, &other)



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry



   .register_type_data::<



       ::bevy_camera::Hdr,



       bevy_mod_scripting_bindings::MarkAsGenerated,



   >();





   .register_type_data::<::bevy_camera::Hdr, bevy_mod_scripting_bindings::MarkAsGenerated>();



}

pub(crate) fn register_aabb_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

@@ -1952,23 +1912,24 @@ pub(crate) fn register_cubemap_frusta_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::primitives::CubemapFrusta,

>::new(world)


   .register_documented(



       "clone",



       |_self: R<::bevy_camera::primitives::CubemapFrusta>| {



           let output: V<::bevy_camera::primitives::CubemapFrusta> = {



               {



                   let output: V<::bevy_camera::primitives::CubemapFrusta> = <::bevy_camera::primitives::CubemapFrusta as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::primitives::CubemapFrusta>| {



       let output: V<::bevy_camera::primitives::CubemapFrusta> = {



           {



               let output: V<::bevy_camera::primitives::CubemapFrusta> =



                   <::bevy_camera::primitives::CubemapFrusta as ::std::clone::Clone>::clone(



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1981,23 +1942,24 @@ pub(crate) fn register_cub...[Comment body truncated]

github-actions · 2026-07-29T17:35:21Z

🔍 Binding Differences Detected

The following changes were detected in generated bindings:

b/crates/bindings/bevy_a11y_bms_bindings/src/lib.rs

index a5999d7..401a7a3 100644
--- a/crates/bindings/bevy_a11y_bms_bindings/src/lib.rs
+++ b/crates/bindings/bevy_a11y_bms_bindings/src/lib.rs
@@ -1,18 +1,16 @@
-
 #![allow(clippy::all)]
 #![allow(unused, deprecated, dead_code)]
 extern crate std;



+use bevy_app::{App, Plugin};

+use bevy_ecs::prelude::*;

use bevy_mod_scripting_bindings::{

ReflectReference,

function::{


   from::{R, M, V},





   from::{M, R, V},
   namespace::NamespaceBuilder,

},

};

-use bevy_ecs::prelude::*;

-use bevy_app::{App, Plugin};

use bevy_mod_scripting_derive::script_bindings;

pub struct BevyA11YScriptingPlugin;

pub(crate) fn register_accessibility_requested_functions(world: &mut World) {

@@ -83,58 +81,53 @@ pub(crate) fn register_manage_accessibility_updates_functions(world: &mut World)

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_a11y::ManageAccessibilityUpdates,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_a11y::ManageAccessibilityUpdates>| {



           let output: V<::bevy_a11y::ManageAccessibilityUpdates> = {



               {



                   let output: V<::bevy_a11y::ManageAccessibilityUpdates> = <::bevy_a11y::ManageAccessibilityUpdates as ::core::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "get",



       |_self: R<::bevy_a11y::ManageAccessibilityUpdates>| {



           let output: bool = {



               {



                   let output: bool = ::bevy_a11y::ManageAccessibilityUpdates::get(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Returns `true` if Bevy's ECS should update the accessibility tree.",



       &["_self"],



   )



   .register_documented(



       "set",



       |mut _self: M<::bevy_a11y::ManageAccessibilityUpdates>, value: bool| {



           let output: () = {



               {



                   let output: () = ::bevy_a11y::ManageAccessibilityUpdates::set(



                           &mut _self,



                           value,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Sets whether Bevy's ECS should update the accessibility tree.",



       &["_self", "value"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_a11y::ManageAccessibilityUpdates>| {



       let output: V<::bevy_a11y::ManageAccessibilityUpdates> = {



           {



               let output: V<::bevy_a11y::ManageAccessibilityUpdates> =



                   <::bevy_a11y::ManageAccessibilityUpdates as ::core::clone::Clone>::clone(



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "get",



   |_self: R<::bevy_a11y::ManageAccessibilityUpdates>| {



       let output: bool = {



           {



               let output: bool = ::bevy_a11y::ManageAccessibilityUpdates::get(&_self).into();



               output



           }



       };



       output



   },



   " Returns `true` if Bevy's ECS should update the accessibility tree.",



   &["_self"],


)
.register_documented(

   "set",



   |mut _self: M<::bevy_a11y::ManageAccessibilityUpdates>, value: bool| {



       let output: () = {



           {



               let output: () =



                   ::bevy_a11y::ManageAccessibilityUpdates::set(&mut _self, value).into();



               output



           }



       };



       output



   },



   " Sets whether Bevy's ECS should update the accessibility tree.",



   &["_self", "value"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -147,43 +140,41 @@ pub(crate) fn register_accessibility_systems_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_a11y::AccessibilitySystems,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_a11y::AccessibilitySystems>| {



           let output: V<::bevy_a11y::AccessibilitySystems> = {



               {



                   let output: V<::bevy_a11y::AccessibilitySystems> = <::bevy_a11y::AccessibilitySystems as ::core::clone::Clone>::clone(



                           &_self,



                       )




.register_documented(

   "clone",



   |_self: R<::bevy_a11y::AccessibilitySystems>| {



       let output: V<::bevy_a11y::AccessibilitySystems> = {



           {



               let output: V<::bevy_a11y::AccessibilitySystems> =



                   <::bevy_a11y::AccessibilitySystems as ::core::clone::Clone>::clone(&_self)
                       .into();





                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: R<::bevy_a11y::AccessibilitySystems>,



           other: R<::bevy_a11y::AccessibilitySystems>|



       {



           let output: bool = {



               {



                   let output: bool = <::bevy_a11y::AccessibilitySystems as ::core::cmp::PartialEq<





               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: R<::bevy_a11y::AccessibilitySystems>,



    other: R<::bevy_a11y::AccessibilitySystems>| {



       let output: bool = {



           {



               let output: bool =



                   <::bevy_a11y::AccessibilitySystems as ::core::cmp::PartialEq<
                       ::bevy_a11y::AccessibilitySystems,
                   >>::eq(&_self, &other)





                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   );





                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

b/crates/bindings/bevy_animation_bms_bindings/src/lib.rs

index 67d1564..c823e14 100644
--- a/crates/bindings/bevy_animation_bms_bindings/src/lib.rs
+++ b/crates/bindings/bevy_animation_bms_bindings/src/lib.rs
@@ -1,41 +1,40 @@
-
 #![allow(clippy::all)]
 #![allow(unused, deprecated, dead_code)]
 extern crate std;



+use bevy_app::{App, Plugin};

+use bevy_ecs::prelude::*;

use bevy_mod_scripting_bindings::{

ReflectReference,

function::{


   from::{R, M, V},





   from::{M, R, V},
   namespace::NamespaceBuilder,

},

};

-use bevy_ecs::prelude::*;

-use bevy_app::{App, Plugin};

use bevy_mod_scripting_derive::script_bindings;

pub struct BevyAnimationScriptingPlugin;

pub(crate) fn register_animation_node_type_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_animation::graph::AnimationNodeType,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_animation::graph::AnimationNodeType>| {



           let output: V<::bevy_animation::graph::AnimationNodeType> = {



               {



                   let output: V<::bevy_animation::graph::AnimationNodeType> = <::bevy_animation::graph::AnimationNodeType as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_animation::graph::AnimationNodeType>| {



       let output: V<::bevy_animation::graph::AnimationNodeType> = {



           {



               let output: V<::bevy_animation::graph::AnimationNodeType> =



                   <::bevy_animation::graph::AnimationNodeType as ::std::clone::Clone>::clone(



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -109,58 +108,52 @@ pub(crate) fn register_animation_clip_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_animation::AnimationClip,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_animation::AnimationClip>| {



           let output: V<::bevy_animation::AnimationClip> = {



               {



                   let output: V<::bevy_animation::AnimationClip> = <::bevy_animation::AnimationClip as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "duration",



       |_self: R<::bevy_animation::AnimationClip>| {



           let output: f32 = {



               {



                   let output: f32 = ::bevy_animation::AnimationClip::duration(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Duration of the clip, represented in seconds.",



       &["_self"],



   )



   .register_documented(



       "set_duration",



       |mut _self: M<::bevy_animation::AnimationClip>, duration_sec: f32| {



           let output: () = {



               {



                   let output: () = ::bevy_animation::AnimationClip::set_duration(



                           &mut _self,



                           duration_sec,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Set the duration of the clip in seconds.",



       &["_self", "duration_sec"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_animation::AnimationClip>| {



       let output: V<::bevy_animation::AnimationClip> = {



           {



               let output: V<::bevy_animation::AnimationClip> =



                   <::bevy_animation::AnimationClip as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "duration",



   |_self: R<::bevy_animation::AnimationClip>| {



       let output: f32 = {



           {



               let output: f32 = ::bevy_animation::AnimationClip::duration(&_self).into();



               output



           }



       };



       output



   },



   " Duration of the clip, represented in seconds.",



   &["_self"],


)
.register_documented(

   "set_duration",



   |mut _self: M<::bevy_animation::AnimationClip>, duration_sec: f32| {



       let output: () = {



           {



               let output: () =



                   ::bevy_animation::AnimationClip::set_duration(&mut _self, duration_sec)



                       .into();



               output



           }



       };



       output



   },



   " Set the duration of the clip in seconds.",



   &["_self", "duration_sec"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -173,78 +166,70 @@ pub(crate) fn register_animation_player_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_animation::AnimationPlayer,

::new(world)





   .register_documented(



       "all_finished",



       |_self: R<::bevy_animation::AnimationPlayer>| {



           let output: bool = {



               {



                   let output: bool = ::bevy_animation::AnimationPlayer::all_finished(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Check if all playing animations have finished, according to the repetition behavior.",



       &["_self"],



   )



   .register_documented(



       "all_paused",



       |_self: R<::bevy_animation::AnimationPlayer>| {



           let output: bool = {



               {



                   let output: bool = ::bevy_animation::AnimationPlayer::all_paused(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Check if all playing animations are paused.",



       &["_self"],



   )



   .register_documented(



       "clone",



       |_self: R<::bevy_animation::AnimationPlayer>| {



           let output: V<::bevy_animation::AnimationPlayer> = {



               {



                   let output: V<::bevy_animation::AnimationPlayer> = <::bevy_animation::AnimationPlayer as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "clone_from",



       |



           mut _self: M<::bevy_animation::AnimationPlayer>,



           source: R<::bevy_animation::AnimationPlayer>|



       {



           let output: () = {



               {



                   let output: () = <::bevy_animation::AnimationPlayer as ::std::clone::Clone>::clone_from(



                           &mut _self,



                           &source,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "source"],



   );




.register_documented(

   "all_finished",



   |_self: R<::bevy_animation::AnimationPlayer>| {



       let output: bool = {



           {



               let output: bool =



                   ::bevy_animation::AnimationPlayer::all_finished(&_self).into();



               output



           }



       };



       output



   },



   " Check if all playing animations have finished, according to the repetition behavior.",



   &["_self"],


)
.register_documented(

   "all_paused",



   |_self: R<::bevy_animation::AnimationPlayer>| {



       let output: bool = {



           {



               let output: bool = ::bevy_animation::AnimationPlayer::all_paused(&_self).into();



               output



           }



       };



       output



   },



   " Check if all playing animations are paused.",



   &["_self"],


)
.register_documented(

   "clone",



   |_self: R<::bevy_animation::AnimationPlayer>| {



       let output: V<::bevy_animation::AnimationPlayer> = {



           {



               let output: V<::bevy_animation::AnimationPlayer> =



                   <::bevy_animation::AnimationPlayer as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "clone_from",



   |mut _self: M<::bevy_animation::AnimationPlayer>,



    source: R<::bevy_animation::AnimationPlayer>| {



       let output: () = {



           {



               let output: () =



                   <::bevy_animation::AnimationPlayer as ::std::clone::Clone>::clone_from(



                       &mut _self, &source,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "source"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -324,60 +309,56 @@ pub(crate) fn register_animation_target_id_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_animation::AnimationTargetId,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_animation::AnimationTargetId>| {



           let output: V<::bevy_animation::AnimationTargetId> = {



               {



                   let output: V<::bevy_animation::AnimationTargetId> = <::bevy_animation::AnimationTargetId as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: R<::bevy_animation::AnimationTargetId>,



           other: R<::bevy_animation::AnimationTargetId>|



       {



           let output: bool = {



               {



                   let output: bool = <::bevy_animation::AnimationTargetId as ::std::cmp::PartialEq<




.register_documented(

   "clone",



   |_self: R<::bevy_animation::AnimationTargetId>| {



       let output: V<::bevy_animation::AnimationTargetId> = {



           {



               let output: V<::bevy_animation::AnimationTargetId> =



                   <::bevy_animation::AnimationTargetId as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: R<::bevy_animation::AnimationTargetId>,



    other: R<::bevy_animation::AnimationTargetId>| {



       let output: bool = {



           {



               let output: bool =



                   <::bevy_animation::AnimationTargetId as ::std::cmp::PartialEq<
                       ::bevy_animation::AnimationTargetId,
                   >>::eq(&_self, &other)





                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   )



   .register_documented(



       "from_name",



       |name: R<::bevy_ecs::name::Name>| {



           let output: V<::bevy_animation::AnimationTargetId> = {



               {



                   let output: V<::bevy_animation::AnimationTargetId> = ::bevy_animation::AnimationTargetId::from_name(



                           &name,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Creates a new [`AnimationTargetId`] by hashing a single name.",



       &["name"],



   );





                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


)
.register_documented(

   "from_name",



   |name: R<::bevy_ecs::name::Name>| {



       let output: V<::bevy_animation::AnimationTargetId> = {



           {



               let output: V<::bevy_animation::AnimationTargetId> =



                   ::bevy_animation::AnimationTargetId::from_name(&name).into();



               output



           }



       };



       output



   },



   " Creates a new [`AnimationTargetId`] by hashing a single name.",



   &["name"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -390,23 +371,21 @@ pub(crate) fn register_animated_by_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_animation::AnimatedBy,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_animation::AnimatedBy>| {



           let output: V<::bevy_animation::AnimatedBy> = {



               {



                   let output: V<::bevy_animation::AnimatedBy> = <::bevy_animation::AnimatedBy as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_animation::AnimatedBy>| {



       let output: V<::bevy_animation::AnimatedBy> = {



           {



               let output: V<::bevy_animation::AnimatedBy> =



                   <::bevy_animation::AnimatedBy as ::std::clone::Clone>::clone(&_self).into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -419,43 +398,41 @@ pub(crate) fn register_repeat_animation_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_animation::RepeatAnimation,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_animation::RepeatAnimation>| {



           let output: V<::bevy_animation::RepeatAnimation> = {



               {



                   let output: V<::bevy_animation::RepeatAnimation> = <::bevy_animation::RepeatAnimation as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: R<::bevy_animation::RepeatAnimation>,



           other: R<::bevy_animation::RepeatAnimation>|



       {



           let output: bool = {



               {



                   let output: bool = <::bevy_animation::RepeatAnimation as ::std::cmp::PartialEq<




.register_documented(

   "clone",



   |_self: R<::bevy_animation::RepeatAnimation>| {



       let output: V<::bevy_animation::RepeatAnimation> = {



           {



               let output: V<::bevy_animation::RepeatAnimation> =



                   <::bevy_animation::RepeatAnimation as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: R<::bevy_animation::RepeatAnimation>,



    other: R<::bevy_animation::RepeatAnimation>| {



       let output: bool = {



           {



               let output: bool =



                   <::bevy_animation::RepeatAnimation as ::std::cmp::PartialEq<
                       ::bevy_animation::RepeatAnimation,
                   >>::eq(&_self, &other)





                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   );





                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

b/crates/bindings/bevy_app_bms_bindings/src/lib.rs

index b9a5a09..ff722e7 100644
--- a/crates/bindings/bevy_app_bms_bindings/src/lib.rs
+++ b/crates/bindings/bevy_app_bms_bindings/src/lib.rs
@@ -1,18 +1,16 @@
-
 #![allow(clippy::all)]
 #![allow(unused, deprecated, dead_code)]
 extern crate std;



+use bevy_app::{App, Plugin};

+use bevy_ecs::prelude::*;

use bevy_mod_scripting_bindings::{

ReflectReference,

function::{


   from::{R, M, V},





   from::{M, R, V},
   namespace::NamespaceBuilder,

},

};

-use bevy_ecs::prelude::*;

-use bevy_app::{App, Plugin};

use bevy_mod_scripting_derive::script_bindings;

pub struct BevyAppScriptingPlugin;

pub(crate) fn register_app_exit_functions(world: &mut World) {

@@ -117,10 +115,7 @@ pub(crate) fn register_app_exit_functions(world: &mut World) {

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry



   .register_type_data::<



       ::bevy_app::AppExit,



       bevy_mod_scripting_bindings::MarkAsGenerated,



   >();





   .register_type_data::<::bevy_app::AppExit, bevy_mod_scripting_bindings::MarkAsGenerated>();



}

impl Plugin for BevyAppScriptingPlugin {

fn build(&self, app: &mut App) {

b/crates/bindings/bevy_asset_bms_bindings/src/lib.rs

index cc4690a..f34a2db 100644
--- a/crates/bindings/bevy_asset_bms_bindings/src/lib.rs
+++ b/crates/bindings/bevy_asset_bms_bindings/src/lib.rs
@@ -1,18 +1,16 @@
-
 #![allow(clippy::all)]
 #![allow(unused, deprecated, dead_code)]
 extern crate std;



+use bevy_app::{App, Plugin};

+use bevy_ecs::prelude::*;

use bevy_mod_scripting_bindings::{

ReflectReference,

function::{


   from::{R, M, V},





   from::{M, R, V},
   namespace::NamespaceBuilder,

},

};

-use bevy_ecs::prelude::*;

-use bevy_app::{App, Plugin};

use bevy_mod_scripting_derive::script_bindings;

pub struct BevyAssetScriptingPlugin;

pub(crate) fn register_untyped_handle_functions(world: &mut World) {

@@ -119,60 +117,54 @@ pub(crate) fn register_untyped_asset_id_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_asset::UntypedAssetId,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_asset::UntypedAssetId>| {



           let output: V<::bevy_asset::UntypedAssetId> = {



               {



                   let output: V<::bevy_asset::UntypedAssetId> = <::bevy_asset::UntypedAssetId as ::core::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: R<::bevy_asset::UntypedAssetId>,



           other: R<::bevy_asset::UntypedAssetId>|



       {



           let output: bool = {



               {



                   let output: bool = <::bevy_asset::UntypedAssetId as ::core::cmp::PartialEq<



                       ::bevy_asset::UntypedAssetId,



                   >>::eq(&_self, &other)



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   )



   .register_documented(



       "type_id",



       |_self: R<::bevy_asset::UntypedAssetId>| {



           let output: V<::core::any::TypeId> = {



               {



                   let output: V<::core::any::TypeId> = ::bevy_asset::UntypedAssetId::type_id(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Returns the stored [`TypeId`] of the referenced [`Asset`].",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_asset::UntypedAssetId>| {



       let output: V<::bevy_asset::UntypedAssetId> = {



           {



               let output: V<::bevy_asset::UntypedAssetId> =



                   <::bevy_asset::UntypedAssetId as ::core::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: R<::bevy_asset::UntypedAssetId>, other: R<::bevy_asset::UntypedAssetId>| {



       let output: bool = {



           {



               let output: bool = <::bevy_asset::UntypedAssetId as ::core::cmp::PartialEq<



                   ::bevy_asset::UntypedAssetId,



               >>::eq(&_self, &other)



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


)
.register_documented(

   "type_id",



   |_self: R<::bevy_asset::UntypedAssetId>| {



       let output: V<::core::any::TypeId> = {



           {



               let output: V<::core::any::TypeId> =



                   ::bevy_asset::UntypedAssetId::type_id(&_self).into();



               output



           }



       };



       output



   },



   " Returns the stored [`TypeId`] of the referenced [`Asset`].",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

b/crates/bindings/bevy_camera_bms_bindings/src/lib.rs

index 3d33978..6db71a9 100644
--- a/crates/bindings/bevy_camera_bms_bindings/src/lib.rs
+++ b/crates/bindings/bevy_camera_bms_bindings/src/lib.rs
@@ -1,18 +1,16 @@
-
 #![allow(clippy::all)]
 #![allow(unused, deprecated, dead_code)]
 extern crate std;



+use bevy_app::{App, Plugin};

+use bevy_ecs::prelude::*;

use bevy_mod_scripting_bindings::{

ReflectReference,

function::{


   from::{R, M, V},





   from::{M, R, V},
   namespace::NamespaceBuilder,

},

};

-use bevy_ecs::prelude::*;

-use bevy_app::{App, Plugin};

use bevy_mod_scripting_derive::script_bindings;

pub struct BevyCameraScriptingPlugin;

pub(crate) fn register_clear_color_functions(world: &mut World) {

@@ -114,60 +112,58 @@ pub(crate) fn register_view_visibility_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::visibility::ViewVisibility,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::visibility::ViewVisibility>| {



           let output: V<::bevy_camera::visibility::ViewVisibility> = {



               {



                   let output: V<::bevy_camera::visibility::ViewVisibility> = <::bevy_camera::visibility::ViewVisibility as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: R<::bevy_camera::visibility::ViewVisibility>,



           other: R<::bevy_camera::visibility::ViewVisibility>|



       {



           let output: bool = {



               {



                   let output: bool = <::bevy_camera::visibility::ViewVisibility as ::std::cmp::PartialEq<




.register_documented(

   "clone",



   |_self: R<::bevy_camera::visibility::ViewVisibility>| {



       let output: V<::bevy_camera::visibility::ViewVisibility> = {



           {



               let output: V<::bevy_camera::visibility::ViewVisibility> =



                   <::bevy_camera::visibility::ViewVisibility as ::std::clone::Clone>::clone(



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: R<::bevy_camera::visibility::ViewVisibility>,



    other: R<::bevy_camera::visibility::ViewVisibility>| {



       let output: bool = {



           {



               let output: bool =



                   <::bevy_camera::visibility::ViewVisibility as ::std::cmp::PartialEq<
                       ::bevy_camera::visibility::ViewVisibility,
                   >>::eq(&_self, &other)





                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   )



   .register_documented(



       "get",



       |_self: V<::bevy_camera::visibility::ViewVisibility>| {



           let output: bool = {



               {



                   let output: bool = ::bevy_camera::visibility::ViewVisibility::get(



                           _self.into_inner(),



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Returns `true` if the entity is visible in any view.\n Otherwise, returns `false`.",



       &["_self"],



   );





                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


)
.register_documented(

   "get",



   |_self: V<::bevy_camera::visibility::ViewVisibility>| {



       let output: bool = {



           {



               let output: bool =



                   ::bevy_camera::visibility::ViewVisibility::get(_self.into_inner()).into();



               output



           }



       };



       output



   },



   " Returns `true` if the entity is visible in any view.\n Otherwise, returns `false`.",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -415,10 +411,8 @@ pub(crate) fn register_camera_functions(world: &mut World) {

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry



   .register_type_data::<



       ::bevy_camera::Camera,



       bevy_mod_scripting_bindings::MarkAsGenerated,



   >();





   .register_type_data::<::bevy_camera::Camera, bevy_mod_scripting_bindings::MarkAsGenerated>(



   );



}

pub(crate) fn register_camera_2_d_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

@@ -482,23 +476,22 @@ pub(crate) fn register_clear_color_config_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::ClearColorConfig,

>::new(world)


   .register_documented(



       "clone",



       |_self: R<::bevy_camera::ClearColorConfig>| {



           let output: V<::bevy_camera::ClearColorConfig> = {



               {



                   let output: V<::bevy_camera::ClearColorConfig> = <::bevy_camera::ClearColorConfig as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::ClearColorConfig>| {



       let output: V<::bevy_camera::ClearColorConfig> = {



           {



               let output: V<::bevy_camera::ClearColorConfig> =



                   <::bevy_camera::ClearColorConfig as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -511,43 +504,39 @@ pub(crate) fn register_compositing_space_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::CompositingSpace,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::CompositingSpace>| {



           let output: V<::bevy_camera::CompositingSpace> = {



               {



                   let output: V<::bevy_camera::CompositingSpace> = <::bevy_camera::CompositingSpace as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: R<::bevy_camera::CompositingSpace>,



           other: R<::bevy_camera::CompositingSpace>|



       {



           let output: bool = {



               {



                   let output: bool = <::bevy_camera::CompositingSpace as ::std::cmp::PartialEq<



                       ::bevy_camera::CompositingSpace,



                   >>::eq(&_self, &other)



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::CompositingSpace>| {



       let output: V<::bevy_camera::CompositingSpace> = {



           {



               let output: V<::bevy_camera::CompositingSpace> =



                   <::bevy_camera::CompositingSpace as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: R<::bevy_camera::CompositingSpace>, other: R<::bevy_camera::CompositingSpace>| {



       let output: bool = {



           {



               let output: bool = <::bevy_camera::CompositingSpace as ::std::cmp::PartialEq<



                   ::bevy_camera::CompositingSpace,



               >>::eq(&_self, &other)



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -560,43 +549,38 @@ pub(crate) fn register_msaa_writeback_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::MsaaWriteback,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::MsaaWriteback>| {



           let output: V<::bevy_camera::MsaaWriteback> = {



               {



                   let output: V<::bevy_camera::MsaaWriteback> = <::bevy_camera::MsaaWriteback as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: R<::bevy_camera::MsaaWriteback>,



           other: R<::bevy_camera::MsaaWriteback>|



       {



           let output: bool = {



               {



                   let output: bool = <::bevy_camera::MsaaWriteback as ::std::cmp::PartialEq<



                       ::bevy_camera::MsaaWriteback,



                   >>::eq(&_self, &other)



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::MsaaWriteback>| {



       let output: V<::bevy_camera::MsaaWriteback> = {



           {



               let output: V<::bevy_camera::MsaaWriteback> =



                   <::bevy_camera::MsaaWriteback as ::std::clone::Clone>::clone(&_self).into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: R<::bevy_camera::MsaaWriteback>, other: R<::bevy_camera::MsaaWriteback>| {



       let output: bool = {



           {



               let output: bool = <::bevy_camera::MsaaWriteback as ::std::cmp::PartialEq<



                   ::bevy_camera::MsaaWriteback,



               >>::eq(&_self, &other)



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -668,23 +652,24 @@ pub(crate) fn register_perspective_projection_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::PerspectiveProjection,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::PerspectiveProjection>| {



           let output: V<::bevy_camera::PerspectiveProjection> = {



               {



                   let output: V<::bevy_camera::PerspectiveProjection> = <::bevy_camera::PerspectiveProjection as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::PerspectiveProjection>| {



       let output: V<::bevy_camera::PerspectiveProjection> = {



           {



               let output: V<::bevy_camera::PerspectiveProjection> =



                   <::bevy_camera::PerspectiveProjection as ::std::clone::Clone>::clone(



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -887,126 +872,115 @@ pub(crate) fn register_visible_entities_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::visibility::VisibleEntities,

::new(world)





   .register_documented(



       "clear",



       |



           mut _self: M<::bevy_camera::visibility::VisibleEntities>,



           type_id: V<::std::any::TypeId>|



       {



           let output: () = {



               {



                   let output: () = ::bevy_camera::visibility::VisibleEntities::clear(



                           &mut _self,



                           type_id.into_inner(),



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "type_id"],



   )



   .register_documented(



       "clear_all",



       |mut _self: M<::bevy_camera::visibility::VisibleEntities>| {



           let output: () = {



               {



                   let output: () = ::bevy_camera::visibility::VisibleEntities::clear_all(



                           &mut _self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "clone",



       |_self: R<::bevy_camera::visibility::VisibleEntities>| {



           let output: V<::bevy_camera::visibility::VisibleEntities> = {



               {



                   let output: V<::bevy_camera::visibility::VisibleEntities> = <::bevy_camera::visibility::VisibleEntities as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "is_empty",



       |



           _self: R<::bevy_camera::visibility::VisibleEntities>,



           type_id: V<::std::any::TypeId>|



       {



           let output: bool = {



               {



                   let output: bool = ::bevy_camera::visibility::VisibleEntities::is_empty(



                           &_self,



                           type_id.into_inner(),



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "type_id"],



   )



   .register_documented(



       "len",



       |



           _self: R<::bevy_camera::visibility::VisibleEntities>,



           type_id: V<::std::any::TypeId>|



       {



           let output: usize = {



               {



                   let output: usize = ::bevy_camera::visibility::VisibleEntities::len(



                           &_self,



                           type_id.into_inner(),



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "type_id"],



   )



   .register_documented(



       "push",



       |



           mut _self: M<::bevy_camera::visibility::VisibleEntities>,



           entity: V<::bevy_ecs::entity::Entity>,



           type_id: V<::std::any::TypeId>|



       {



           let output: () = {



               {



                   let output: () = ::bevy_camera::visibility::VisibleEntities::push(



                           &mut _self,



                           entity.into_inner(),



                           type_id.into_inner(),



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "entity", "type_id"],



   );




.register_documented(

   "clear",



   |mut _self: M<::bevy_camera::visibility::VisibleEntities>,



    type_id: V<::std::any::TypeId>| {



       let output: () = {



           {



               let output: () = ::bevy_camera::visibility::VisibleEntities::clear(



                   &mut _self,



                   type_id.into_inner(),



               )



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "type_id"],


)
.register_documented(

   "clear_all",



   |mut _self: M<::bevy_camera::visibility::VisibleEntities>| {



       let output: () = {



           {



               let output: () =



                   ::bevy_camera::visibility::VisibleEntities::clear_all(&mut _self).into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "clone",



   |_self: R<::bevy_camera::visibility::VisibleEntities>| {



       let output: V<::bevy_camera::visibility::VisibleEntities> = {



           {



               let output: V<::bevy_camera::visibility::VisibleEntities> =



                   <::bevy_camera::visibility::VisibleEntities as ::std::clone::Clone>::clone(



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "is_empty",



   |_self: R<::bevy_camera::visibility::VisibleEntities>, type_id: V<::std::any::TypeId>| {



       let output: bool = {



           {



               let output: bool = ::bevy_camera::visibility::VisibleEntities::is_empty(



                   &_self,



                   type_id.into_inner(),



               )



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "type_id"],


)
.register_documented(

   "len",



   |_self: R<::bevy_camera::visibility::VisibleEntities>, type_id: V<::std::any::TypeId>| {



       let output: usize = {



           {



               let output: usize = ::bevy_camera::visibility::VisibleEntities::len(



                   &_self,



                   type_id.into_inner(),



               )



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "type_id"],


)
.register_documented(

   "push",



   |mut _self: M<::bevy_camera::visibility::VisibleEntities>,



    entity: V<::bevy_ecs::entity::Entity>,



    type_id: V<::std::any::TypeId>| {



       let output: () = {



           {



               let output: () = ::bevy_camera::visibility::VisibleEntities::push(



                   &mut _self,



                   entity.into_inner(),



                   type_id.into_inner(),



               )



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "entity", "type_id"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1078,43 +1052,38 @@ pub(crate) fn register_sub_camera_view_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::SubCameraView,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::SubCameraView>| {



           let output: V<::bevy_camera::SubCameraView> = {



               {



                   let output: V<::bevy_camera::SubCameraView> = <::bevy_camera::SubCameraView as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: R<::bevy_camera::SubCameraView>,



           other: R<::bevy_camera::SubCameraView>|



       {



           let output: bool = {



               {



                   let output: bool = <::bevy_camera::SubCameraView as ::std::cmp::PartialEq<



                       ::bevy_camera::SubCameraView,



                   >>::eq(&_self, &other)



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::SubCameraView>| {



       let output: V<::bevy_camera::SubCameraView> = {



           {



               let output: V<::bevy_camera::SubCameraView> =



                   <::bevy_camera::SubCameraView as ::std::clone::Clone>::clone(&_self).into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: R<::bevy_camera::SubCameraView>, other: R<::bevy_camera::SubCameraView>| {



       let output: bool = {



           {



               let output: bool = <::bevy_camera::SubCameraView as ::std::cmp::PartialEq<



                   ::bevy_camera::SubCameraView,



               >>::eq(&_self, &other)



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1127,23 +1096,22 @@ pub(crate) fn register_render_target_info_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::RenderTargetInfo,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::RenderTargetInfo>| {



           let output: V<::bevy_camera::RenderTargetInfo> = {



               {



                   let output: V<::bevy_camera::RenderTargetInfo> = <::bevy_camera::RenderTargetInfo as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::RenderTargetInfo>| {



       let output: V<::bevy_camera::RenderTargetInfo> = {



           {



               let output: V<::bevy_camera::RenderTargetInfo> =



                   <::bevy_camera::RenderTargetInfo as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1156,23 +1124,22 @@ pub(crate) fn register_computed_camera_values_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::ComputedCameraValues,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::ComputedCameraValues>| {



           let output: V<::bevy_camera::ComputedCameraValues> = {



               {



                   let output: V<::bevy_camera::ComputedCameraValues> = <::bevy_camera::ComputedCameraValues as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::ComputedCameraValues>| {



       let output: V<::bevy_camera::ComputedCameraValues> = {



           {



               let output: V<::bevy_camera::ComputedCameraValues> =



                   <::bevy_camera::ComputedCameraValues as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1229,23 +1196,24 @@ pub(crate) fn register_camera_main_texture_usages_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::CameraMainTextureUsages,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::CameraMainTextureUsages>| {



           let output: V<::bevy_camera::CameraMainTextureUsages> = {



               {



                   let output: V<::bevy_camera::CameraMainTextureUsages> = <::bevy_camera::CameraMainTextureUsages as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::CameraMainTextureUsages>| {



       let output: V<::bevy_camera::CameraMainTextureUsages> = {



           {



               let output: V<::bevy_camera::CameraMainTextureUsages> =



                   <::bevy_camera::CameraMainTextureUsages as ::std::clone::Clone>::clone(



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1287,23 +1255,22 @@ pub(crate) fn register_camera_output_mode_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::CameraOutputMode,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::CameraOutputMode>| {



           let output: V<::bevy_camera::CameraOutputMode> = {



               {



                   let output: V<::bevy_camera::CameraOutputMode> = <::bevy_camera::CameraOutputMode as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::CameraOutputMode>| {



       let output: V<::bevy_camera::CameraOutputMode> = {



           {



               let output: V<::bevy_camera::CameraOutputMode> =



                   <::bevy_camera::CameraOutputMode as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1316,23 +1283,22 @@ pub(crate) fn register_shadow_lod_origin_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::ShadowLodOrigin,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::ShadowLodOrigin>| {



           let output: V<::bevy_camera::ShadowLodOrigin> = {



               {



                   let output: V<::bevy_camera::ShadowLodOrigin> = <::bevy_camera::ShadowLodOrigin as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::ShadowLodOrigin>| {



       let output: V<::bevy_camera::ShadowLodOrigin> = {



           {



               let output: V<::bevy_camera::ShadowLodOrigin> =



                   <::bevy_camera::ShadowLodOrigin as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1345,43 +1311,40 @@ pub(crate) fn register_image_render_target_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::ImageRenderTarget,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::ImageRenderTarget>| {



           ...*[Comment body truncated]*

github-actions · 2026-07-29T18:37:01Z

🔍 Binding Differences Detected

The following changes were detected in generated bindings:

b/crates/bevy_mod_scripting_core/src/commands.rs

index 9cd5be5..1b74412 100644
--- a/crates/bevy_mod_scripting_core/src/commands.rs
+++ b/crates/bevy_mod_scripting_core/src/commands.rs
@@ -11,7 +11,11 @@ use crate::{
     pipeline::RunProcessingPipelineOnce,
     script::Context,
 };
-use bevy_ecs::{error::{BevyError, Severity}, system::Command, world::World};
+use bevy_ecs::{
+    error::{BevyError, Severity},
+    system::Command,
+    world::World,
+};
 use bevy_log::trace;
 use bevy_mod_scripting_bindings::{CurrentScriptAttachment, ScriptValue, WorldExtensions};
 use bevy_mod_scripting_display::DisplayProxy;
@@ -222,7 +226,8 @@ impl RunScriptCallback {
 impl Command for RunScriptCallback
 {
     fn apply(self, world: &mut World) -> Self::Out {
         // inner handling already logs
-        self.run(world).map_err(|e| BevyError::from(e).with_severity(Severity::Ignore))
+        self.run(world)
+            .map_err(|e| BevyError::from(e).with_severity(Severity::Ignore))
     }
     type Out = Result;
 }

b/crates/bevy_mod_scripting_core/src/handler.rs

index a5bff79..66397ec 100644
--- a/crates/bevy_mod_scripting_core/src/handler.rs
+++ b/crates/bevy_mod_scripting_core/src/handler.rs
@@ -117,14 +117,14 @@ pub(crate) fn event_handler_inner(
     guard: WorldAccessGuard,
 ) {
     let mut errors = Vec::default();
-    let events: Result, InteropError> = guard.with_resource(|events: &Messages| {
-        event_cursor
-            .read(events)
-            .filter(|e| e.label == callback_label)
-            .cloned()
-            .collect::>()
-    });
-
+    let events: Result, InteropError> =
+        guard.with_resource(|events: &Messages| {
+            event_cursor
+                .read(events)
+                .filter(|e| e.label == callback_label)
+                .cloned()
+                .collect::>()
+        });
 let events = match events {
     Ok(events) => events,

@@ -142,7 +142,6 @@ pub(crate) fn event_handler_inner<P: IntoScriptPluginParams>(

for event in events.into_iter().filter(|e| {

e.label == callback_label && e.language.as_ref().is_none_or(|l| l == &P::LANGUAGE)

}) {
     let recipients = event.recipients.get_recipients(script_context.clone());
     let highly_specific = matches!(
         event.recipients,

@@ -183,7 +182,7 @@ pub(crate) fn event_handler_inner<P: IntoScriptPluginParams>(

.with_type_info_context(Some("args: "), event.args.clone())

.with_language(P::LANGUAGE)

});


       drop(ctxt);

       if event.trigger_response {

b/crates/bevy_mod_scripting_world/src/world.rs

index 6c6f74b..26dfd46 100644
--- a/crates/bevy_mod_scripting_world/src/world.rs
+++ b/crates/bevy_mod_scripting_world/src/world.rs
@@ -430,13 +430,17 @@ impl<'w> WorldAccessGuard<'w> {
 /// Gets the resource id of the given component or resource
 pub fn get_resource_id(&self, id: TypeId) -> Result<Option<ComponentId>, DynWorldAccessError> {



   let cell = self



       .as_unsafe_world_cell_readonly()?;





   let cell = self.as_unsafe_world_cell_readonly()?;
   Ok(cell
       .components()
       .get_id(id)
       // Safety: we are not updating the cache





       .and_then(|id| unsafe { cell.resource_entities() }.get(id).is_some().then_some(id)))





       .and_then(|id| {



           unsafe { cell.resource_entities() }



               .get(id)



               .is_some()



               .then_some(id)



       }))

}
fn resource_component_id<R: Resource>(&self) -> Result<ComponentId, DynWorldAccessError> {

b/crates/bindings/bevy_a11y_bms_bindings/src/lib.rs

index a5999d7..401a7a3 100644
--- a/crates/bindings/bevy_a11y_bms_bindings/src/lib.rs
+++ b/crates/bindings/bevy_a11y_bms_bindings/src/lib.rs
@@ -1,18 +1,16 @@
-
 #![allow(clippy::all)]
 #![allow(unused, deprecated, dead_code)]
 extern crate std;



+use bevy_app::{App, Plugin};

+use bevy_ecs::prelude::*;

use bevy_mod_scripting_bindings::{

ReflectReference,

function::{


   from::{R, M, V},





   from::{M, R, V},
   namespace::NamespaceBuilder,

},

};

-use bevy_ecs::prelude::*;

-use bevy_app::{App, Plugin};

use bevy_mod_scripting_derive::script_bindings;

pub struct BevyA11YScriptingPlugin;

pub(crate) fn register_accessibility_requested_functions(world: &mut World) {

@@ -83,58 +81,53 @@ pub(crate) fn register_manage_accessibility_updates_functions(world: &mut World)

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_a11y::ManageAccessibilityUpdates,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_a11y::ManageAccessibilityUpdates>| {



           let output: V<::bevy_a11y::ManageAccessibilityUpdates> = {



               {



                   let output: V<::bevy_a11y::ManageAccessibilityUpdates> = <::bevy_a11y::ManageAccessibilityUpdates as ::core::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "get",



       |_self: R<::bevy_a11y::ManageAccessibilityUpdates>| {



           let output: bool = {



               {



                   let output: bool = ::bevy_a11y::ManageAccessibilityUpdates::get(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Returns `true` if Bevy's ECS should update the accessibility tree.",



       &["_self"],



   )



   .register_documented(



       "set",



       |mut _self: M<::bevy_a11y::ManageAccessibilityUpdates>, value: bool| {



           let output: () = {



               {



                   let output: () = ::bevy_a11y::ManageAccessibilityUpdates::set(



                           &mut _self,



                           value,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Sets whether Bevy's ECS should update the accessibility tree.",



       &["_self", "value"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_a11y::ManageAccessibilityUpdates>| {



       let output: V<::bevy_a11y::ManageAccessibilityUpdates> = {



           {



               let output: V<::bevy_a11y::ManageAccessibilityUpdates> =



                   <::bevy_a11y::ManageAccessibilityUpdates as ::core::clone::Clone>::clone(



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "get",



   |_self: R<::bevy_a11y::ManageAccessibilityUpdates>| {



       let output: bool = {



           {



               let output: bool = ::bevy_a11y::ManageAccessibilityUpdates::get(&_self).into();



               output



           }



       };



       output



   },



   " Returns `true` if Bevy's ECS should update the accessibility tree.",



   &["_self"],


)
.register_documented(

   "set",



   |mut _self: M<::bevy_a11y::ManageAccessibilityUpdates>, value: bool| {



       let output: () = {



           {



               let output: () =



                   ::bevy_a11y::ManageAccessibilityUpdates::set(&mut _self, value).into();



               output



           }



       };



       output



   },



   " Sets whether Bevy's ECS should update the accessibility tree.",



   &["_self", "value"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -147,43 +140,41 @@ pub(crate) fn register_accessibility_systems_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_a11y::AccessibilitySystems,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_a11y::AccessibilitySystems>| {



           let output: V<::bevy_a11y::AccessibilitySystems> = {



               {



                   let output: V<::bevy_a11y::AccessibilitySystems> = <::bevy_a11y::AccessibilitySystems as ::core::clone::Clone>::clone(



                           &_self,



                       )




.register_documented(

   "clone",



   |_self: R<::bevy_a11y::AccessibilitySystems>| {



       let output: V<::bevy_a11y::AccessibilitySystems> = {



           {



               let output: V<::bevy_a11y::AccessibilitySystems> =



                   <::bevy_a11y::AccessibilitySystems as ::core::clone::Clone>::clone(&_self)
                       .into();





                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: R<::bevy_a11y::AccessibilitySystems>,



           other: R<::bevy_a11y::AccessibilitySystems>|



       {



           let output: bool = {



               {



                   let output: bool = <::bevy_a11y::AccessibilitySystems as ::core::cmp::PartialEq<





               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: R<::bevy_a11y::AccessibilitySystems>,



    other: R<::bevy_a11y::AccessibilitySystems>| {



       let output: bool = {



           {



               let output: bool =



                   <::bevy_a11y::AccessibilitySystems as ::core::cmp::PartialEq<
                       ::bevy_a11y::AccessibilitySystems,
                   >>::eq(&_self, &other)





                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   );





                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

b/crates/bindings/bevy_animation_bms_bindings/src/lib.rs

index 67d1564..c823e14 100644
--- a/crates/bindings/bevy_animation_bms_bindings/src/lib.rs
+++ b/crates/bindings/bevy_animation_bms_bindings/src/lib.rs
@@ -1,41 +1,40 @@
-
 #![allow(clippy::all)]
 #![allow(unused, deprecated, dead_code)]
 extern crate std;



+use bevy_app::{App, Plugin};

+use bevy_ecs::prelude::*;

use bevy_mod_scripting_bindings::{

ReflectReference,

function::{


   from::{R, M, V},





   from::{M, R, V},
   namespace::NamespaceBuilder,

},

};

-use bevy_ecs::prelude::*;

-use bevy_app::{App, Plugin};

use bevy_mod_scripting_derive::script_bindings;

pub struct BevyAnimationScriptingPlugin;

pub(crate) fn register_animation_node_type_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_animation::graph::AnimationNodeType,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_animation::graph::AnimationNodeType>| {



           let output: V<::bevy_animation::graph::AnimationNodeType> = {



               {



                   let output: V<::bevy_animation::graph::AnimationNodeType> = <::bevy_animation::graph::AnimationNodeType as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_animation::graph::AnimationNodeType>| {



       let output: V<::bevy_animation::graph::AnimationNodeType> = {



           {



               let output: V<::bevy_animation::graph::AnimationNodeType> =



                   <::bevy_animation::graph::AnimationNodeType as ::std::clone::Clone>::clone(



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -109,58 +108,52 @@ pub(crate) fn register_animation_clip_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_animation::AnimationClip,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_animation::AnimationClip>| {



           let output: V<::bevy_animation::AnimationClip> = {



               {



                   let output: V<::bevy_animation::AnimationClip> = <::bevy_animation::AnimationClip as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "duration",



       |_self: R<::bevy_animation::AnimationClip>| {



           let output: f32 = {



               {



                   let output: f32 = ::bevy_animation::AnimationClip::duration(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Duration of the clip, represented in seconds.",



       &["_self"],



   )



   .register_documented(



       "set_duration",



       |mut _self: M<::bevy_animation::AnimationClip>, duration_sec: f32| {



           let output: () = {



               {



                   let output: () = ::bevy_animation::AnimationClip::set_duration(



                           &mut _self,



                           duration_sec,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Set the duration of the clip in seconds.",



       &["_self", "duration_sec"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_animation::AnimationClip>| {



       let output: V<::bevy_animation::AnimationClip> = {



           {



               let output: V<::bevy_animation::AnimationClip> =



                   <::bevy_animation::AnimationClip as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "duration",



   |_self: R<::bevy_animation::AnimationClip>| {



       let output: f32 = {



           {



               let output: f32 = ::bevy_animation::AnimationClip::duration(&_self).into();



               output



           }



       };



       output



   },



   " Duration of the clip, represented in seconds.",



   &["_self"],


)
.register_documented(

   "set_duration",



   |mut _self: M<::bevy_animation::AnimationClip>, duration_sec: f32| {



       let output: () = {



           {



               let output: () =



                   ::bevy_animation::AnimationClip::set_duration(&mut _self, duration_sec)



                       .into();



               output



           }



       };



       output



   },



   " Set the duration of the clip in seconds.",



   &["_self", "duration_sec"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -173,78 +166,70 @@ pub(crate) fn register_animation_player_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_animation::AnimationPlayer,

::new(world)





   .register_documented(



       "all_finished",



       |_self: R<::bevy_animation::AnimationPlayer>| {



           let output: bool = {



               {



                   let output: bool = ::bevy_animation::AnimationPlayer::all_finished(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Check if all playing animations have finished, according to the repetition behavior.",



       &["_self"],



   )



   .register_documented(



       "all_paused",



       |_self: R<::bevy_animation::AnimationPlayer>| {



           let output: bool = {



               {



                   let output: bool = ::bevy_animation::AnimationPlayer::all_paused(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Check if all playing animations are paused.",



       &["_self"],



   )



   .register_documented(



       "clone",



       |_self: R<::bevy_animation::AnimationPlayer>| {



           let output: V<::bevy_animation::AnimationPlayer> = {



               {



                   let output: V<::bevy_animation::AnimationPlayer> = <::bevy_animation::AnimationPlayer as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "clone_from",



       |



           mut _self: M<::bevy_animation::AnimationPlayer>,



           source: R<::bevy_animation::AnimationPlayer>|



       {



           let output: () = {



               {



                   let output: () = <::bevy_animation::AnimationPlayer as ::std::clone::Clone>::clone_from(



                           &mut _self,



                           &source,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "source"],



   );




.register_documented(

   "all_finished",



   |_self: R<::bevy_animation::AnimationPlayer>| {



       let output: bool = {



           {



               let output: bool =



                   ::bevy_animation::AnimationPlayer::all_finished(&_self).into();



               output



           }



       };



       output



   },



   " Check if all playing animations have finished, according to the repetition behavior.",



   &["_self"],


)
.register_documented(

   "all_paused",



   |_self: R<::bevy_animation::AnimationPlayer>| {



       let output: bool = {



           {



               let output: bool = ::bevy_animation::AnimationPlayer::all_paused(&_self).into();



               output



           }



       };



       output



   },



   " Check if all playing animations are paused.",



   &["_self"],


)
.register_documented(

   "clone",



   |_self: R<::bevy_animation::AnimationPlayer>| {



       let output: V<::bevy_animation::AnimationPlayer> = {



           {



               let output: V<::bevy_animation::AnimationPlayer> =



                   <::bevy_animation::AnimationPlayer as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "clone_from",



   |mut _self: M<::bevy_animation::AnimationPlayer>,



    source: R<::bevy_animation::AnimationPlayer>| {



       let output: () = {



           {



               let output: () =



                   <::bevy_animation::AnimationPlayer as ::std::clone::Clone>::clone_from(



                       &mut _self, &source,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "source"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -324,60 +309,56 @@ pub(crate) fn register_animation_target_id_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_animation::AnimationTargetId,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_animation::AnimationTargetId>| {



           let output: V<::bevy_animation::AnimationTargetId> = {



               {



                   let output: V<::bevy_animation::AnimationTargetId> = <::bevy_animation::AnimationTargetId as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: R<::bevy_animation::AnimationTargetId>,



           other: R<::bevy_animation::AnimationTargetId>|



       {



           let output: bool = {



               {



                   let output: bool = <::bevy_animation::AnimationTargetId as ::std::cmp::PartialEq<




.register_documented(

   "clone",



   |_self: R<::bevy_animation::AnimationTargetId>| {



       let output: V<::bevy_animation::AnimationTargetId> = {



           {



               let output: V<::bevy_animation::AnimationTargetId> =



                   <::bevy_animation::AnimationTargetId as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: R<::bevy_animation::AnimationTargetId>,



    other: R<::bevy_animation::AnimationTargetId>| {



       let output: bool = {



           {



               let output: bool =



                   <::bevy_animation::AnimationTargetId as ::std::cmp::PartialEq<
                       ::bevy_animation::AnimationTargetId,
                   >>::eq(&_self, &other)





                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   )



   .register_documented(



       "from_name",



       |name: R<::bevy_ecs::name::Name>| {



           let output: V<::bevy_animation::AnimationTargetId> = {



               {



                   let output: V<::bevy_animation::AnimationTargetId> = ::bevy_animation::AnimationTargetId::from_name(



                           &name,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Creates a new [`AnimationTargetId`] by hashing a single name.",



       &["name"],



   );





                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


)
.register_documented(

   "from_name",



   |name: R<::bevy_ecs::name::Name>| {



       let output: V<::bevy_animation::AnimationTargetId> = {



           {



               let output: V<::bevy_animation::AnimationTargetId> =



                   ::bevy_animation::AnimationTargetId::from_name(&name).into();



               output



           }



       };



       output



   },



   " Creates a new [`AnimationTargetId`] by hashing a single name.",



   &["name"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -390,23 +371,21 @@ pub(crate) fn register_animated_by_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_animation::AnimatedBy,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_animation::AnimatedBy>| {



           let output: V<::bevy_animation::AnimatedBy> = {



               {



                   let output: V<::bevy_animation::AnimatedBy> = <::bevy_animation::AnimatedBy as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_animation::AnimatedBy>| {



       let output: V<::bevy_animation::AnimatedBy> = {



           {



               let output: V<::bevy_animation::AnimatedBy> =



                   <::bevy_animation::AnimatedBy as ::std::clone::Clone>::clone(&_self).into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -419,43 +398,41 @@ pub(crate) fn register_repeat_animation_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_animation::RepeatAnimation,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_animation::RepeatAnimation>| {



           let output: V<::bevy_animation::RepeatAnimation> = {



               {



                   let output: V<::bevy_animation::RepeatAnimation> = <::bevy_animation::RepeatAnimation as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: R<::bevy_animation::RepeatAnimation>,



           other: R<::bevy_animation::RepeatAnimation>|



       {



           let output: bool = {



               {



                   let output: bool = <::bevy_animation::RepeatAnimation as ::std::cmp::PartialEq<




.register_documented(

   "clone",



   |_self: R<::bevy_animation::RepeatAnimation>| {



       let output: V<::bevy_animation::RepeatAnimation> = {



           {



               let output: V<::bevy_animation::RepeatAnimation> =



                   <::bevy_animation::RepeatAnimation as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: R<::bevy_animation::RepeatAnimation>,



    other: R<::bevy_animation::RepeatAnimation>| {



       let output: bool = {



           {



               let output: bool =



                   <::bevy_animation::RepeatAnimation as ::std::cmp::PartialEq<
                       ::bevy_animation::RepeatAnimation,
                   >>::eq(&_self, &other)





                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   );





                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

b/crates/bindings/bevy_app_bms_bindings/src/lib.rs

index b9a5a09..ff722e7 100644
--- a/crates/bindings/bevy_app_bms_bindings/src/lib.rs
+++ b/crates/bindings/bevy_app_bms_bindings/src/lib.rs
@@ -1,18 +1,16 @@
-
 #![allow(clippy::all)]
 #![allow(unused, deprecated, dead_code)]
 extern crate std;



+use bevy_app::{App, Plugin};

+use bevy_ecs::prelude::*;

use bevy_mod_scripting_bindings::{

ReflectReference,

function::{


   from::{R, M, V},





   from::{M, R, V},
   namespace::NamespaceBuilder,

},

};

-use bevy_ecs::prelude::*;

-use bevy_app::{App, Plugin};

use bevy_mod_scripting_derive::script_bindings;

pub struct BevyAppScriptingPlugin;

pub(crate) fn register_app_exit_functions(world: &mut World) {

@@ -117,10 +115,7 @@ pub(crate) fn register_app_exit_functions(world: &mut World) {

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry



   .register_type_data::<



       ::bevy_app::AppExit,



       bevy_mod_scripting_bindings::MarkAsGenerated,



   >();





   .register_type_data::<::bevy_app::AppExit, bevy_mod_scripting_bindings::MarkAsGenerated>();



}

impl Plugin for BevyAppScriptingPlugin {

fn build(&self, app: &mut App) {

b/crates/bindings/bevy_asset_bms_bindings/src/lib.rs

index cc4690a..f34a2db 100644
--- a/crates/bindings/bevy_asset_bms_bindings/src/lib.rs
+++ b/crates/bindings/bevy_asset_bms_bindings/src/lib.rs
@@ -1,18 +1,16 @@
-
 #![allow(clippy::all)]
 #![allow(unused, deprecated, dead_code)]
 extern crate std;



+use bevy_app::{App, Plugin};

+use bevy_ecs::prelude::*;

use bevy_mod_scripting_bindings::{

ReflectReference,

function::{


   from::{R, M, V},





   from::{M, R, V},
   namespace::NamespaceBuilder,

},

};

-use bevy_ecs::prelude::*;

-use bevy_app::{App, Plugin};

use bevy_mod_scripting_derive::script_bindings;

pub struct BevyAssetScriptingPlugin;

pub(crate) fn register_untyped_handle_functions(world: &mut World) {

@@ -119,60 +117,54 @@ pub(crate) fn register_untyped_asset_id_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_asset::UntypedAssetId,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_asset::UntypedAssetId>| {



           let output: V<::bevy_asset::UntypedAssetId> = {



               {



                   let output: V<::bevy_asset::UntypedAssetId> = <::bevy_asset::UntypedAssetId as ::core::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: R<::bevy_asset::UntypedAssetId>,



           other: R<::bevy_asset::UntypedAssetId>|



       {



           let output: bool = {



               {



                   let output: bool = <::bevy_asset::UntypedAssetId as ::core::cmp::PartialEq<



                       ::bevy_asset::UntypedAssetId,



                   >>::eq(&_self, &other)



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   )



   .register_documented(



       "type_id",



       |_self: R<::bevy_asset::UntypedAssetId>| {



           let output: V<::core::any::TypeId> = {



               {



                   let output: V<::core::any::TypeId> = ::bevy_asset::UntypedAssetId::type_id(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Returns the stored [`TypeId`] of the referenced [`Asset`].",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_asset::UntypedAssetId>| {



       let output: V<::bevy_asset::UntypedAssetId> = {



           {



               let output: V<::bevy_asset::UntypedAssetId> =



                   <::bevy_asset::UntypedAssetId as ::core::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: R<::bevy_asset::UntypedAssetId>, other: R<::bevy_asset::UntypedAssetId>| {



       let output: bool = {



           {



               let output: bool = <::bevy_asset::UntypedAssetId as ::core::cmp::PartialEq<



                   ::bevy_asset::UntypedAssetId,



               >>::eq(&_self, &other)



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


)
.register_documented(

   "type_id",



   |_self: R<::bevy_asset::UntypedAssetId>| {



       let output: V<::core::any::TypeId> = {



           {



               let output: V<::core::any::TypeId> =



                   ::bevy_asset::UntypedAssetId::type_id(&_self).into();



               output



           }



       };



       output



   },



   " Returns the stored [`TypeId`] of the referenced [`Asset`].",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

b/crates/bindings/bevy_camera_bms_bindings/src/lib.rs

index 3d33978..6db71a9 100644
--- a/crates/bindings/bevy_camera_bms_bindings/src/lib.rs
+++ b/crates/bindings/bevy_camera_bms_bindings/src/lib.rs
@@ -1,18 +1,16 @@
-
 #![allow(clippy::all)]
 #![allow(unused, deprecated, dead_code)]
 extern crate std;



+use bevy_app::{App, Plugin};

+use bevy_ecs::prelude::*;

use bevy_mod_scripting_bindings::{

ReflectReference,

function::{


   from::{R, M, V},





   from::{M, R, V},
   namespace::NamespaceBuilder,

},

};

-use bevy_ecs::prelude::*;

-use bevy_app::{App, Plugin};

use bevy_mod_scripting_derive::script_bindings;

pub struct BevyCameraScriptingPlugin;

pub(crate) fn register_clear_color_functions(world: &mut World) {

@@ -114,60 +112,58 @@ pub(crate) fn register_view_visibility_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::visibility::ViewVisibility,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::visibility::ViewVisibility>| {



           let output: V<::bevy_camera::visibility::ViewVisibility> = {



               {



                   let output: V<::bevy_camera::visibility::ViewVisibility> = <::bevy_camera::visibility::ViewVisibility as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: R<::bevy_camera::visibility::ViewVisibility>,



           other: R<::bevy_camera::visibility::ViewVisibility>|



       {



           let output: bool = {



               {



                   let output: bool = <::bevy_camera::visibility::ViewVisibility as ::std::cmp::PartialEq<




.register_documented(

   "clone",



   |_self: R<::bevy_camera::visibility::ViewVisibility>| {



       let output: V<::bevy_camera::visibility::ViewVisibility> = {



           {



               let output: V<::bevy_camera::visibility::ViewVisibility> =



                   <::bevy_camera::visibility::ViewVisibility as ::std::clone::Clone>::clone(



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: R<::bevy_camera::visibility::ViewVisibility>,



    other: R<::bevy_camera::visibility::ViewVisibility>| {



       let output: bool = {



           {



               let output: bool =



                   <::bevy_camera::visibility::ViewVisibility as ::std::cmp::PartialEq<
                       ::bevy_camera::visibility::ViewVisibility,
                   >>::eq(&_self, &other)





                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   )



   .register_documented(



       "get",



       |_self: V<::bevy_camera::visibility::ViewVisibility>| {



           let output: bool = {



               {



                   let output: bool = ::bevy_camera::visibility::ViewVisibility::get(



                           _self.into_inner(),



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Returns `true` if the entity is visible in any view.\n Otherwise, returns `false`.",



       &["_self"],



   );





                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


)
.register_documented(

   "get",



   |_self: V<::bevy_camera::visibility::ViewVisibility>| {



       let output: bool = {



           {



               let output: bool =



                   ::bevy_camera::visibility::ViewVisibility::get(_self.into_inner()).into();



               output



           }



       };



       output



   },



   " Returns `true` if the entity is visible in any view.\n Otherwise, returns `false`.",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -415,10 +411,8 @@ pub(crate) fn register_camera_functions(world: &mut World) {

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry



   .register_type_data::<



       ::bevy_camera::Camera,



       bevy_mod_scripting_bindings::MarkAsGenerated,



   >();





   .register_type_data::<::bevy_camera::Camera, bevy_mod_scripting_bindings::MarkAsGenerated>(



   );



}

pub(crate) fn register_camera_2_d_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

@@ -482,23 +476,22 @@ pub(crate) fn register_clear_color_config_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::ClearColorConfig,

>::new(world)


   .register_documented(



       "clone",



       |_self: R<::bevy_camera::ClearColorConfig>| {



           let output: V<::bevy_camera::ClearColorConfig> = {



               {



                   let output: V<::bevy_camera::ClearColorConfig> = <::bevy_camera::ClearColorConfig as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::ClearColorConfig>| {



       let output: V<::bevy_camera::ClearColorConfig> = {



           {



               let output: V<::bevy_camera::ClearColorConfig> =



                   <::bevy_camera::ClearColorConfig as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -511,43 +504,39 @@ pub(crate) fn register_compositing_space_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::CompositingSpace,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::CompositingSpace>| {



           let output: V<::bevy_camera::CompositingSpace> = {



               {



                   let output: V<::bevy_camera::CompositingSpace> = <::bevy_camera::CompositingSpace as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: R<::bevy_camera::CompositingSpace>,



           other: R<::bevy_camera::CompositingSpace>|



       {



           let output: bool = {



               {



                   let output: bool = <::bevy_camera::CompositingSpace as ::std::cmp::PartialEq<



                       ::bevy_camera::CompositingSpace,



                   >>::eq(&_self, &other)



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::CompositingSpace>| {



       let output: V<::bevy_camera::CompositingSpace> = {



           {



               let output: V<::bevy_camera::CompositingSpace> =



                   <::bevy_camera::CompositingSpace as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: R<::bevy_camera::CompositingSpace>, other: R<::bevy_camera::CompositingSpace>| {



       let output: bool = {



           {



               let output: bool = <::bevy_camera::CompositingSpace as ::std::cmp::PartialEq<



                   ::bevy_camera::CompositingSpace,



               >>::eq(&_self, &other)



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -560,43 +549,38 @@ pub(crate) fn register_msaa_writeback_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::MsaaWriteback,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::MsaaWriteback>| {



           let output: V<::bevy_camera::MsaaWriteback> = {



               {



                   let output: V<::bevy_camera::MsaaWriteback> = <::bevy_camera::MsaaWriteback as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: R<::bevy_camera::MsaaWriteback>,



           other: R<::bevy_camera::MsaaWriteback>|



       {



           let output: bool = {



               {



                   let output: bool = <::bevy_camera::MsaaWriteback as ::std::cmp::PartialEq<



                       ::bevy_camera::MsaaWriteback,



                   >>::eq(&_self, &other)



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::MsaaWriteback>| {



       let output: V<::bevy_camera::MsaaWriteback> = {



           {



               let output: V<::bevy_camera::MsaaWriteback> =



                   <::bevy_camera::MsaaWriteback as ::std::clone::Clone>::clone(&_self).into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: R<::bevy_camera::MsaaWriteback>, other: R<::bevy_camera::MsaaWriteback>| {



       let output: bool = {



           {



               let output: bool = <::bevy_camera::MsaaWriteback as ::std::cmp::PartialEq<



                   ::bevy_camera::MsaaWriteback,



               >>::eq(&_self, &other)



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -668,23 +652,24 @@ pub(crate) fn register_perspective_projection_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::PerspectiveProjection,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::PerspectiveProjection>| {



           let output: V<::bevy_camera::PerspectiveProjection> = {



               {



                   let output: V<::bevy_camera::PerspectiveProjection> = <::bevy_camera::PerspectiveProjection as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::PerspectiveProjection>| {



       let output: V<::bevy_camera::PerspectiveProjection> = {



           {



               let output: V<::bevy_camera::PerspectiveProjection> =



                   <::bevy_camera::PerspectiveProjection as ::std::clone::Clone>::clone(



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -887,126 +872,115 @@ pub(crate) fn register_visible_entities_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::visibility::VisibleEntities,

::new(world)





   .register_documented(



       "clear",



       |



           mut _self: M<::bevy_camera::visibility::VisibleEntities>,



           type_id: V<::std::any::TypeId>|



       {



           let output: () = {



               {



                   let output: () = ::bevy_camera::visibility::VisibleEntities::clear(



                           &mut _self,



                           type_id.into_inner(),



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "type_id"],



   )



   .register_documented(



       "clear_all",



       |mut _self: M<::bevy_camera::visibility::VisibleEntities>| {



           let output: () = {



               {



                   let output: () = ::bevy_camera::visibility::VisibleEntities::clear_all(



                           &mut _self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "clone",



       |_self: R<::bevy_camera::visibility::VisibleEntities>| {



           let output: V<::bevy_camera::visibility::VisibleEntities> = {



               {



                   let output: V<::bevy_camera::visibility::VisibleEntities> = <::bevy_camera::visibility::VisibleEntities as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "is_empty",



       |



           _self: R<::bevy_camera::visibility::VisibleEntities>,



           type_id: V<::std::any::TypeId>|



       {



           let output: bool = {



               {



                   let output: bool = ::bevy_camera::visibility::VisibleEntities::is_empty(



                           &_self,



                           type_id.into_inner(),



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "type_id"],



   )



   .register_documented(



       "len",



       |



           _self: R<::bevy_camera::visibility::VisibleEntities>,



           type_id: V<::std::any::TypeId>|



       {



           let output: usize = {



               {



                   let output: usize = ::bevy_camera::visibility::VisibleEntities::len(



                           &_self,



                           type_id.into_inner(),



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "type_id"],



   )



   .register_documented(



       "push",



       |



           mut _self: M<::bevy_camera::visibility::VisibleEntities>,



           entity: V<::bevy_ecs::entity::Entity>,



           type_id: V<::std::any::TypeId>|



       {



           let output: () = {



               {



                   let output: () = ::bevy_camera::visibility::VisibleEntities::push(



                           &mut _self,



                           entity.into_inner(),



                           type_id.into_inner(),



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "entity", "type_id"],



   );




.register_documented(

   "clear",



   |mut _self: M<::bevy_camera::visibility::VisibleEntities>,



    type_id: V<::std::any::TypeId>| {



       let output: () = {



           {



               let output: () = ::bevy_camera::visibility::VisibleEntities::clear(



                   &mut _self,



                   type_id.into_inner(),



               )



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "type_id"],


)
.register_documented(

   "clear_all",



   |mut _self: M<::bevy_camera::visibility::VisibleEntities>| {



       let output: () = {



           {



               let output: () =



                   ::bevy_camera::visibility::VisibleEntities::clear_all(&mut _self).into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "clone",



   |_self: R<::bevy_camera::visibility::VisibleEntities>| {



       let output: V<::bevy_camera::visibility::VisibleEntities> = {



           {



               let output: V<::bevy_camera::visibility::VisibleEntities> =



                   <::bevy_camera::visibility::VisibleEntities as ::std::clone::Clone>::clone(



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "is_empty",



   |_self: R<::bevy_camera::visibility::VisibleEntities>, type_id: V<::std::any::TypeId>| {



       let output: bool = {



           {



               let output: bool = ::bevy_camera::visibility::VisibleEntities::is_empty(



                   &_self,



                   type_id.into_inner(),



               )



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "type_id"],


)
.register_documented(

   "len",



   |_self: R<::bevy_camera::visibility::VisibleEntities>, type_id: V<::std::any::TypeId>| {



       let output: usize = {



           {



               let output: usize = ::bevy_camera::visibility::VisibleEntities::len(



                   &_self,



                   type_id.into_inner(),



               )



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "type_id"],


)
.register_documented(

   "push",



   |mut _self: M<::bevy_camera::visibility::VisibleEntities>,



    entity: V<::bevy_ecs::entity::Entity>,



    type_id: V<::std::any::TypeId>| {



       let output: () = {



           {



               let output: () = ::bevy_camera::visibility::VisibleEntities::push(



                   &mut _self,



                   entity.into_inner(),



                   type_id.into_inner(),



               )



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "entity", "type_id"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1078,43 +1052,38 @@ pub(crate) fn register_sub_camera_view_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::SubCameraView,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::SubCameraView>| {



           let output: V<::bevy_camera::SubCameraView> = {



               {



                   let output: V<::bevy_camera::SubCameraView> = <::bevy_camera::SubCameraView as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: R<::bevy_camera::SubCameraView>,



           other: R<::bevy_camera::SubCameraView>|



       {



           let output: bool = {



               {



                   let output: bool = <::bevy_camera::SubCameraView as ::std::cmp::PartialEq<



                       ::bevy_camera::SubCameraView,



                   >>::eq(&_self, &other)



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::SubCameraView>| {



       let output: V<::bevy_camera::SubCameraView> = {



           {



               let output: V<::bevy_camera::SubCameraView> =



                   <::bevy_camera::SubCameraView as ::std::clone::Clone>::clone(&_self).into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: R<::bevy_camera::SubCameraView>, other: R<::bevy_camera::SubCameraView>| {



       let output: bool = {



           {



               let output: bool = <::bevy_camera::SubCameraView as ::std::cmp::PartialEq<



                   ::bevy_camera::SubCameraView,



               >>::eq(&_self, &other)



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1127,23 +1096,22 @@ pub(crate) fn register_render_target_info_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::RenderTargetInfo,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::RenderTargetInfo>| {



           let output: V<::bevy_camera::RenderTargetInfo> = {



               {



                   let output: V<::bevy_camera::RenderTargetInfo> = <::bevy_camera::RenderTargetInfo as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::RenderTargetInfo>| {



       let output: V<::bevy_camera::RenderTargetInfo> = {



           {



               let output: V<::bevy_camera::RenderTargetInfo> =



                   <::bevy_camera::RenderTargetInfo as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1156,23 +1124,22 @@ pub(crate) fn register_computed_camera_values_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::ComputedCameraValues,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::ComputedCameraValues>| {



           let output: V<::bevy_camera::ComputedCameraValues> = {



               {



                   let output: V<::bevy_camera::ComputedCameraValues> = <::bevy_camera::ComputedCameraValues as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: R<::bevy_camera::ComputedCameraValues>| {



       let output: V<::bevy_camera::ComputedCameraValues> = {



           {



               let output: V<::bevy_camera::ComputedCameraValues> =



                   <::bevy_camera::ComputedCameraValues as ::std::clone::Clone>::clone(&_self)



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1229,23 +1196,24 @@ pub(crate) fn register_camera_main_texture_usages_functions(world: &mut World) {

bevy_mod_scripting_bindings::function::namespace::NamespaceBuilder::<

::bevy_camera::CameraMainTextureUsages,

::new(world)





   .register_documented(



       "clone",



       |_self: R<::bevy_camera::CameraMainTextureUsages>| {



           let output: V<::bevy_camera::CameraMainTextureUsages> = {



               {



                   let output: V<::bevy_camera::CameraMainTextureUsages> = <::bevy_camera::CameraMainTextureUsages as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",...*[Comment body truncated]*

github-actions · 2026-07-29T18:57:37Z

Bencher Report

Project	Bevy Scripting
Branch	feat/bevy-0.19
Testbed	linux-gha

⚠️ WARNING: Truncated view!
The full continuous benchmarking report exceeds the maximum length allowed on this platform.

🚨 14 Alerts

🐰 View full continuous benchmarking report in Bencher

makspll added 5 commits June 26, 2026 17:35

upgrade bevy

24f3eb6

WIP, trying to narrow down issue

df8e04b

make more complex type work

d4c4fcb

dayum

8d865cf

better

b52b17b

makspll added 3 commits July 29, 2026 17:47

fixes

8c4b085

fix

891ab21

more fixes

a7eb9d4

fix

5027c77

fix test

afa6249

fmt

d771f06

makspll enabled auto-merge (squash) July 29, 2026 19:08

makspll added 2 commits July 29, 2026 20:17

thingies

48a37fc

fix bench compilation time

30aac37

makspll merged commit 2870fb1 into main Jul 29, 2026
33 of 73 checks passed

makspll deleted the feat/bevy-0.19 branch July 29, 2026 21:00

This was referenced Jul 29, 2026

chore: release v0.21.0 #549

Merged

chore: release v0.21.1 #550

Open

Navigation Menu

Uh oh!

feat: bevy 0.19 - #547

feat: bevy 0.19#547
makspll merged 13 commits into
mainfrom
feat/bevy-0.19

makspll commented Jul 29, 2026 •

edited

Loading

Uh oh!

semanticdiff-com Bot commented Jul 29, 2026 •

edited

Loading

Uh oh!

github-actions Bot commented Jul 29, 2026

Uh oh!

github-actions Bot commented Jul 29, 2026

Uh oh!

github-actions Bot commented Jul 29, 2026

@@ -142,7 +142,6 @@ pub(crate) fn event_handler_inner<P: IntoScriptPluginParams>(
for event in events.into_iter().filter(|e| {
e.label == callback_label && e.language.as_ref().is_none_or(|l| l == &P::LANGUAGE)
}) {

@@ -183,7 +182,7 @@ pub(crate) fn event_handler_inner<P: IntoScriptPluginParams>(
.with_type_info_context(Some("args: "), event.args.clone())
.with_language(P::LANGUAGE)
});

Uh oh!

github-actions Bot commented Jul 29, 2026 •

edited

Loading

⚠️ WARNING: Truncated view!

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

Uh oh!

Conversation

makspll commented Jul 29, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Summary

Uh oh!

semanticdiff-com Bot commented Jul 29, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

github-actions Bot commented Jul 29, 2026

🔍 Binding Differences Detected

Uh oh!

github-actions Bot commented Jul 29, 2026

🔍 Binding Differences Detected

Uh oh!

github-actions Bot commented Jul 29, 2026

🔍 Binding Differences Detected

@@ -142,7 +142,6 @@ pub(crate) fn event_handler_inner<P: IntoScriptPluginParams>( for event in events.into_iter().filter(|e| { e.label == callback_label && e.language.as_ref().is_none_or(|l| l == &P::LANGUAGE) }) {

@@ -183,7 +182,7 @@ pub(crate) fn event_handler_inner<P: IntoScriptPluginParams>( .with_type_info_context(Some("args: "), event.args.clone()) .with_language(P::LANGUAGE) });

Uh oh!

github-actions Bot commented Jul 29, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Bencher Report

⚠️ WARNING: Truncated view!

🚨 14 Alerts

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

makspll commented Jul 29, 2026 •

edited

Loading

semanticdiff-com Bot commented Jul 29, 2026 •

edited

Loading

@@ -142,7 +142,6 @@ pub(crate) fn event_handler_inner<P: IntoScriptPluginParams>(
for event in events.into_iter().filter(|e| {
e.label == callback_label && e.language.as_ref().is_none_or(|l| l == &P::LANGUAGE)
}) {

@@ -183,7 +182,7 @@ pub(crate) fn event_handler_inner<P: IntoScriptPluginParams>(
.with_type_info_context(Some("args: "), event.args.clone())
.with_language(P::LANGUAGE)
});

github-actions Bot commented Jul 29, 2026 •

edited

Loading