feat!: bevy 0.18 #507

makspll · 2026-01-25T15:23:56Z

Summary

A straightforward bevy bump

semanticdiff-com · 2026-01-25T15:23:59Z

Review changes with

Changed Files

File	Status
crates/bevy_mod_scripting_display/src/printer/mod.rs	93% smaller
crates/testing_crates/script_integration_test_harness/src/scenario.rs	92% smaller
assets/tests/query/query_can_access_components.lua	89% smaller
assets/tests/query/dynamic_component_query.lua	88% smaller
assets/tests/query/query_returns_all_entities_matching.lua	88% smaller
crates/bindings/bevy_sprite_bms_bindings/src/lib.rs	84% smaller
crates/bindings/bevy_math_bms_bindings/src/lib.rs	81% smaller
crates/bevy_mod_scripting_asset/src/loader.rs	67% smaller
crates/bindings/bevy_ecs_bms_bindings/src/lib.rs	30% smaller
crates/bindings/bevy_ui_bms_bindings/src/lib.rs	28% smaller
crates/bevy_mod_scripting_bindings/src/reference.rs	17% smaller
crates/bindings/bevy_text_bms_bindings/src/lib.rs	9% smaller
crates/bindings/bevy_camera_bms_bindings/src/lib.rs	7% smaller
crates/bindings/bevy_animation_bms_bindings/src/lib.rs	5% smaller
crates/bindings/bevy_input_focus_bms_bindings/src/lib.rs	1% smaller
Cargo.toml	Unsupported file format
codegen/Cargo.bootstrap.toml	Unsupported file format
codegen/src/args.rs	0% smaller
codegen_bevy_features.txt	Unsupported file format
crates/bevy_mod_scripting_bindings/src/error.rs	0% smaller
crates/bevy_mod_scripting_bindings/src/script_component.rs	0% smaller
crates/bevy_mod_scripting_bindings/src/world.rs	0% smaller
crates/bevy_mod_scripting_core/src/script_system.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_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_core_pipeline_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_core_pipeline_bms_bindings/src/lib.rs	0% smaller
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_gltf_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_image_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_image_bms_bindings/src/lib.rs	0% smaller
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_light_bms_bindings/Cargo.toml	Unsupported file format
crates/bindings/bevy_light_bms_bindings/src/lib.rs	0% smaller
crates/bindings/bevy_math_bms_bindings/Cargo.toml	Unsupported file format
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_pbr_bms_bindings/src/lib.rs	0% smaller
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_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_time_bms_bindings/src/lib.rs	0% smaller
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/ladfile_builder/Cargo.toml	Unsupported file format
crates/testing_crates/test_utils/src/test_data.rs	0% smaller
docs/src/ReleaseNotes/0.17-to-0.18.md	Unsupported file format
docs/src/ReleaseNotes/0.18.0.md	Unsupported file format
examples/game_of_life.rs	0% smaller
examples/script_loading.rs	0% smaller
readme.md	Unsupported file format
rust-toolchain.toml	Unsupported file format

github-actions · 2026-01-25T15:48:35Z

🔍 Binding Differences Detected

The following changes were detected in generated bindings:

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

index 7b7f72c..f041856 100644
--- a/crates/bindings/bevy_a11y_bms_bindings/src/lib.rs
+++ b/crates/bindings/bevy_a11y_bms_bindings/src/lib.rs
@@ -1,18 +1,15 @@
-
 #![allow(clippy::all)]
 #![allow(unused, deprecated, dead_code)]




+use bevy_app::{App, Plugin};

+use bevy_ecs::prelude::*;

use bevy_mod_scripting_bindings::{

ReflectReference,

function::{


   from::{Ref, Mut, Val},





   from::{Mut, Ref, Val},
   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 +80,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: Ref<::bevy_a11y::ManageAccessibilityUpdates>| {



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



               {



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



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "get",



       |_self: Ref<::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: Mut<::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: Ref<::bevy_a11y::ManageAccessibilityUpdates>| {



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



           {



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



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



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "get",



   |_self: Ref<::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: Mut<::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 69af35e..571ddc3 100644
--- a/crates/bindings/bevy_animation_bms_bindings/src/lib.rs
+++ b/crates/bindings/bevy_animation_bms_bindings/src/lib.rs
@@ -1,41 +1,39 @@
-
 #![allow(clippy::all)]
 #![allow(unused, deprecated, dead_code)]




+use bevy_app::{App, Plugin};

+use bevy_ecs::prelude::*;

use bevy_mod_scripting_bindings::{

ReflectReference,

function::{


   from::{Ref, Mut, Val},





   from::{Mut, Ref, Val},
   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: Ref<::bevy_animation::graph::AnimationNodeType>| {



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



               {



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



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



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



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



           {



               let output: Val<::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 +124,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: Ref<::bevy_animation::AnimationClip>| {



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



               {



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



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "duration",



       |_self: Ref<::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: Mut<::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: Ref<::bevy_animation::AnimationClip>| {



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



           {



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



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



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "duration",



   |_self: Ref<::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: Mut<::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 +182,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: Ref<::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: Ref<::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: Ref<::bevy_animation::AnimationPlayer>| {



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



               {



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



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "clone_from",



       |



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



           source: Ref<::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: Ref<::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: Ref<::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: Ref<::bevy_animation::AnimationPlayer>| {



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



           {



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



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



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "clone_from",



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



    source: Ref<::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 +408,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: Ref<::bevy_animation::AnimatedBy>| {



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



               {



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



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



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



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



           {



               let output: Val<::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_asset_bms_bindings/src/lib.rs

index 4c474c9..b76822a 100644
--- a/crates/bindings/bevy_asset_bms_bindings/src/lib.rs
+++ b/crates/bindings/bevy_asset_bms_bindings/src/lib.rs
@@ -1,18 +1,15 @@
-
 #![allow(clippy::all)]
 #![allow(unused, deprecated, dead_code)]




+use bevy_app::{App, Plugin};

+use bevy_ecs::prelude::*;

use bevy_mod_scripting_bindings::{

ReflectReference,

function::{


   from::{Ref, Mut, Val},





   from::{Mut, Ref, Val},
   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) {

@@ -102,60 +99,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: Ref<::bevy_asset::UntypedAssetId>| {



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



               {



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



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: Ref<::bevy_asset::UntypedAssetId>,



           other: Ref<::bevy_asset::UntypedAssetId>|



       {



           let output: bool = {



               {



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



                       ::bevy_asset::UntypedAssetId,



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



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   )



   .register_documented(



       "type_id",



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



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



               {



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



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



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



       &["_self"],



   );




.register_documented(

   "clone",



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



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



           {



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



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



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



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



       let output: bool = {



           {



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



                   ::bevy_asset::UntypedAssetId,



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



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


)
.register_documented(

   "type_id",



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



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



           {



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



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



               output



           }



       };



       output



   },



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



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

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

index e3b497c..edef7e2 100644
--- a/crates/bindings/bevy_camera_bms_bindings/src/lib.rs
+++ b/crates/bindings/bevy_camera_bms_bindings/src/lib.rs
@@ -1,18 +1,15 @@
-
 #![allow(clippy::all)]
 #![allow(unused, deprecated, dead_code)]




+use bevy_app::{App, Plugin};

+use bevy_ecs::prelude::*;

use bevy_mod_scripting_bindings::{

ReflectReference,

function::{


   from::{Ref, Mut, Val},





   from::{Mut, Ref, Val},
   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) {

@@ -423,10 +420,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::<

@@ -490,23 +485,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: Ref<::bevy_camera::ClearColorConfig>| {



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



               {



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



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



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



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



           {



               let output: Val<::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

@@ -644,23 +638,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: Ref<::bevy_camera::PerspectiveProjection>| {



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



               {



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



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



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



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



           {



               let output: Val<::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

@@ -882,126 +877,117 @@ pub(crate) fn register_visible_entities_functions(world: &mut World) {

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

::bevy_camera::visibility::VisibleEntities,

::new(world)





   .register_documented(



       "clear",



       |



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



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



       {



           let output: () = {



               {



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



                           &mut _self,



                           type_id.into_inner(),



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "type_id"],



   )



   .register_documented(



       "clear_all",



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



           let output: () = {



               {



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



                           &mut _self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "clone",



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



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



               {



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



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "is_empty",



       |



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



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



       {



           let output: bool = {



               {



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



                           &_self,



                           type_id.into_inner(),



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "type_id"],



   )



   .register_documented(



       "len",



       |



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



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



       {



           let output: usize = {



               {



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



                           &_self,



                           type_id.into_inner(),



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "type_id"],



   )



   .register_documented(



       "push",



       |



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



           entity: Val<::bevy_ecs::entity::Entity>,



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



       {



           let output: () = {



               {



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



                           &mut _self,



                           entity.into_inner(),



                           type_id.into_inner(),



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



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



   );




.register_documented(

   "clear",



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



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



       let output: () = {



           {



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



                   &mut _self,



                   type_id.into_inner(),



               )



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "type_id"],


)
.register_documented(

   "clear_all",



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



       let output: () = {



           {



               let output: () =



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



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "clone",



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



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



           {



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



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



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "is_empty",



   |_self: Ref<::bevy_camera::visibility::VisibleEntities>,



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



       let output: bool = {



           {



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



                   &_self,



                   type_id.into_inner(),



               )



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "type_id"],


)
.register_documented(

   "len",



   |_self: Ref<::bevy_camera::visibility::VisibleEntities>,



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



       let output: usize = {



           {



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



                   &_self,



                   type_id.into_inner(),



               )



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "type_id"],


)
.register_documented(

   "push",



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



    entity: Val<::bevy_ecs::entity::Entity>,



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



       let output: () = {



           {



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



                   &mut _self,



                   entity.into_inner(),



                   type_id.into_inner(),



               )



               .into();



               output



           }



       };



       output



   },



   "",



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


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1073,43 +1059,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: Ref<::bevy_camera::SubCameraView>| {



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



               {



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



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: Ref<::bevy_camera::SubCameraView>,



           other: Ref<::bevy_camera::SubCameraView>|



       {



           let output: bool = {



               {



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



                       ::bevy_camera::SubCameraView,



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



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   );




.register_documented(

   "clone",



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



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



           {



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



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



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



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



       let output: bool = {



           {



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



                   ::bevy_camera::SubCameraView,



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



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1166,23 +1147,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: Ref<::bevy_camera::CameraMainTextureUsages>| {



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



               {



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



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



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



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



           {



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



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



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1224,23 +1206,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: Ref<::bevy_camera::CameraOutputMode>| {



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



               {



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



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



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



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



           {



               let output: Val<::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

@@ -1253,43 +1234,41 @@ 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: Ref<::bevy_camera::ImageRenderTarget>| {



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



               {



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



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: Ref<::bevy_camera::ImageRenderTarget>,



           other: Ref<::bevy_camera::ImageRenderTarget>|



       {



           let output: bool = {



               {



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




.register_documented(

   "clone",



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



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



           {



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



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



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: Ref<::bevy_camera::ImageRenderTarget>,



    other: Ref<::bevy_camera::ImageRenderTarget>| {



       let output: bool = {



           {



               let output: bool =



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





                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   );





                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1434,23 +1413,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: Ref<::bevy_camera::Camera3dDepthLoadOp>| {



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



               {



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



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



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



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



           {



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



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



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1463,23 +1441,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: Ref<::bevy_camera::Camera3dDepthTextureUsage>| {



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



               {



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



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



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



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



           {



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



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



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1541,118 +1520,110 @@ pub(crate) fn register_aabb_functions(world: &mut World) {

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

::bevy_camera::primitives::Aabb,

::new(world)





   .register_documented(



       "clone",



       |_self: Ref<::bevy_camera::primitives::Aabb>| {



           let output: Val<::bevy_camera::primitives::Aabb> = {



               {



                   let output: Val<::bevy_camera::primitives::Aabb> = <::bevy_camera::primitives::Aabb as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "eq",



       |



           _self: Ref<::bevy_camera::primitives::Aabb>,



           other: Ref<::bevy_camera::primitives::Aabb>|



       {



           let output: bool = {



               {



                   let output: bool = <::bevy_camera::primitives::Aabb as ::std::cmp::PartialEq<



                       ::bevy_camera::primitives::Aabb,



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



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self", "other"],



   )



   .register_documented(



       "from_min_max",



       |minimum: Val<::bevy_math::Vec3>, maximum: Val<::bevy_math::Vec3>| {



           let output: Val<::bevy_camera::primitives::Aabb> = {



               {



                   let output: Val<::bevy_camera::primitives::Aabb> = ::bevy_camera::primitives::Aabb::from_min_max(



                           minimum.into_inner(),



                           maximum.into_inner(),



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["minimum", "maximum"],



   )



   .register_documented(



       "max",



       |_self: Ref<::bevy_camera::primitives::Aabb>| {



           let output: Val<::bevy_math::Vec3A> = {



               {



                   let output: Val<::bevy_math::Vec3A> = ::bevy_camera::primitives::Aabb::max(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "min",



       |_self: Ref<::bevy_camera::primitives::Aabb>| {



           let output: Val<::bevy_math::Vec3A> = {



               {



                   let output: Val<::bevy_math::Vec3A> = ::bevy_camera::primitives::Aabb::min(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   )



   .register_documented(



       "relative_radius",



       |



           _self: Ref<::bevy_camera::primitives::Aabb>,



           p_normal: Ref<::bevy_math::Vec3A>,



           world_from_local: Ref<::bevy_math::Mat3A>|



       {



           let output: f32 = {



               {



                   let output: f32 = ::bevy_camera::primitives::Aabb::relative_radius(



                           &_self,



                           &p_normal,



                           &world_from_local,



                       )



                       .into();



                   output



               }



           };



           output



       },



       " Calculate the relative radius of the AABB with respect to a plane",



       &["_self", "p_normal", "world_from_local"],



   );




.register_documented(

   "clone",



   |_self: Ref<::bevy_camera::primitives::Aabb>| {



       let output: Val<::bevy_camera::primitives::Aabb> = {



           {



               let output: Val<::bevy_camera::primitives::Aabb> =



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



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "eq",



   |_self: Ref<::bevy_camera::primitives::Aabb>,



    other: Ref<::bevy_camera::primitives::Aabb>| {



       let output: bool = {



           {



               let output: bool = <::bevy_camera::primitives::Aabb as ::std::cmp::PartialEq<



                   ::bevy_camera::primitives::Aabb,



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



               .into();



               output



           }



       };



       output



   },



   "",



   &["_self", "other"],


)
.register_documented(

   "from_min_max",



   |minimum: Val<::bevy_math::Vec3>, maximum: Val<::bevy_math::Vec3>| {



       let output: Val<::bevy_camera::primitives::Aabb> = {



           {



               let output: Val<::bevy_camera::primitives::Aabb> =



                   ::bevy_camera::primitives::Aabb::from_min_max(



                       minimum.into_inner(),



                       maximum.into_inner(),



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["minimum", "maximum"],


)
.register_documented(

   "max",



   |_self: Ref<::bevy_camera::primitives::Aabb>| {



       let output: Val<::bevy_math::Vec3A> = {



           {



               let output: Val<::bevy_math::Vec3A> =



                   ::bevy_camera::primitives::Aabb::max(&_self).into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "min",



   |_self: Ref<::bevy_camera::primitives::Aabb>| {



       let output: Val<::bevy_math::Vec3A> = {



           {



               let output: Val<::bevy_math::Vec3A> =



                   ::bevy_camera::primitives::Aabb::min(&_self).into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


)
.register_documented(

   "relative_radius",



   |_self: Ref<::bevy_camera::primitives::Aabb>,



    p_normal: Ref<::bevy_math::Vec3A>,



    world_from_local: Ref<::bevy_math::Mat3A>| {



       let output: f32 = {



           {



               let output: f32 = ::bevy_camera::primitives::Aabb::relative_radius(



                   &_self,



                   &p_normal,



                   &world_from_local,



               )



               .into();



               output



           }



       };



       output



   },



   " Calculate the relative radius of the AABB with respect to a plane",



   &["_self", "p_normal", "world_from_local"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1665,23 +1636,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: Ref<::bevy_camera::primitives::CubemapFrusta>| {



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



               {



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



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



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



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



           {



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



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



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1694,23 +1666,24 @@ pub(crate) fn register_cubemap_layout_functions(world: &mut World) {

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

::bevy_camera::primitives::CubemapLayout,

::new(world)





   .register_documented(



       "clone",



       |_self: Ref<::bevy_camera::primitives::CubemapLayout>| {



           let output: Val<::bevy_camera::primitives::CubemapLayout> = {



               {



                   let output: Val<::bevy_camera::primitives::CubemapLayout> = <::bevy_camera::primitives::CubemapLayout as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: Ref<::bevy_camera::primitives::CubemapLayout>| {



       let output: Val<::bevy_camera::primitives::CubemapLayout> = {



           {



               let output: Val<::bevy_camera::primitives::CubemapLayout> =



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



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1723,23 +1696,24 @@ pub(crate) fn register_cascades_frusta_functions(world: &mut World) {

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

::bevy_camera::primitives::CascadesFrusta,

::new(world)





   .register_documented(



       "clone",



       |_self: Ref<::bevy_camera::primitives::CascadesFrusta>| {



           let output: Val<::bevy_camera::primitives::CascadesFrusta> = {



               {



                   let output: Val<::bevy_camera::primitives::CascadesFrusta> = <::bevy_camera::primitives::CascadesFrusta as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: Ref<::bevy_camera::primitives::CascadesFrusta>| {



       let output: Val<::bevy_camera::primitives::CascadesFrusta> = {



           {



               let output: Val<::bevy_camera::primitives::CascadesFrusta> =



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



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1752,23 +1726,22 @@ pub(crate) fn register_custom_projection_functions(world: &mut World) {

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

::bevy_camera::CustomProjection,

::new(world)





   .register_documented(



       "clone",



       |_self: Ref<::bevy_camera::CustomProjection>| {



           let output: Val<::bevy_camera::CustomProjection> = {



               {



                   let output: Val<::bevy_camera::CustomProjection> = <::bevy_camera::CustomProjection as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: Ref<::bevy_camera::CustomProjection>| {



       let output: Val<::bevy_camera::CustomProjection> = {



           {



               let output: Val<::bevy_camera::CustomProjection> =



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



                       .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1810,23 +1783,24 @@ pub(crate) fn register_visibility_class_functions(world: &mut World) {

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

::bevy_camera::visibility::VisibilityClass,

::new(world)





   .register_documented(



       "clone",



       |_self: Ref<::bevy_camera::visibility::VisibilityClass>| {



           let output: Val<::bevy_camera::visibility::VisibilityClass> = {



               {



                   let output: Val<::bevy_camera::visibility::VisibilityClass> = <::bevy_camera::visibility::VisibilityClass as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: Ref<::bevy_camera::visibility::VisibilityClass>| {



       let output: Val<::bevy_camera::visibility::VisibilityClass> = {



           {



               let output: Val<::bevy_camera::visibility::VisibilityClass> =



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



                       &_self,



                   )



                   .into();



               output



           }



       };



       output



   },



   "",



   &["_self"],


);

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry

@@ -1944,23 +1918,24 @@ pub(crate) fn register_no_auto_aabb_functions(world: &mut World) {

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

::bevy_camera::visibility::NoAutoAabb,

::new(world)





   .register_documented(



       "clone",



       |_self: Ref<::bevy_camera::visibility::NoAutoAabb>| {



           let output: Val<::bevy_camera::visibility::NoAutoAabb> = {



               {



                   let output: Val<::bevy_camera::visibility::NoAutoAabb> = <::bevy_camera::visibility::NoAutoAabb as ::std::clone::Clone>::clone(



                           &_self,



                       )



                       .into();



                   output



               }



           };



           output



       },



       "",



       &["_self"],



   );




.register_documented(

   "clone",



   |_self: Ref<::bevy_camera::visibility::NoAutoAabb>| {



       let output: Val<::bevy_camera::visibility::NoAutoAabb> = {



           {



               let output: Val<::bevy_camera::visibility::NoAutoAabb> =



                   <::bevy_camera::visibility::NoAutoAabb 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_color_bms_bindings/src/lib.rs

index 7d513da..b2a8298 100644
--- a/crates/bindings/bevy_color_bms_bindings/src/lib.rs
+++ b/crates/bindings/bevy_color_bms_bindings/src/lib.rs
@@ -1,18 +1,15 @@
-
 #![allow(clippy::all)]
 #![allow(unused, deprecated, dead_code)]




+use bevy_app::{App, Plugin};

+use bevy_ecs::prelude::*;

use bevy_mod_scripting_bindings::{

ReflectReference,

function::{


   from::{Ref, Mut, Val},





   from::{Mut, Ref, Val},
   namespace::NamespaceBuilder,

},

};

-use bevy_ecs::prelude::*;

-use bevy_app::{App, Plugin};

use bevy_mod_scripting_derive::script_bindings;

pub struct BevyColorScriptingPlugin;

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

@@ -536,10 +533,7 @@ pub(crate) fn register_color_functions(world: &mut World) {

let registry = world.get_resource_or_init::();

let mut registry = registry.write();

registry



   .register_type_data::<



       ::bevy_color::Color,



       bevy_mod_scripting_bindings::MarkAsGenerated,



   >();





   .register_type_data::<::bevy_color::Color, bevy_mod_scripting_bindings::MarkAsGenerated>();



}

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

bevy_mod_scripting_bindings::function::namespa...[Comment body truncated]

github-actions · 2026-01-25T17:44:34Z

Bencher Report

Branch	feat/bevy-0.18
Testbed	linux-gha

Click to view all benchmark results

Benchmark	Latency	Benchmark Result nanoseconds (ns) (Result Δ%)	Upper Boundary nanoseconds (ns) (Limit %)
component/access Lua	📈 view plot 🚷 view threshold	6,047.20 ns (+15.98%) Baseline: 5,214.08 ns	7,236.22 ns (83.57%)
component/access Rhai	📈 view plot 🚷 view threshold	9,062.90 ns (+18.80%) Baseline: 7,628.40 ns	11,946.10 ns (75.86%)
component/get Lua	📈 view plot 🚷 view threshold	3,151.30 ns (+6.12%) Baseline: 2,969.56 ns	3,329.92 ns (94.64%)
component/get Rhai	📈 view plot 🚷 view threshold	7,842.70 ns (+25.67%) Baseline: 6,240.72 ns	10,800.39 ns (72.61%)
conversions/Mut::from	📈 view plot 🚷 view threshold	85.51 ns (-11.98%) Baseline: 97.15 ns	124.27 ns (68.81%)
conversions/Ref::from	📈 view plot 🚷 view threshold	82.10 ns (-12.59%) Baseline: 93.92 ns	119.41 ns (68.75%)
conversions/ScriptValue::List	📈 view plot 🚷 view threshold	392.33 ns (-0.80%) Baseline: 395.50 ns	455.53 ns (86.13%)
conversions/ScriptValue::Map	📈 view plot 🚷 view threshold	1,059.40 ns (-9.21%) Baseline: 1,166.89 ns	1,404.60 ns (75.42%)
conversions/ScriptValue::Reference::from_into	📈 view plot 🚷 view threshold	24.63 ns (-9.79%) Baseline: 27.30 ns	33.42 ns (73.69%)
conversions/Val::from_into	📈 view plot 🚷 view threshold	295.96 ns (-3.25%) Baseline: 305.89 ns	397.99 ns (74.36%)
function/call 4 args Lua	📈 view plot 🚷 view threshold	1,958.90 ns (-5.37%) Baseline: 2,070.00 ns	2,482.19 ns (78.92%)
function/call 4 args Rhai	📈 view plot 🚷 view threshold	1,442.50 ns (-5.33%) Baseline: 1,523.75 ns	1,740.90 ns (82.86%)
function/call Lua	📈 view plot 🚷 view threshold	428.37 ns (+3.66%) Baseline: 413.26 ns	503.70 ns (85.04%)
function/call Rhai	📈 view plot 🚷 view threshold	432.84 ns (-9.71%) Baseline: 479.40 ns	553.44 ns (78.21%)
loading/empty Lua	📈 view plot 🚷 view threshold	1,049,400.00 ns (-12.01%) Baseline: 1,192,686.00 ns	2,023,672.25 ns (51.86%)
loading/empty Rhai	📈 view plot 🚷 view threshold	1,235,800.00 ns (-16.23%) Baseline: 1,475,254.00 ns	2,622,056.14 ns (47.13%)
math/vec mat ops Lua	📈 view plot 🚷 view threshold	9,745.90 ns (+5.96%) Baseline: 9,197.87 ns	11,431.04 ns (85.26%)
math/vec mat ops Rhai	📈 view plot 🚷 view threshold	9,481.40 ns (+11.48%) Baseline: 8,504.75 ns	11,547.51 ns (82.11%)
query/10 entities Lua	📈 view plot 🚷 view threshold	21,711.00 ns (-10.62%) Baseline: 24,291.80 ns	28,607.67 ns (75.89%)
query/10 entities Rhai	📈 view plot 🚷 view threshold	29,309.00 ns (+13.89%) Baseline: 25,733.80 ns	35,538.12 ns (82.47%)
query/100 entities Lua	📈 view plot 🚷 view threshold	43,215.00 ns (-5.80%) Baseline: 45,873.90 ns	52,440.11 ns (82.41%)
query/100 entities Rhai	📈 view plot 🚷 view threshold	42,481.00 ns (+6.68%) Baseline: 39,819.60 ns	49,098.62 ns (86.52%)
query/1000 entities Lua	📈 view plot 🚷 view threshold	270,170.00 ns (-6.81%) Baseline: 289,907.00 ns	356,562.06 ns (75.77%)
query/1000 entities Rhai	📈 view plot 🚷 view threshold	176,380.00 ns (-5.24%) Baseline: 186,139.00 ns	211,864.12 ns (83.25%)
reflection/10 Lua	📈 view plot 🚷 view threshold	5,416.60 ns (-8.13%) Baseline: 5,896.05 ns	7,034.33 ns (77.00%)
reflection/10 Rhai	📈 view plot 🚷 view threshold	15,210.00 ns (-2.31%) Baseline: 15,569.40 ns	17,350.84 ns (87.66%)
reflection/100 Lua	📈 view plot 🚷 view threshold	45,754.00 ns (-8.16%) Baseline: 49,819.20 ns	60,206.37 ns (76.00%)
reflection/100 Rhai	📈 view plot 🚷 view threshold	643,870.00 ns (-11.21%) Baseline: 725,197.00 ns	987,156.87 ns (65.22%)
resource/access Lua	📈 view plot 🚷 view threshold	3,925.10 ns (-3.18%) Baseline: 4,054.08 ns	4,339.11 ns (90.46%)
resource/access Rhai	📈 view plot 🚷 view threshold	8,568.80 ns (+22.32%) Baseline: 7,005.32 ns	11,109.60 ns (77.13%)
resource/get Lua	📈 view plot 🚷 view threshold	2,566.10 ns (-0.25%) Baseline: 2,572.41 ns	2,938.48 ns (87.33%)
resource/get Rhai	📈 view plot 🚷 view threshold	7,360.60 ns (+28.41%) Baseline: 5,731.91 ns	10,204.90 ns (72.13%)

🐰 View full continuous benchmarking report in Bencher

makspll added 2 commits January 25, 2026 15:24

feat!: initial bevy bump

ac2ab3f

bump bevy console

d92291e

makspll force-pushed the feat/bevy-0.18 branch from ad7ca65 to d92291e Compare January 25, 2026 15:24

makspll added 6 commits January 25, 2026 16:23

fmt bindings

ce30289

fmt bindings

9651afa

fix examples

90164ab

fix test setup

92070a9

fix tests affected by bindings changes

c48c8f4

upgrade docs

83e6067

makspll enabled auto-merge (squash) January 25, 2026 17:28

makspll merged commit fe70244 into main Jan 25, 2026
26 checks passed

makspll deleted the feat/bevy-0.18 branch January 25, 2026 18:18

This was referenced Jan 25, 2026

chore: release v0.19.0 #506

Merged

chore: release v0.19.1 #508

Open

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

feat!: bevy 0.18 #507

feat!: bevy 0.18 #507

Uh oh!

makspll commented Jan 25, 2026

Uh oh!

semanticdiff-com bot commented Jan 25, 2026 •

edited

Loading

Uh oh!

github-actions bot commented Jan 25, 2026

Uh oh!

github-actions bot commented Jan 25, 2026 •

edited

Loading

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

Uh oh!

feat!: bevy 0.18 #507

feat!: bevy 0.18 #507

Uh oh!

Conversation

makspll commented Jan 25, 2026

Summary

Uh oh!

semanticdiff-com bot commented Jan 25, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

github-actions bot commented Jan 25, 2026

🔍 Binding Differences Detected

Uh oh!

github-actions bot commented Jan 25, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Bencher Report

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

semanticdiff-com bot commented Jan 25, 2026 •

edited

Loading

github-actions bot commented Jan 25, 2026 •

edited

Loading