diff --git a/Cargo.toml b/Cargo.toml index 71a2c6a..c2a2ef9 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -3,6 +3,7 @@ members = [ "crates/bevy_gltf_components", "crates/bevy_gltf_blueprints", "crates/bevy_gltf_save_load", + "crates/bevy_registry_export", "examples/bevy_gltf_components/basic/", "examples/bevy_gltf_components/basic_wasm/", "examples/bevy_gltf_blueprints/basic/", @@ -15,6 +16,7 @@ members = [ "examples/bevy_gltf_blueprints/multiple_levels_multiple_blendfiles", "examples/bevy_gltf_blueprints/materials/", "examples/bevy_gltf_save_load/basic/", + "examples/bevy_registry_export/basic" ] resolver = "2" diff --git a/README-workflow-classic.md b/README-workflow-classic.md new file mode 100644 index 0000000..3eab7e1 --- /dev/null +++ b/README-workflow-classic.md @@ -0,0 +1,73 @@ +# Workflow: classic + +The workflow goes as follows (once you got your Bevy code setup) + +- create & register all your components you want to be able to set from the Blender side (this is basic Bevy, no specific work needed) + +![component registration](./docs/component_registration.png) + +## Component creation +- Create an object / collection (for reuse) in Blender +- Go to object properties => add a property, and add your component data + - unit structs, enums, and more complex strucs / components are all supported, (if the fields are basic data types at least, + have not tried more complex ones yet, but should also work) + - for structs with no params (unit structs): use a **STRING** property & an empty value + - for structs with params: use a RON representation of your fields (see below) + - for tupple strucs you can use any of the built in Blender custom property types: Strings, Booleans, floats, Vectors, etc + + ![unit struct components in Blender](./docs/components_blender.png) + + In rust: + + ![unit struct components in Bevy](./docs/demo_simple_components.png) + + (the Rust struct for these components for reference is [here](./examples/basic/game.rs#34) ) + + + ![complex components in Blender](./docs/components_blender_parameters.png) + + In rust: + + ![complex components in Blender](./docs/camera_tracking_component.png) + + (the Rust struct for this component for reference is [here](./examples/basic/core/camera/camera_tracking.rs#21) ) + + There is an other examples of using various Component types: Enums, Tupple structs, strucs with fields etc [here](./examples/basic/test_components.rs), + even colors, Vecs (arrays), Vec2, Vec3 etc are all supported + + ![complex components in Blender](./docs/components_blender_parameters2.png) + +- for collections & their instances: + * I usually create a library scene with nested collections + * the leaf collections are the assets you use in your level + * add an empty called xxxx_components + * add the components as explained in the previous part + + ![blender collection asset](./docs/blender_collections.png) + + * In the Level/world itself, just create an instance of the collection (standard Blender, ie Shift+A -> collection instance -> pick the collection) + +## Exporting to gltf + +- export your level as a glb/gltf file : + - using Blender's default gltf exporter + !!**IMPORTANT** you need to check the following: + - custom properties + - cameras & lights if you want a complete level (as in this example) + ![gltf_export](./docs/gltf_export.png) + - or much better, using [gltf_auto_export](./tools/gltf_auto_export/) + +## Now use your gltf files in Bevy + +- load it in Bevy (see the various examples for this) +- you should see the components attached to your entities in Bevy + +![components in bevy](./docs/components_bevy.png) +![components in bevy](./docs/components_bevy2.png) +![components in bevy](./docs/components_bevy3.png) + + +> note: you get a warning if there are any unregistered components in your gltf file (they get ignored) +you will get a warning **per entity** + +![missing components warnings](./docs/component_warnings.png) diff --git a/README-workflow-ui.md b/README-workflow-ui.md new file mode 100644 index 0000000..268bb1d --- /dev/null +++ b/README-workflow-ui.md @@ -0,0 +1,40 @@ +# Workflow: UI + +The workflow goes as follows (once you got your Bevy code setup) + +## Bevy side +- create & register all your components you want to be able to set from the Blender side (this is basic Bevy, no specific work needed) +- follow the instructions in the [bevy_registry_export](./crates/bevy_registry_export/) to generate a registry export + +## Component creation + +Setup the Blender [bevy_components](./tools/bevy_components/README.md) add-on +to add & edit your components visually & reliably + +![bevy_components](./docs/bevy_components.png) + + +## Exporting to gltf + +- export your level as a glb/gltf file : + - using Blender's default gltf exporter + !!**IMPORTANT** you need to check the following: + - custom properties + - cameras & lights if you want a complete level (as in this example) + ![gltf_export](./docs/gltf_export.png) + - or much better, using [gltf_auto_export](./tools/gltf_auto_export/) + +## Now use your gltf files in Bevy + +- load it in Bevy (see the various examples for this) +- you should see the components attached to your entities in Bevy + +![components in bevy](./docs/components_bevy.png) +![components in bevy](./docs/components_bevy2.png) +![components in bevy](./docs/components_bevy3.png) + + +> note: you get a warning if there are any unregistered components in your gltf file (they get ignored) +you will get a warning **per entity** + +![missing components warnings](./docs/component_warnings.png) diff --git a/README.md b/README.md index abb17cd..4703885 100644 --- a/README.md +++ b/README.md @@ -18,7 +18,8 @@ It also allows you to setup 'blueprints' in Blender by using collections (the re * Useful if you want to use Blender (or any editor allowing to export gltf with configurable gltf_extras) as your Editor * define Bevy components as custom properties in Blender (some visually , some using RON, though an older JSON version is also available) -* no plugin or extra tools needed in Blender (but I provide a [little Blender plugin](./tools/gltf_auto_export/README.md) to auto-export to gltf on save (and more !) if you want !) +* no plugin or extra tools needed in Blender (but I provide a [little Blender add-on](./tools/gltf_auto_export/README.md) to auto-export to gltf on save (and more !) if you want !) +* now also with a nice UI tool to add & edit Bevy components in [Blender](./tools/bevy_components/README.md) * define components in Blender Collections & override any of them in your collection instances if you want * ability to automatically turn your Blender collections into [gltf Blueprints](./crates/bevy_gltf_blueprints/README.md) for reuse * minimal setup & code, you can have something basic running fast @@ -29,18 +30,23 @@ It also allows you to setup 'blueprints' in Blender by using collections (the re ## Crates - [bevy_gltf_components](./crates/bevy_gltf_components/) This crate allows you to define components direclty inside gltf files and instanciate/inject the components on the Bevy side. -There is a [video tutorial/explanation](https://youtu.be/-lcScjQCA3c) if you want, or you can read the crate docs. -The examples for the crate are [here](./examples/bevy_gltf_components/) + + There is a [video tutorial/explanation](https://youtu.be/-lcScjQCA3c) if you want, or you can read the crate docs. + The examples for the crate are [here](./examples/bevy_gltf_components/) - [bevy_gltf_blueprints](./crates/bevy_gltf_blueprints/) This crate adds the ability to define Blueprints/Prefabs for Bevy inside gltf files and spawn them in Bevy. With the ability to override and add components when spawning, efficient "level" loading etc -There is a [video tutorial/explanation](https://youtu.be/CgyNtwgYwdM) for this one too, or you can read the crate docs -The examples for the crate are [here](./examples/bevy_gltf_blueprints/) -> Note: this is the recomended crate to use and uses ```bevy_gltf_components``` under the hood + + There is a [video tutorial/explanation](https://youtu.be/CgyNtwgYwdM) for this one too, or you can read the crate docs + The examples for the crate are [here](./examples/bevy_gltf_blueprints/) + > Note: this is the recomended crate to use and uses ```bevy_gltf_components``` under the hood - [bevy_gltf_save_load](./crates/bevy_gltf_save_load/) This crate adds the ability to save & load your game state in a relatively simple way, by leveraging the blueprint functionality of bevy_gltf_blueprints to only save a minimal subset of dynamic data, seperating dynamic & static parts of levels etc. The examples for the crate are [here](./examples/bevy_gltf_save_load/) -> Note: this uses ```bevy_gltf_blueprints``` under the hood + > Note: this uses ```bevy_gltf_blueprints``` under the hood + +- [bevy_registry_export](./crates/bevy_registry_export/) This crate adds the ability to export your project's Bevy registry to json, in order to be able to generate custom component UIs on the Blender side in the Blender [bevy_components](./tools/bevy_components/README.md) add-on + ## Tools @@ -51,6 +57,13 @@ The examples for the crate are [here](./examples/bevy_gltf_save_load/) Please read the [README]((./tools/gltf_auto_export/README.md)) of the add-on for installation & use instructions +### Blender: bevy_components + +- an add-on for Blender to allow easilly adding & editing Bevy components , using automatically generated UIs for each component + +Please read the [README]((./tools/bevy_components/README.md)) of the add-on for installation & use instructions + + ## Examples @@ -62,6 +75,12 @@ you can find all examples, by crate as seperate crates for clearer dependencies - [bevy_gltf_blueprints](./examples/bevy_gltf_blueprints/) * [basic](./examples/bevy_gltf_blueprints/basic/) more advanced example : use of ```bevy_gltf_blueprints``` to spawn a level and then populate it with entities coming from different gltf files, live (at runtime) spawning of entities etc * [animation](./examples/bevy_gltf_blueprints/animation/) how to use and trigger animations from gltf files (a feature of ```bevy_gltf_blueprints```) + * & lots more + +- [bevy_gltf_save_load](./examples/bevy_gltf_save_load/) + +- [bevy_registry_export](./examples/bevy_registry_export/) + ## Workflow @@ -70,74 +89,12 @@ The workflow goes as follows (once you got your Bevy code setup) - create & register all your components you want to be able to set from the Blender side (this is basic Bevy, no specific work needed) ![component registration](./docs/component_registration.png) -- Create an object / collection (for reuse) in Blender -- Go to object properties => add a property, and add your component data - - unit structs, enums, and more complex strucs / components are all supported, (if the fields are basic data types at least, - have not tried more complex ones yet, but should also work) - - for structs with no params (unit structs): use a **STRING** property & an empty value - - for structs with params: use a RON representation of your fields (see below) - - for tupple strucs you can use any of the built in Blender custom property types: Strings, Booleans, floats, Vectors, etc - - ![unit struct components in Blender](./docs/components_blender.png) - - In rust: - - ![unit struct components in Bevy](./docs/demo_simple_components.png) - - (the Rust struct for these components for reference is [here](./examples/basic/game.rs#34) ) - - - ![complex components in Blender](./docs/components_blender_parameters.png) - - In rust: - - ![complex components in Blender](./docs/camera_tracking_component.png) - - (the Rust struct for this component for reference is [here](./examples/basic/core/camera/camera_tracking.rs#21) ) - - There is an other examples of using various Component types: Enums, Tupple structs, strucs with fields etc [here](./examples/basic/test_components.rs), - even colors, Vecs (arrays), Vec2, Vec3 etc are all supported - - ![complex components in Blender](./docs/components_blender_parameters2.png) - -- for collections & their instances: - * I usually create a library scene with nested collections - * the leaf collections are the assets you use in your level - * add an empty called xxxx_components - * add the components as explained in the previous part - - ![blender collection asset](./docs/blender_collections.png) - - * In the Level/world itself, just create an instance of the collection (standard Blender, ie Shift+A -> collection instance -> pick the collection) - - -- export your level as a glb/gltf file : - - using Blender's default gltf exporter - !!**IMPORTANT** you need to check the following: - - custom properties - - cameras & lights if you want a complete level (as in this example) - ![gltf_export](./docs/gltf_export.png) - - or much better, using [gltf_auto_export](./tools/gltf_auto_export/) - - - -- load it in Bevy (see the demo main file for this) -- you should see the components attached to your entities in Bevy - -![components in bevy](./docs/components_bevy.png) -![components in bevy](./docs/components_bevy2.png) -![components in bevy](./docs/components_bevy3.png) - - -> note: you get a warning if there are any unregistered components in your gltf file (they get ignored) -you will get a warning **per entity** - -![missing components warnings](./docs/component_warnings.png) - +- then you have two options + - add your components to objects in Blender **manually** as **custom properties** : see [here](./README-workflow-classic.md) for more details + - add your components to objects in Blender **with a nice UI** see [here](./README-workflow-ui.md) for more details ## Limitations / issues -- some components have to be defined in ```text``` in Blender, might try using the AppTypeRegistry and some Python code on the Blender side for a nicer UI (although this loses the "fast & easy, no tooling" approach) - Some of `bevy_rapier`/physics code / ways to define colliders could perhaps be done better/visually within Blender (currently it also goes via RON) ## Future work @@ -153,6 +110,9 @@ Thanks to all the contributors helping out with this project ! Big kudos to you, - [GitGhillie](https://github.com/GitGhillie) - [Azorlogh](https://github.com/Azorlogh) +- [BSDGuyShawn](https://github.com/BSDGuyShawn) +- [yukkop](https://github.com/yukkop) +- [killercup](https://github.com/killercup) ## License diff --git a/crates/bevy_gltf_blueprints/Cargo.toml b/crates/bevy_gltf_blueprints/Cargo.toml index 15b99df..bee65b1 100644 --- a/crates/bevy_gltf_blueprints/Cargo.toml +++ b/crates/bevy_gltf_blueprints/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "bevy_gltf_blueprints" -version = "0.6.0" +version = "0.7.0" authors = ["Mark 'kaosat-dev' Moissette"] description = "Adds the ability to define Blueprints/Prefabs for [Bevy](https://bevyengine.org/) inside gltf files and spawn them in Bevy." homepage = "https://github.com/kaosat-dev/Blender_bevy_components_workflow" @@ -17,5 +17,6 @@ workspace = true bevy = { version = "0.12", default-features = false, features = ["bevy_asset", "bevy_scene", "bevy_gltf", "bevy_animation", "animation"] } [dependencies] -bevy_gltf_components = "0.2" +bevy_gltf_components = "0.3" +#bevy_gltf_components = { path = "../bevy_gltf_components" } bevy = { version = "0.12", default-features = false, features = ["bevy_asset", "bevy_scene", "bevy_gltf", "bevy_animation", "animation"] } diff --git a/crates/bevy_gltf_blueprints/README.md b/crates/bevy_gltf_blueprints/README.md index 48ac9c1..59c57c7 100644 --- a/crates/bevy_gltf_blueprints/README.md +++ b/crates/bevy_gltf_blueprints/README.md @@ -26,7 +26,7 @@ Here's a minimal usage example: # Cargo.toml [dependencies] bevy="0.12" -bevy_gltf_blueprints = { version = "0.6"} +bevy_gltf_blueprints = { version = "0.7"} ``` @@ -64,7 +64,7 @@ fn spawn_blueprint( Add the following to your `[dependencies]` section in `Cargo.toml`: ```toml -bevy_gltf_blueprints = "0.6" +bevy_gltf_blueprints = "0.7" ``` Or use `cargo add`: @@ -307,6 +307,25 @@ see https://github.com/kaosat-dev/Blender_bevy_components_workflow/tree/main/exa Generating optimised blueprints and material libraries can be automated using the latests version of the [Blender plugin](https://github.com/kaosat-dev/Blender_bevy_components_workflow/tree/main/tools/gltf_auto_export) + +## Legacy mode + +Starting in version 0.7 there is a new parameter ```legacy_mode``` for backwards compatibility + +To disable the legacy mode: (enabled by default) + +```rust no_run +BlueprintsPlugin{legacy_mode: false} +``` + + +You **need** to disable legacy mode if you want to use the [```bevy_components```](https://github.com/kaosat-dev/Blender_bevy_components_workflow/tree/tools_bevy_blueprints/tools/bevy_components) Blender addon + the [```bevy_registry_export crate```](https://crates.io/crates/bevy_registry_export) ! +As it create custom properties that are writen in real **ron** file format instead of a simplified version (the one in the legacy mode) + + +> Note: the legacy mode support will be dropped in future versions, and the default behaviour will be NO legacy mode + + ## Examples https://github.com/kaosat-dev/Blender_bevy_components_workflow/tree/main/examples/bevy_gltf_blueprints/basic @@ -333,7 +352,7 @@ The main branch is compatible with the latest Bevy release, while the branch `be Compatibility of `bevy_gltf_blueprints` versions: | `bevy_gltf_blueprints` | `bevy` | | :-- | :-- | -| `0.3 - 0.6` | `0.12` | +| `0.3 - 0.7` | `0.12` | | `0.1 - 0.2` | `0.11` | | branch `main` | `0.12` | | branch `bevy_main` | `main` | diff --git a/crates/bevy_gltf_blueprints/src/lib.rs b/crates/bevy_gltf_blueprints/src/lib.rs index e335437..f6bd24b 100644 --- a/crates/bevy_gltf_blueprints/src/lib.rs +++ b/crates/bevy_gltf_blueprints/src/lib.rs @@ -78,6 +78,8 @@ impl fmt::Display for GltfFormat { #[derive(Debug, Clone)] /// Plugin for gltf blueprints pub struct BlueprintsPlugin { + pub legacy_mode: bool, // flag that gets passed on to bevy_gltf_components + pub format: GltfFormat, /// The base folder where library/blueprints assets are loaded from, relative to the executable. pub library_folder: PathBuf, @@ -91,6 +93,7 @@ pub struct BlueprintsPlugin { impl Default for BlueprintsPlugin { fn default() -> Self { Self { + legacy_mode: true, format: GltfFormat::GLB, library_folder: PathBuf::from("models/library"), aabbs: false, @@ -110,7 +113,9 @@ fn materials_library_enabled(blueprints_config: Res) -> bool { impl Plugin for BlueprintsPlugin { fn build(&self, app: &mut App) { - app.add_plugins(ComponentsFromGltfPlugin) + app.add_plugins(ComponentsFromGltfPlugin{ + legacy_mode: self.legacy_mode + }) .register_type::() .register_type::() .register_type::() diff --git a/crates/bevy_gltf_components/Cargo.toml b/crates/bevy_gltf_components/Cargo.toml index 56092bf..0d6c56b 100644 --- a/crates/bevy_gltf_components/Cargo.toml +++ b/crates/bevy_gltf_components/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "bevy_gltf_components" -version = "0.2.2" +version = "0.3.0" authors = ["Mark 'kaosat-dev' Moissette"] description = "Allows you to define [Bevy](https://bevyengine.org/) components direclty inside gltf files and instanciate the components on the Bevy side." homepage = "https://github.com/kaosat-dev/Blender_bevy_components_workflow" diff --git a/crates/bevy_gltf_components/README.md b/crates/bevy_gltf_components/README.md index 554ec64..7a6243d 100644 --- a/crates/bevy_gltf_components/README.md +++ b/crates/bevy_gltf_components/README.md @@ -24,7 +24,7 @@ Here's a minimal usage example: # Cargo.toml [dependencies] bevy="0.12" -bevy_gltf_components = { version = "0.2"} +bevy_gltf_components = { version = "0.3"} ``` @@ -33,7 +33,7 @@ bevy_gltf_components = { version = "0.2"} fn main() { App::new() .add_plugins(DefaultPlugins) - .add_plugin(ComponentsFromGltfPlugin) + .add_plugin(ComponentsFromGltfPlugin::default()) .add_system(spawn_level) .run(); } @@ -60,7 +60,7 @@ bevy_gltf_components = { version = "0.2"} Add the following to your `[dependencies]` section in `Cargo.toml`: ```toml -bevy_gltf_components = "0.2" +bevy_gltf_components = "0.3" ``` Or use `cargo add`: @@ -69,6 +69,27 @@ Or use `cargo add`: cargo add bevy_gltf_components ``` +## Configuration + +starting with version 0.3, this plugin is configurable +Use the default configuration: + +```rust no_run +ComponentsFromGltfPlugin::default() +``` + +Or disable the legacy mode: (enabled by default) + +```rust no_run +ComponentsFromGltfPlugin{legacy_mode: false} +``` + +You **need** to disable legacy mode if you want to use the [```bevy_components```](https://github.com/kaosat-dev/Blender_bevy_components_workflow/tree/tools_bevy_blueprints/tools/bevy_components) Blender addon + the [```bevy_registry_export crate```](https://crates.io/crates/bevy_registry_export) ! +As it create custom properties that are writen in real **ron** file format +instead of a simplified version (the one in the legacy mode) + +> Note: the legacy mode support will be dropped in future versions, and the default behaviour will be NO legacy mode + ## SystemSet the ordering of systems is very important ! @@ -96,7 +117,7 @@ The main branch is compatible with the latest Bevy release, while the branch `be Compatibility of `bevy_gltf_components` versions: | `bevy_gltf_components` | `bevy` | | :-- | :-- | -| `0.2` | `0.12` | +| `0.2 - 0.3` | `0.12` | | `0.1` | `0.11` | | branch `main` | `0.12` | | branch `bevy_main` | `main` | diff --git a/crates/bevy_gltf_components/src/gltf_to_components.rs b/crates/bevy_gltf_components/src/gltf_to_components.rs index cf319f6..8a051f0 100644 --- a/crates/bevy_gltf_components/src/gltf_to_components.rs +++ b/crates/bevy_gltf_components/src/gltf_to_components.rs @@ -1,11 +1,12 @@ +use bevy::ecs::component::Component; +use bevy::render::color::Color; use core::ops::Deref; - use ron::Value; use serde::de::DeserializeSeed; use bevy::ecs::{entity::Entity, reflect::ReflectComponent}; use bevy::gltf::{Gltf, GltfExtras}; -use bevy::reflect::serde::UntypedReflectDeserializer; // ReflectSerializer +use bevy::reflect::serde::UntypedReflectDeserializer; use bevy::reflect::{Reflect, TypeInfo, TypeRegistry}; use bevy::scene::Scene; use bevy::utils::HashMap; @@ -16,9 +17,18 @@ use bevy::{ use super::capitalize_first_letter; +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +struct TuppleTestColor(Color); + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +pub struct VecOfColors(Vec); + pub fn ronstring_to_reflect_component( ron_string: &String, type_registry: &TypeRegistry, + simplified_types: bool, ) -> Vec> { let lookup: HashMap = ron::from_str(ron_string.as_str()).unwrap(); let mut components: Vec> = Vec::new(); @@ -38,82 +48,72 @@ pub fn ronstring_to_reflect_component( type_registry.get_with_short_type_path(capitalized_type_name.as_str()) { debug!("TYPE INFO {:?}", type_registration.type_info()); - match type_registration.type_info() { - TypeInfo::TupleStruct(info) => { - // we handle tupple strucs with only one field differently, as Blender's custom properties with custom ui (float, int, bool, etc) always give us a tupple struct - if info.field_len() == 1 { - let field = info - .field_at(0) - .expect("we should always have at least one field here"); - let field_name = field.type_path(); - // TODO: find a way to cast with typeId instead of this matching - /*match field.type_id(){ - TypeId::of::() => { - println!("WE HAVE A f32"); - } - } - Vec3 => { - println!("WE HAVE A VEC3"); - let bla:Vec3 = ron::from_str(&parsed_value).unwrap(); - println!("bla {}", bla) - } - _ =>{} - }*/ - - let mut formated = parsed_value.clone(); - match field_name { - "f32" => { - formated = parsed_value.parse::().unwrap().to_string(); - } - "f64" => { - formated = parsed_value.parse::().unwrap().to_string(); - } - "u8" => { - formated = parsed_value.parse::().unwrap().to_string(); - } - "u16" => { - formated = parsed_value.parse::().unwrap().to_string(); - } - "u32" => { - formated = parsed_value.parse::().unwrap().to_string(); - } - "u64" => { - formated = parsed_value.parse::().unwrap().to_string(); - } - "u128" => { - formated = parsed_value.parse::().unwrap().to_string(); - } - "glam::Vec2" => { - let parsed: Vec = ron::from_str(&parsed_value).unwrap(); - formated = format!("(x:{},y:{})", parsed[0], parsed[1]); - } - "glam::Vec3" => { - let parsed: Vec = ron::from_str(&parsed_value).unwrap(); - formated = - format!("(x:{},y:{},z:{})", parsed[0], parsed[1], parsed[2]); - } - "bevy_render::color::Color" => { - let parsed: Vec = ron::from_str(&parsed_value).unwrap(); - if parsed.len() == 3 { + if simplified_types { + match type_registration.type_info() { + TypeInfo::TupleStruct(info) => { + // we handle tupple strucs with only one field differently, as Blender's custom properties with custom ui (float, int, bool, etc) always give us a tupple struct + if info.field_len() == 1 { + let field = info + .field_at(0) + .expect("we should always have at least one field here"); + let field_name = field.type_path(); + let mut formated = parsed_value.clone(); + match field_name { + "f32" => { + formated = parsed_value.parse::().unwrap().to_string(); + } + "f64" => { + formated = parsed_value.parse::().unwrap().to_string(); + } + "u8" => { + formated = parsed_value.parse::().unwrap().to_string(); + } + "u16" => { + formated = parsed_value.parse::().unwrap().to_string(); + } + "u32" => { + formated = parsed_value.parse::().unwrap().to_string(); + } + "u64" => { + formated = parsed_value.parse::().unwrap().to_string(); + } + "u128" => { + formated = parsed_value.parse::().unwrap().to_string(); + } + "glam::Vec2" => { + let parsed: Vec = ron::from_str(&parsed_value).unwrap(); + formated = format!("(x:{},y:{})", parsed[0], parsed[1]); + } + "glam::Vec3" => { + let parsed: Vec = ron::from_str(&parsed_value).unwrap(); formated = format!( - "Rgba(red:{},green:{},blue:{}, alpha: 1.0)", + "(x:{},y:{},z:{})", parsed[0], parsed[1], parsed[2] ); } - if parsed.len() == 4 { - formated = format!( - "Rgba(red:{},green:{},blue:{}, alpha:{})", - parsed[0], parsed[1], parsed[2], parsed[3] - ); + "bevy_render::color::Color" => { + let parsed: Vec = ron::from_str(&parsed_value).unwrap(); + if parsed.len() == 3 { + formated = format!( + "Rgba(red:{},green:{},blue:{}, alpha: 1.0)", + parsed[0], parsed[1], parsed[2] + ); + } + if parsed.len() == 4 { + formated = format!( + "Rgba(red:{},green:{},blue:{}, alpha:{})", + parsed[0], parsed[1], parsed[2], parsed[3] + ); + } } + _ => {} } - _ => {} - } - parsed_value = format!("({formated})"); + parsed_value = format!("({formated})"); + } } + _ => {} } - _ => {} } // println!("parsed value {}",parsed_value); @@ -128,7 +128,7 @@ pub fn ronstring_to_reflect_component( ); // usefull to determine what an entity looks like Serialized - /*let test_struct = Enemy::default(); + /*let test_struct = VecOfColors(vec![Color::Rgba { red: 0., green: 0.0, blue: 0.0, alpha: 0.0 }]);//TuppleTestColor(Color::Rgba { red: 0., green: 0.0, blue: 0.0, alpha: 0.0 }); let serializer = ReflectSerializer::new(&test_struct, &type_registry); let serialized = ron::ser::to_string_pretty(&serializer, ron::ser::PrettyConfig::default()).unwrap(); @@ -162,8 +162,13 @@ pub fn gltf_extras_to_components( gltf: &mut Gltf, scenes: &mut ResMut>, type_registry: impl Deref, + legacy_mode: bool ) { let mut added_components = 0; + let simplified_types = legacy_mode; + if simplified_types { + warn!("using simplified component definitions is deprecated since 0.3, prefer defining components with real ron values (use the bevy_components tool for Blender for simplicity) "); + } for (_name, scene) in &gltf.named_scenes { debug!("gltf: scene name {:?}", _name); @@ -173,7 +178,8 @@ pub fn gltf_extras_to_components( let mut entity_components: HashMap>> = HashMap::new(); for (entity, name, extras, parent) in query.iter(&scene.world) { debug!("Name: {}, entity {:?}, parent: {:?}", name, entity, parent); - let reflect_components = ronstring_to_reflect_component(&extras.value, &type_registry); + let reflect_components = + ronstring_to_reflect_component(&extras.value, &type_registry, simplified_types); added_components = reflect_components.len(); debug!("Found components {}", added_components); diff --git a/crates/bevy_gltf_components/src/lib.rs b/crates/bevy_gltf_components/src/lib.rs index 7f78a25..aaa312f 100644 --- a/crates/bevy_gltf_components/src/lib.rs +++ b/crates/bevy_gltf_components/src/lib.rs @@ -7,7 +7,7 @@ pub use gltf_to_components::*; pub mod process_gltfs; pub use process_gltfs::*; -use bevy::prelude::{App, IntoSystemConfigs, Plugin, SystemSet, Update}; +use bevy::{ecs::system::Resource, prelude::{App, IntoSystemConfigs, Plugin, SystemSet, Update}}; /// A Bevy plugin for extracting components from gltf files and automatically adding them to the relevant entities /// It will automatically run every time you load a gltf file @@ -34,7 +34,7 @@ use bevy::prelude::{App, IntoSystemConfigs, Plugin, SystemSet, Update}; /// ){ /// if keycode.just_pressed(KeyCode::Return) { /// commands.spawn(SceneBundle { -/// scene: asset_server.load("basic/models/level1.glb#Scene0"), +/// scene: asset_server.load("basic/models/level1.glb"), /// transform: Transform::from_xyz(2.0, 0.0, -5.0), /// ..Default::default() /// }); @@ -48,11 +48,29 @@ pub enum GltfComponentsSet { Injection, } -#[derive(Default)] -pub struct ComponentsFromGltfPlugin; +#[derive(Clone, Resource)] +pub struct GltfComponentsConfig { + pub(crate) legacy_mode: bool, +} + +pub struct ComponentsFromGltfPlugin { + pub legacy_mode: bool +} + +impl Default for ComponentsFromGltfPlugin { + fn default() -> Self { + Self { + legacy_mode: true + } + } +} + impl Plugin for ComponentsFromGltfPlugin { fn build(&self, app: &mut App) { app.insert_resource(GltfLoadingTracker::new()) + .insert_resource(GltfComponentsConfig { + legacy_mode: self.legacy_mode + }) .add_systems(Update, (track_new_gltf, process_loaded_scenes)) .add_systems( Update, diff --git a/crates/bevy_gltf_components/src/process_gltfs.rs b/crates/bevy_gltf_components/src/process_gltfs.rs index f83266c..18e26af 100644 --- a/crates/bevy_gltf_components/src/process_gltfs.rs +++ b/crates/bevy_gltf_components/src/process_gltfs.rs @@ -4,20 +4,20 @@ use bevy::gltf::Gltf; use bevy::utils::HashSet; use bevy::{asset::LoadState, prelude::*}; -use crate::gltf_extras_to_components; +use crate::{gltf_extras_to_components, GltfComponentsConfig}; #[derive(Resource)] /// component to keep track of gltfs' loading state pub struct GltfLoadingTracker { pub loading_gltfs: HashSet>, - pub loaded_gltfs: HashSet>, + pub processed_gltfs: HashSet, } impl GltfLoadingTracker { pub fn new() -> GltfLoadingTracker { GltfLoadingTracker { - loaded_gltfs: HashSet::new(), loading_gltfs: HashSet::new(), + processed_gltfs: HashSet::new(), } } pub fn add_gltf(&mut self, handle: Handle) { @@ -55,6 +55,7 @@ pub fn process_loaded_scenes( mut scenes: ResMut>, app_type_registry: Res, asset_server: Res, + gltf_components_config: Res, ) { let mut loaded_gltfs = Vec::new(); for gltf in &tracker.loading_gltfs { @@ -75,10 +76,15 @@ pub fn process_loaded_scenes( for gltf_handle in &loaded_gltfs { if let Some(gltf) = gltfs.get_mut(gltf_handle) { - gltf_extras_to_components(gltf, &mut scenes, &*type_registry); + gltf_extras_to_components(gltf, &mut scenes, &*type_registry, gltf_components_config.legacy_mode); + + if let Some(path) = gltf_handle.path() { + tracker.processed_gltfs.insert(path.to_string()); + } + } else { + warn!("could not find gltf asset, cannot process it"); } tracker.loading_gltfs.remove(gltf_handle); - tracker.loaded_gltfs.insert(gltf_handle.clone()); - debug!("Done loading scene"); + debug!("Done loading gltf file"); } } diff --git a/crates/bevy_gltf_save_load/Cargo.toml b/crates/bevy_gltf_save_load/Cargo.toml index 9006566..659726e 100644 --- a/crates/bevy_gltf_save_load/Cargo.toml +++ b/crates/bevy_gltf_save_load/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "bevy_gltf_save_load" -version = "0.1.0" +version = "0.2.0" authors = ["Mark 'kaosat-dev' Moissette"] description = "Save & load your bevy games" homepage = "https://github.com/kaosat-dev/Blender_bevy_components_workflow" @@ -18,4 +18,4 @@ bevy = { version = "0.12", default-features = false, features = ["bevy_asset", " [dependencies] bevy = { version = "0.12", default-features = false, features = ["bevy_asset", "bevy_scene", "bevy_gltf"] } -bevy_gltf_blueprints = "0.6" +bevy_gltf_blueprints = "0.7" diff --git a/crates/bevy_registry_export/Cargo.toml b/crates/bevy_registry_export/Cargo.toml new file mode 100644 index 0000000..3aa0228 --- /dev/null +++ b/crates/bevy_registry_export/Cargo.toml @@ -0,0 +1,21 @@ +[package] +name = "bevy_registry_export" +version = "0.1.0" +authors = ["Mark 'kaosat-dev' Moissette"] +description = "Allows you to define [Bevy](https://bevyengine.org/) components direclty inside gltf files and instanciate the components on the Bevy side." +homepage = "https://github.com/kaosat-dev/Blender_bevy_components_workflow" +repository = "https://github.com/kaosat-dev/Blender_bevy_components_workflow" +keywords = ["gamedev", "bevy", "assets", "gltf", "components"] +categories = ["game-development"] +edition = "2021" +license = "MIT OR Apache-2.0" + +[dev-dependencies] +bevy = { version = "0.12", default-features = false, features = ["bevy_asset", "bevy_scene", "bevy_gltf"] } + +[dependencies] +bevy = { version = "0.12", default-features = false, features = ["bevy_scene"] } +bevy_reflect = { version = "0.12.1", default-features = false } +bevy_app = { version = "0.12.1", default-features = false, features = ["bevy_reflect"] } +bevy_ecs = { version = "0.12.1", default-features = false, features = ["bevy_reflect"] } +serde_json = "1.0.108" \ No newline at end of file diff --git a/crates/bevy_registry_export/LICENSE.md b/crates/bevy_registry_export/LICENSE.md new file mode 100644 index 0000000..ad21aac --- /dev/null +++ b/crates/bevy_registry_export/LICENSE.md @@ -0,0 +1,4 @@ +This crate is available under either: + +* The [MIT License](./LICENSE_MIT) +* The [Apache License, Version 2.0](./LICENSE_APACHE) \ No newline at end of file diff --git a/crates/bevy_registry_export/LICENSE_APACHE.md b/crates/bevy_registry_export/LICENSE_APACHE.md new file mode 100644 index 0000000..43c47c4 --- /dev/null +++ b/crates/bevy_registry_export/LICENSE_APACHE.md @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [2024] [Mark "kaosat-dev" Moissette] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. \ No newline at end of file diff --git a/crates/bevy_registry_export/LICENSE_MIT.md b/crates/bevy_registry_export/LICENSE_MIT.md new file mode 100644 index 0000000..c7e0144 --- /dev/null +++ b/crates/bevy_registry_export/LICENSE_MIT.md @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2024 Mark "kaosat-dev" Moissette + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/crates/bevy_registry_export/README.md b/crates/bevy_registry_export/README.md new file mode 100644 index 0000000..df85616 --- /dev/null +++ b/crates/bevy_registry_export/README.md @@ -0,0 +1,130 @@ +[![Crates.io](https://img.shields.io/crates/v/bevy_registry_export)](https://crates.io/crates/bevy_registry_export) +[![Docs](https://img.shields.io/docsrs/bevy_registry_export)](https://docs.rs/bevy_registry_export/latest/bevy_registry_export/) +[![License](https://img.shields.io/crates/l/bevy_registry_export)](https://github.com/kaosat-dev/Blender_bevy_components_workflow/blob/main/crates/bevy_registry_export/License.md) +[![Bevy tracking](https://img.shields.io/badge/Bevy%20tracking-released%20version-lightblue)](https://github.com/bevyengine/bevy/blob/main/docs/plugins_guidelines.md#main-branch-tracking) + +# bevy_registry_export + +This plugin allows you to create a Json export of all your components/ registered types. +Its main use case is as a backbone for the [```bevy_components``` Blender add-on](https://github.com/kaosat-dev/Blender_bevy_components_workflow/tree/main/tools/bevy_components), that allows you to add & edit components directly in Blender, using the actual type definitions from Bevy +(and any of your custom types & components that you register in Bevy). + + +## Usage + +Here's a minimal usage example: + +```toml +# Cargo.toml +[dependencies] +bevy="0.12" +bevy_registry_export = "0.1" +``` + +```rust no_run +use bevy::prelude::*; +use bevy_registry_export::*; + +fn main() { + App::new() + .add_plugins(( + DefaultPlugins, + ExportRegistryPlugin::default() // will save your registry schema json file to assets/registry.json + )) + .run(); +} + +``` + +take a look at the [example]('https://github.com/kaosat-dev/Blender_bevy_components_workflow/tree/main/examples/bevy_registry_export/basic/src/core/mod.rs) for more clarity + + +## Installation + +Add the following to your `[dependencies]` section in `Cargo.toml`: + +```toml +bevy_registry_export = "0.1" + +``` + +Or use `cargo add`: + +```toml +cargo add bevy_registry_export +``` + +## Setup + +```rust no_run +use bevy::prelude::*; +use bevy_registry_export::*; + +fn main() { + App::new() + .add_plugins(( + DefaultPlugins + ExportRegistryPlugin::default() + )) + .run(); +} + +``` + +you can also configure the output path + +```rust no_run +use bevy::prelude::*; +use bevy_registry_export::*; + +fn main() { + App::new() + .add_plugins(( + DefaultPlugins + ExportRegistryPlugin { + save_path: "assets/registry.json".into(), + ..Default::default() + }, + )) + .run(); +} + +``` + +## Usage + +- The output file will be generated in the ```Startup``` schedule whenever you run your app. +- Every time you compile & run your app, the output json file will be updated. + +## Examples + +All examples are here: + +> the examples use ```bevy_gltf_blueprints``` with the **legacy_mode** set to **FALSE** as the new custom properties generated by the Blender add-on require newer/ non legacy logic. + +- https://github.com/kaosat-dev/Blender_bevy_components_workflow/tree/main/examples/bevy_registry_export/basic + + +## Compatible Bevy versions + +The main branch is compatible with the latest Bevy release, while the branch `bevy_main` tries to track the `main` branch of Bevy (PRs updating the tracked commit are welcome). + +Compatibility of `bevy_registry_export` versions: +| `bevy_registry_export` | `bevy` | `bevy_components (Blender add-on)` | +| :-- | :-- |:-- | +| `0.1 ` | `0.12` | `0.1.0` | +| branch `main` | `0.12` | `0.1.0` | +| branch `bevy_main` | `main` | `n/a` | + + +## Contributors + +Thanks to all the contributors helping out with this project ! Big kudos to you, contributions are always appreciated ! :) +A big shout out to [killercup](https://github.com/killercup), that did the bulk of the Bevy side code ! + +## License + +This crate, all its code, contents & assets is Dual-licensed under either of + +- Apache License, Version 2.0, ([LICENSE-APACHE](./LICENSE_APACHE.md) or https://www.apache.org/licenses/LICENSE-2.0) +- MIT license ([LICENSE-MIT](./LICENSE_MIT.md) or https://opensource.org/licenses/MIT) \ No newline at end of file diff --git a/crates/bevy_registry_export/src/export_types.rs b/crates/bevy_registry_export/src/export_types.rs new file mode 100644 index 0000000..06c0573 --- /dev/null +++ b/crates/bevy_registry_export/src/export_types.rs @@ -0,0 +1,267 @@ +use std::fs::File; + +use bevy::log::info; +use bevy_ecs::{ + reflect::{AppTypeRegistry, ReflectComponent, ReflectResource}, + world::World, +}; +use bevy_reflect::{TypeInfo, TypeRegistration, VariantInfo}; // TypePath // DynamicTypePath +use serde_json::{json, Map, Value}; + +use crate::ExportComponentsConfig; + +pub fn export_types(world: &mut World) { + let config = world + .get_resource::() + .expect("ExportComponentsConfig should exist at this stage"); + + let writer = + File::create(config.save_path.to_path_buf()).expect("should have created schema file"); + + let types = world.resource_mut::(); + let types = types.read(); + let schemas = types.iter().map(export_type).collect::>(); + + serde_json::to_writer_pretty( + writer, + &json!({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "bevy component registry schema", + "$defs": schemas, + }), + ) + .expect("valid json"); + + info!("Done exporting registry schema") +} + +pub fn export_type(reg: &TypeRegistration) -> (String, Value) { + let t = reg.type_info(); + let binding = t.type_path_table(); + let short_name = binding.short_path(); + let mut schema = match t { + TypeInfo::Struct(info) => { + let properties = info + .iter() + .enumerate() + .map(|(idx, field)| { + ( + field.name().to_owned(), + add_min_max(json!({ "type": typ(field.type_path()) }), reg, idx, None), + ) + }) + .collect::>(); + + json!({ + "type": "object", + "typeInfo": "Struct", + "title": t.type_path(), + "properties": properties, + "additionalProperties": false, + "required": info + .iter() + .filter(|field| !field.type_path().starts_with("core::option::Option")) + .map(|field| field.name()) + .collect::>(), + }) + } + TypeInfo::Enum(info) => { + let simple = info + .iter() + .all(|variant| matches!(variant, VariantInfo::Unit(_))); + if simple { + json!({ + "type": "string", + "typeInfo": "Enum", + "title": t.type_path(), + "oneOf": info + .iter() + .map(|variant| match variant { + VariantInfo::Unit(v) => v.name(), + _ => unreachable!(), + }) + .collect::>(), + }) + } else { + let variants = info + .iter() + .enumerate() + .map(|(field_idx, variant)| match variant { + //let binding = t.type_path_table(); + //let short_name = binding.short_path(); + VariantInfo::Struct(v) => json!({ + "type": "object", + "typeInfo": "Struct", + "title": v.name(), + "short_name": v.name().split("::").last().unwrap_or(v.name()), + "properties": v + .iter() + .enumerate() + .map(|(variant_idx, field)| (field.name().to_owned(), add_min_max(json!({"type": typ(field.type_path()), "title": field.name()}), reg, field_idx, Some(variant_idx)))) + .collect::>(), + "additionalProperties": false, + "required": v + .iter() + .filter(|field| !field.type_path().starts_with("core::option::Option")) + .map(|field| field.name()) + .collect::>(), + }), + VariantInfo::Tuple(v) => json!({ + "type": "array", + "typeInfo": "Tuple", + "title": v.name(), + "short_name":v.name(), + "prefixItems": v + .iter() + .enumerate() + .map(|(variant_idx, field)| add_min_max(json!({"type": typ(field.type_path())}), reg, field_idx, Some(variant_idx))) + .collect::>(), + "items": false, + }), + VariantInfo::Unit(v) => json!({ + "title": v.name(), + }), + }) + .collect::>(); + + json!({ + "type": "object", + "typeInfo": "Enum", + "title": t.type_path(), + "oneOf": variants, + }) + } + } + TypeInfo::TupleStruct(info) => json!({ + "title": t.type_path(), + "type": "array", + "typeInfo": "TupleStruct", + "prefixItems": info + .iter() + .enumerate() + .map(|(idx, field)| add_min_max(json!({"type": typ(field.type_path())}), reg, idx, None)) + .collect::>(), + "items": false, + }), + TypeInfo::List(info) => { + json!({ + "title": t.type_path(), + "type": "array", + "typeInfo": "List", + "items": json!({"type": typ(info.item_type_path_table().path())}), + }) + } + TypeInfo::Array(info) => json!({ + "title": t.type_path(), + "type": "array", + "typeInfo": "Array", + "items": json!({"type": typ(info.item_type_path_table().path())}), + }), + TypeInfo::Map(info) => json!({ + "title": t.type_path(), + "type": "object", + "typeInfo": "Map", + "additionalProperties": json!({"type": typ(info.value_type_path_table().path())}), + }), + TypeInfo::Tuple(info) => json!({ + "title": t.type_path(), + "type": "array", + "typeInfo": "Tuple", + "prefixItems": info + .iter() + .enumerate() + .map(|(idx, field)| add_min_max(json!({"type": typ(field.type_path())}), reg, idx, None)) + .collect::>(), + "items": false, + }), + TypeInfo::Value(info) => json!({ + "title": t.type_path(), + "type": map_json_type(info.type_path()), + "typeInfo": "Value", + }), + }; + schema.as_object_mut().unwrap().insert( + "isComponent".to_owned(), + reg.data::().is_some().into(), + ); + schema.as_object_mut().unwrap().insert( + "isResource".to_owned(), + reg.data::().is_some().into(), + ); + + schema + .as_object_mut() + .unwrap() + .insert("short_name".to_owned(), short_name.into()); + + (t.type_path().to_owned(), schema) +} + +fn typ(t: &str) -> Value { + json!({ "$ref": format!("#/$defs/{t}") }) +} + +fn map_json_type(t: &str) -> Value { + match t { + "bool" => "boolean", + "u8" | "u16" | "u32" | "u64" | "u128" | "usize" => "uint", + "i8" | "i16" | "i32" | "i64" | "i128" | "isize" => "int", + "f32" | "f64" => "float", + "char" | "str" | "alloc::string::String" => "string", + _ => "object", + } + .into() +} + +fn add_min_max( + mut val: Value, + reg: &TypeRegistration, + field_index: usize, + variant_index: Option, +) -> Value { + #[cfg(feature = "support-inspector")] + fn get_min_max( + reg: &TypeRegistration, + field_index: usize, + variant_index: Option, + ) -> Option<(Option, Option)> { + use bevy_inspector_egui::inspector_options::{ + std_options::NumberOptions, ReflectInspectorOptions, Target, + }; + + reg.data::() + .and_then(|ReflectInspectorOptions(o)| { + o.get(if let Some(variant_index) = variant_index { + Target::VariantField { + variant_index, + field_index, + } + } else { + Target::Field(field_index) + }) + }) + .and_then(|o| o.downcast_ref::>()) + .map(|num| (num.min, num.max)) + } + + #[cfg(not(feature = "support-inspector"))] + fn get_min_max( + _reg: &TypeRegistration, + _field_index: usize, + _variant_index: Option, + ) -> Option<(Option, Option)> { + None + } + + let Some((min, max)) = get_min_max(reg, field_index, variant_index) else { + return val; + }; + let obj = val.as_object_mut().unwrap(); + if let Some(min) = min { + obj.insert("minimum".to_owned(), min.into()); + } + if let Some(max) = max { + obj.insert("maximum".to_owned(), max.into()); + } + val +} diff --git a/crates/bevy_registry_export/src/lib.rs b/crates/bevy_registry_export/src/lib.rs new file mode 100644 index 0000000..fa8e29d --- /dev/null +++ b/crates/bevy_registry_export/src/lib.rs @@ -0,0 +1,48 @@ +pub mod export_types; +use std::path::PathBuf; + +use bevy_app::Startup; +use bevy_ecs::system::Resource; +pub use export_types::*; + +use bevy::{ + prelude::{App, Plugin}, + scene::SceneFilter, +}; + +// Plugin configuration +#[derive(Clone, Resource)] +pub struct ExportComponentsConfig { + pub(crate) save_path: PathBuf, + #[allow(dead_code)] + pub(crate) component_filter: SceneFilter, // unused for now + #[allow(dead_code)] + pub(crate) resource_filter: SceneFilter, // unused for now +} + +pub struct ExportRegistryPlugin { + pub component_filter: SceneFilter, + pub resource_filter: SceneFilter, + pub save_path: PathBuf, +} + +impl Default for ExportRegistryPlugin { + fn default() -> Self { + Self { + component_filter: SceneFilter::default(), // unused for now + resource_filter: SceneFilter::default(), // unused for now + save_path: PathBuf::from("assets/registry.json"), + } + } +} + +impl Plugin for ExportRegistryPlugin { + fn build(&self, app: &mut App) { + app.insert_resource(ExportComponentsConfig { + save_path: self.save_path.clone(), + component_filter: self.component_filter.clone(), + resource_filter: self.resource_filter.clone(), + }) + .add_systems(Startup, export_types); + } +} diff --git a/docs/bevy_components.png b/docs/bevy_components.png new file mode 100644 index 0000000..b26a4d1 Binary files /dev/null and b/docs/bevy_components.png differ diff --git a/examples/bevy_gltf_components/basic/src/main.rs b/examples/bevy_gltf_components/basic/src/main.rs index 4795411..8827730 100644 --- a/examples/bevy_gltf_components/basic/src/main.rs +++ b/examples/bevy_gltf_components/basic/src/main.rs @@ -34,7 +34,7 @@ fn main() { RapierPhysicsPlugin::::default(), RapierDebugRenderPlugin::default(), // our custom plugins - ComponentsFromGltfPlugin, + ComponentsFromGltfPlugin::default(), CorePlugin, // reusable plugins DemoPlugin, // specific to our game ComponentsTestPlugin, // Showcases different type of components /structs diff --git a/examples/bevy_gltf_components/basic_wasm/src/main.rs b/examples/bevy_gltf_components/basic_wasm/src/main.rs index 4795411..8827730 100644 --- a/examples/bevy_gltf_components/basic_wasm/src/main.rs +++ b/examples/bevy_gltf_components/basic_wasm/src/main.rs @@ -34,7 +34,7 @@ fn main() { RapierPhysicsPlugin::::default(), RapierDebugRenderPlugin::default(), // our custom plugins - ComponentsFromGltfPlugin, + ComponentsFromGltfPlugin::default(), CorePlugin, // reusable plugins DemoPlugin, // specific to our game ComponentsTestPlugin, // Showcases different type of components /structs diff --git a/examples/bevy_gltf_save_load/basic/Cargo.toml b/examples/bevy_gltf_save_load/basic/Cargo.toml index 71138df..5f8676f 100644 --- a/examples/bevy_gltf_save_load/basic/Cargo.toml +++ b/examples/bevy_gltf_save_load/basic/Cargo.toml @@ -6,7 +6,7 @@ license = "MIT OR Apache-2.0" [dependencies] bevy="0.12" -bevy_gltf_blueprints = "0.6" +bevy_gltf_blueprints = "0.7" bevy_gltf_save_load = { path = "../../../crates/bevy_gltf_save_load" } bevy_rapier3d = { version = "0.23.0", features = [ "serde-serialize", "debug-render-3d", "enhanced-determinism"] } diff --git a/examples/bevy_registry_export/basic/Cargo.lock b/examples/bevy_registry_export/basic/Cargo.lock new file mode 100644 index 0000000..5063b29 --- /dev/null +++ b/examples/bevy_registry_export/basic/Cargo.lock @@ -0,0 +1,4629 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "ab_glyph" +version = "0.2.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "80179d7dd5d7e8c285d67c4a1e652972a92de7475beddfb92028c76463b13225" +dependencies = [ + "ab_glyph_rasterizer", + "owned_ttf_parser", +] + +[[package]] +name = "ab_glyph_rasterizer" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c71b1793ee61086797f5c80b6efa2b8ffa6d5dd703f118545808a7f2e27f7046" + +[[package]] +name = "accesskit" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca8410747ed85a17c4a1e9ed3f5a74d3e7bdcc876cf9a18ff40ae21d645997b2" + +[[package]] +name = "accesskit_consumer" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c17cca53c09fbd7288667b22a201274b9becaa27f0b91bf52a526db95de45e6" +dependencies = [ + "accesskit", +] + +[[package]] +name = "accesskit_macos" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd3b6ae1eabbfbced10e840fd3fce8a93ae84f174b3e4ba892ab7bcb42e477a7" +dependencies = [ + "accesskit", + "accesskit_consumer", + "objc2", + "once_cell", +] + +[[package]] +name = "accesskit_windows" +version = "0.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "afcae27ec0974fc7c3b0b318783be89fd1b2e66dd702179fe600166a38ff4a0b" +dependencies = [ + "accesskit", + "accesskit_consumer", + "once_cell", + "paste", + "static_assertions", + "windows 0.48.0", +] + +[[package]] +name = "accesskit_winit" +version = "0.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "88e39fcec2e10971e188730b7a76bab60647dacc973d4591855ebebcadfaa738" +dependencies = [ + "accesskit", + "accesskit_macos", + "accesskit_windows", + "winit", +] + +[[package]] +name = "addr2line" +version = "0.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb" +dependencies = [ + "gimli", +] + +[[package]] +name = "adler" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe" + +[[package]] +name = "ahash" +version = "0.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91429305e9f0a25f6205c5b8e0d2db09e0708a7a6df0f42212bb56c32c8ac97a" +dependencies = [ + "cfg-if", + "getrandom", + "once_cell", + "version_check", + "zerocopy", +] + +[[package]] +name = "aho-corasick" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0" +dependencies = [ + "memchr", +] + +[[package]] +name = "allocator-api2" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0942ffc6dcaadf03badf6e6a2d0228460359d5e34b57ccdc720b7382dfbd5ec5" + +[[package]] +name = "alsa" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2562ad8dcf0f789f65c6fdaad8a8a9708ed6b488e649da28c01656ad66b8b47" +dependencies = [ + "alsa-sys", + "bitflags 1.3.2", + "libc", + "nix 0.24.3", +] + +[[package]] +name = "alsa-sys" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db8fee663d06c4e303404ef5f40488a53e062f89ba8bfed81f42325aafad1527" +dependencies = [ + "libc", + "pkg-config", +] + +[[package]] +name = "android-activity" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "64529721f27c2314ced0890ce45e469574a73e5e6fdd6e9da1860eb29285f5e0" +dependencies = [ + "android-properties", + "bitflags 1.3.2", + "cc", + "jni-sys", + "libc", + "log", + "ndk", + "ndk-context", + "ndk-sys", + "num_enum 0.6.1", +] + +[[package]] +name = "android-properties" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc7eb209b1518d6bb87b283c20095f5228ecda460da70b44f0802523dea6da04" + +[[package]] +name = "android_log-sys" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5ecc8056bf6ab9892dcd53216c83d1597487d7dacac16c8df6b877d127df9937" + +[[package]] +name = "android_system_properties" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311" +dependencies = [ + "libc", +] + +[[package]] +name = "anyhow" +version = "1.0.75" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6" + +[[package]] +name = "approx" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6" +dependencies = [ + "num-traits", +] + +[[package]] +name = "arboard" +version = "3.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac57f2b058a76363e357c056e4f74f1945bf734d37b8b3ef49066c4787dde0fc" +dependencies = [ + "clipboard-win", + "core-graphics", + "image", + "log", + "objc", + "objc-foundation", + "objc_id", + "parking_lot", + "thiserror", + "winapi", + "x11rb", +] + +[[package]] +name = "arrayref" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6b4930d2cb77ce62f89ee5d5289b4ac049559b1c45539271f5ed4fdc7db34545" + +[[package]] +name = "arrayvec" +version = "0.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711" + +[[package]] +name = "ash" +version = "0.37.3+1.3.251" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39e9c3835d686b0a6084ab4234fcd1b07dbf6e4767dce60874b12356a25ecd4a" +dependencies = [ + "libloading 0.7.4", +] + +[[package]] +name = "async-broadcast" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c48ccdbf6ca6b121e0f586cbc0e73ae440e56c67c30fa0873b4e110d9c26d2b" +dependencies = [ + "event-listener", + "futures-core", +] + +[[package]] +name = "async-channel" +version = "1.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81953c529336010edd6d8e358f886d9581267795c61b19475b71314bffa46d35" +dependencies = [ + "concurrent-queue", + "event-listener", + "futures-core", +] + +[[package]] +name = "async-executor" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b0c4a4f319e45986f347ee47fef8bf5e81c9abc3f6f58dc2391439f30df65f0" +dependencies = [ + "async-lock", + "async-task", + "concurrent-queue", + "fastrand 2.0.1", + "futures-lite", + "slab", +] + +[[package]] +name = "async-fs" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "279cf904654eeebfa37ac9bb1598880884924aab82e290aa65c9e77a0e142e06" +dependencies = [ + "async-lock", + "autocfg", + "blocking", + "futures-lite", +] + +[[package]] +name = "async-lock" +version = "2.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "287272293e9d8c41773cec55e365490fe034813a2f172f502d6ddcf75b2f582b" +dependencies = [ + "event-listener", +] + +[[package]] +name = "async-task" +version = "4.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4eb2cdb97421e01129ccb49169d8279ed21e829929144f4a22a6e54ac549ca1" + +[[package]] +name = "atomic-waker" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0" + +[[package]] +name = "autocfg" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" + +[[package]] +name = "backtrace" +version = "0.3.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2089b7e3f35b9dd2d0ed921ead4f6d318c27680d4a5bd167b3ee120edb105837" +dependencies = [ + "addr2line", + "cc", + "cfg-if", + "libc", + "miniz_oxide", + "object", + "rustc-demangle", +] + +[[package]] +name = "base64" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8" + +[[package]] +name = "base64" +version = "0.21.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "35636a1494ede3b646cc98f74f8e62c773a38a659ebc777a2cf26b9b74171df9" + +[[package]] +name = "bevy" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "329e344f835f5a9a4c46a6d1d57371f726aa2c482d1bd669b2b9c4eb1ee91fd7" +dependencies = [ + "bevy_internal", +] + +[[package]] +name = "bevy-inspector-egui" +version = "0.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d65b98d6fca1209c36c4d403c377f303aad22d940281fe1a9e431217516f0622" +dependencies = [ + "bevy-inspector-egui-derive", + "bevy_app", + "bevy_asset", + "bevy_core", + "bevy_core_pipeline", + "bevy_ecs", + "bevy_egui", + "bevy_hierarchy", + "bevy_log", + "bevy_math", + "bevy_pbr", + "bevy_reflect", + "bevy_render", + "bevy_utils", + "bevy_window", + "egui", + "image", + "once_cell", + "pretty-type-name", + "smallvec", +] + +[[package]] +name = "bevy-inspector-egui-derive" +version = "0.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec800b7cf98151b5dbff80f0eb6dffcb4bcfceef6e457888b395ead4eb7e75ba" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.39", +] + +[[package]] +name = "bevy_a11y" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "271b812e5734f5056a400f7d64592dd82d6c0e6179389c2f066f433ab8bc7692" +dependencies = [ + "accesskit", + "bevy_app", + "bevy_derive", + "bevy_ecs", +] + +[[package]] +name = "bevy_animation" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab94187a1253433e14f175293d8a86ec1c2822fda2a17807908f11ec21f45f00" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_core", + "bevy_ecs", + "bevy_hierarchy", + "bevy_math", + "bevy_reflect", + "bevy_render", + "bevy_time", + "bevy_transform", + "bevy_utils", +] + +[[package]] +name = "bevy_app" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "172d532ea812e5954fa814dae003c207f2a0b20c6e50431787c94a7159677ece" +dependencies = [ + "bevy_derive", + "bevy_ecs", + "bevy_reflect", + "bevy_tasks", + "bevy_utils", + "downcast-rs", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "bevy_asset" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccb2b67984088b23e223cfe9ec1befd89a110665a679acb06839bc4334ed37d6" +dependencies = [ + "async-broadcast", + "async-fs", + "async-lock", + "bevy_app", + "bevy_asset_macros", + "bevy_ecs", + "bevy_log", + "bevy_reflect", + "bevy_tasks", + "bevy_utils", + "bevy_winit", + "blake3", + "crossbeam-channel", + "downcast-rs", + "futures-io", + "futures-lite", + "js-sys", + "parking_lot", + "ron", + "serde", + "thiserror", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", +] + +[[package]] +name = "bevy_asset_loader" +version = "0.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d797cc907daa293a2776fea1517ed79f9e54d9901dfd35410743cbe536d4c2b" +dependencies = [ + "anyhow", + "bevy", + "bevy_asset_loader_derive", + "bevy_common_assets", + "path-slash", + "serde", +] + +[[package]] +name = "bevy_asset_loader_derive" +version = "0.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d43820afc6e2a7a9e09adb5f13a760bd9a973f391c106411f0bf229d9958c61d" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.39", +] + +[[package]] +name = "bevy_asset_macros" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b3245193e90fc8abcf1059a467cb224501dcda083d114c67c10ac66b7171e3a" +dependencies = [ + "bevy_macro_utils", + "proc-macro2", + "quote", + "syn 2.0.39", +] + +[[package]] +name = "bevy_audio" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "478de80ff25cb7decbcb22797774d1597e8c32914e81431c67d64faadc08f84a" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_derive", + "bevy_ecs", + "bevy_math", + "bevy_reflect", + "bevy_transform", + "bevy_utils", + "oboe", + "rodio", +] + +[[package]] +name = "bevy_common_assets" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9397adf1558aa3f08e20aa567538a7238b451362fc8c6b678d409c040c221799" +dependencies = [ + "anyhow", + "bevy", + "ron", + "serde", + "thiserror", +] + +[[package]] +name = "bevy_core" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "025e6800b73048092a55c3611e9327ad4c4c17b60517ec1c0086bb40b4b19ea8" +dependencies = [ + "bevy_app", + "bevy_ecs", + "bevy_math", + "bevy_reflect", + "bevy_tasks", + "bevy_utils", + "bytemuck", + "serde", +] + +[[package]] +name = "bevy_core_pipeline" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2e4b08a2d53ba62d9ec1fca3f7f4e0f556e9f59e1c8e63a4b7c2a18c0701152c" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_core", + "bevy_derive", + "bevy_ecs", + "bevy_log", + "bevy_math", + "bevy_reflect", + "bevy_render", + "bevy_transform", + "bevy_utils", + "bitflags 2.4.1", + "radsort", + "serde", +] + +[[package]] +name = "bevy_derive" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24bf40259be12a1a24d9fd536f5ff18d31eeb5665b77e2732899783be6edc5d6" +dependencies = [ + "bevy_macro_utils", + "quote", + "syn 2.0.39", +] + +[[package]] +name = "bevy_diagnostic" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b5a99a9fb6cd7d1eb1714fad193944a0317f0887a15cccb8309c8d37951132" +dependencies = [ + "bevy_app", + "bevy_core", + "bevy_ecs", + "bevy_log", + "bevy_time", + "bevy_utils", + "sysinfo", +] + +[[package]] +name = "bevy_ecs" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae11a1f467c372b50e9d4b55e78370f5420c9db7416200cc441cc84f08174dd3" +dependencies = [ + "async-channel", + "bevy_ecs_macros", + "bevy_ptr", + "bevy_reflect", + "bevy_tasks", + "bevy_utils", + "downcast-rs", + "event-listener", + "fixedbitset", + "rustc-hash", + "serde", + "thiserror", + "thread_local", +] + +[[package]] +name = "bevy_ecs_macros" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f642c2b67c4d0daf8edf15074f6351457eb487a34b3de1290c760d8f3ac9ec16" +dependencies = [ + "bevy_macro_utils", + "proc-macro2", + "quote", + "syn 2.0.39", +] + +[[package]] +name = "bevy_editor_pls" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "170e3ee3293f70be7fa1b82e8ffe52dcb190c68b2f0ef4847afe65626b417ad7" +dependencies = [ + "bevy", + "bevy_editor_pls_core", + "bevy_editor_pls_default_windows", + "egui", + "egui-gizmo", +] + +[[package]] +name = "bevy_editor_pls_core" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9bab331de653d7d976a1fb0ab3ae8eff1dc821c5991c09bdbe945e70234839c" +dependencies = [ + "bevy", + "bevy-inspector-egui", + "egui_dock", + "indexmap 2.1.0", +] + +[[package]] +name = "bevy_editor_pls_default_windows" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b833e3b3d5c69b92527e766b470b27cb4745406e2087be19be81b595cc48792c" +dependencies = [ + "bevy", + "bevy-inspector-egui", + "bevy_editor_pls_core", + "bevy_mod_debugdump", + "egui-gizmo", + "indexmap 2.1.0", + "opener", + "pretty-type-name", +] + +[[package]] +name = "bevy_egui" +version = "0.23.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85450af551b7e1cb766f710763b60a12a82ffd6323945a8f776c6334c59ccdc1" +dependencies = [ + "arboard", + "bevy", + "egui", + "thread_local", + "webbrowser", +] + +[[package]] +name = "bevy_encase_derive" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65b9fb5a62c4e3ab70caaa839470d35fa932001b1b34b08bc7f7f1909bd2b3a7" +dependencies = [ + "bevy_macro_utils", + "encase_derive_impl", +] + +[[package]] +name = "bevy_gilrs" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad31cc2c84315e0759d793d6c5bcb7d8789bbc16359c98d1b766e708c1bbae49" +dependencies = [ + "bevy_app", + "bevy_ecs", + "bevy_input", + "bevy_log", + "bevy_time", + "bevy_utils", + "gilrs", + "thiserror", +] + +[[package]] +name = "bevy_gizmos" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87d1cc978b91f416b23eb16f00e69f95c3a04582021827d8082e92d4725cc510" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_core", + "bevy_core_pipeline", + "bevy_ecs", + "bevy_math", + "bevy_pbr", + "bevy_reflect", + "bevy_render", + "bevy_sprite", + "bevy_transform", + "bevy_utils", +] + +[[package]] +name = "bevy_gltf" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f933745c0c86e2c07948def581259b466f99708328657054e956275430ccfd7" +dependencies = [ + "base64 0.13.1", + "bevy_animation", + "bevy_app", + "bevy_asset", + "bevy_core", + "bevy_core_pipeline", + "bevy_ecs", + "bevy_hierarchy", + "bevy_log", + "bevy_math", + "bevy_pbr", + "bevy_reflect", + "bevy_render", + "bevy_scene", + "bevy_tasks", + "bevy_transform", + "bevy_utils", + "gltf", + "percent-encoding", + "serde", + "serde_json", + "thiserror", +] + +[[package]] +name = "bevy_gltf_blueprints" +version = "0.3.0" +dependencies = [ + "bevy", + "bevy_gltf_components", +] + +[[package]] +name = "bevy_gltf_blueprints_basic_example" +version = "0.3.0" +dependencies = [ + "bevy", + "bevy_asset_loader", + "bevy_editor_pls", + "bevy_gltf_blueprints", + "bevy_rapier3d", + "rand", +] + +[[package]] +name = "bevy_gltf_components" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd745a2988c631286404e12d184d4a30a634fbbba1deceaaa1ca7fcbc607cc7a" +dependencies = [ + "bevy", + "ron", + "serde", +] + +[[package]] +name = "bevy_hierarchy" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "64fa240011fce8ee23f9b46e5a26a628a31d7860d6d2e4e0e361bb3ea6d5a703" +dependencies = [ + "bevy_app", + "bevy_core", + "bevy_ecs", + "bevy_log", + "bevy_reflect", + "bevy_utils", + "smallvec", +] + +[[package]] +name = "bevy_input" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e86e241b3a10b79f65a69205552546723b855d3d4c1bd8261637c076144d32f" +dependencies = [ + "bevy_app", + "bevy_ecs", + "bevy_math", + "bevy_reflect", + "bevy_utils", + "serde", + "thiserror", +] + +[[package]] +name = "bevy_internal" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "55124e486814c4d3632d5cfad9c4f4e46d052c028593ec46fef5bfbfb0f840b1" +dependencies = [ + "bevy_a11y", + "bevy_animation", + "bevy_app", + "bevy_asset", + "bevy_audio", + "bevy_core", + "bevy_core_pipeline", + "bevy_derive", + "bevy_diagnostic", + "bevy_ecs", + "bevy_gilrs", + "bevy_gizmos", + "bevy_gltf", + "bevy_hierarchy", + "bevy_input", + "bevy_log", + "bevy_math", + "bevy_pbr", + "bevy_ptr", + "bevy_reflect", + "bevy_render", + "bevy_scene", + "bevy_sprite", + "bevy_tasks", + "bevy_text", + "bevy_time", + "bevy_transform", + "bevy_ui", + "bevy_utils", + "bevy_window", + "bevy_winit", +] + +[[package]] +name = "bevy_log" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "011417debf7868b45932bb97fc0d5bfdeaf9304e324aa94840e2f1e6deeed69d" +dependencies = [ + "android_log-sys", + "bevy_app", + "bevy_ecs", + "bevy_utils", + "console_error_panic_hook", + "tracing-log", + "tracing-subscriber", + "tracing-wasm", +] + +[[package]] +name = "bevy_macro_utils" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf6fba87c6d069fcbcd8a48625ca8ab4392ad40d2b260863ce7d641a0f42986d" +dependencies = [ + "proc-macro2", + "quote", + "rustc-hash", + "syn 2.0.39", + "toml_edit 0.20.7", +] + +[[package]] +name = "bevy_math" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "752764558a1f429c20704c3b836a019fa308961c43fdfef4f08e339d456c96be" +dependencies = [ + "glam", + "serde", +] + +[[package]] +name = "bevy_mikktspace" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b596c41a56f2268ec7cde560edc588bc7b5886e4b49c8b27c4dcc9f7c743424c" +dependencies = [ + "glam", +] + +[[package]] +name = "bevy_mod_debugdump" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4db8601f41ea570b7d32f3177292a608196c59bdf3298001a9e202d5e7439438" +dependencies = [ + "bevy_app", + "bevy_ecs", + "bevy_render", + "bevy_utils", + "once_cell", + "petgraph", + "pretty-type-name", +] + +[[package]] +name = "bevy_pbr" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eeb6a35a78d355cc21c10f277dcd171eca65e30a90e76eb89f4dacf606621fe1" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_core_pipeline", + "bevy_derive", + "bevy_ecs", + "bevy_math", + "bevy_reflect", + "bevy_render", + "bevy_transform", + "bevy_utils", + "bevy_window", + "bitflags 2.4.1", + "bytemuck", + "fixedbitset", + "naga_oil", + "radsort", + "smallvec", + "thread_local", +] + +[[package]] +name = "bevy_ptr" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "308a02679f6ce21ef71de20fae6d6a2016c07baa21d8e8d0558e6b7851e8adf2" + +[[package]] +name = "bevy_rapier3d" +version = "0.23.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3f0a2641af76c9eb17da0dcb0fb20cd9d615b93b67be0b85f1867487e956b5a" +dependencies = [ + "bevy", + "bitflags 2.4.1", + "log", + "nalgebra", + "rapier3d", + "serde", +] + +[[package]] +name = "bevy_reflect" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdd56914a8ad57621d7a1a099f7e6b1f7482c9c76cedc9c3d4c175a203939c5d" +dependencies = [ + "bevy_math", + "bevy_ptr", + "bevy_reflect_derive", + "bevy_utils", + "downcast-rs", + "erased-serde", + "glam", + "serde", + "smallvec", + "smol_str", + "thiserror", +] + +[[package]] +name = "bevy_reflect_derive" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "25f627907c40ac552f798423447fc331fc1ddacd94c5f7a2a70942eb06bc8447" +dependencies = [ + "bevy_macro_utils", + "proc-macro2", + "quote", + "syn 2.0.39", + "uuid", +] + +[[package]] +name = "bevy_render" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "90d777f4c51bd58e9e40777c6cb8dde0778df7e2c5298b3f9e3455bd12a9856c" +dependencies = [ + "async-channel", + "bevy_app", + "bevy_asset", + "bevy_core", + "bevy_derive", + "bevy_ecs", + "bevy_encase_derive", + "bevy_hierarchy", + "bevy_log", + "bevy_math", + "bevy_mikktspace", + "bevy_reflect", + "bevy_render_macros", + "bevy_tasks", + "bevy_time", + "bevy_transform", + "bevy_utils", + "bevy_window", + "bitflags 2.4.1", + "bytemuck", + "codespan-reporting", + "downcast-rs", + "encase", + "futures-lite", + "hexasphere", + "image", + "js-sys", + "ktx2", + "naga", + "naga_oil", + "ruzstd", + "serde", + "smallvec", + "thiserror", + "thread_local", + "wasm-bindgen", + "web-sys", + "wgpu", +] + +[[package]] +name = "bevy_render_macros" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "35b00c3d0abff94a729460fc9aa95c2ceac71b49b3041166bb5ba3098e9657e7" +dependencies = [ + "bevy_macro_utils", + "proc-macro2", + "quote", + "syn 2.0.39", +] + +[[package]] +name = "bevy_scene" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba6294396a6375f0b14341d8003408c10aa040e3f833ac8bd49677170ec55d73" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_derive", + "bevy_ecs", + "bevy_hierarchy", + "bevy_reflect", + "bevy_render", + "bevy_transform", + "bevy_utils", + "ron", + "serde", + "thiserror", + "uuid", +] + +[[package]] +name = "bevy_sprite" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4f7d1f88a6e5497fdafd95c20984a1d1b5517bc39d51600b4988cd60c51837a" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_core_pipeline", + "bevy_derive", + "bevy_ecs", + "bevy_log", + "bevy_math", + "bevy_reflect", + "bevy_render", + "bevy_transform", + "bevy_utils", + "bitflags 2.4.1", + "bytemuck", + "fixedbitset", + "guillotiere", + "radsort", + "rectangle-pack", + "thiserror", +] + +[[package]] +name = "bevy_tasks" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a45be906618192515bc613e46546150089adbb4a82178dc462045acd1e89e92" +dependencies = [ + "async-channel", + "async-executor", + "async-task", + "concurrent-queue", + "futures-lite", + "wasm-bindgen-futures", +] + +[[package]] +name = "bevy_text" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c136af700af4f87c94f68d6e019528c371bf09ebf4a8ff7468bb3c73806b34f5" +dependencies = [ + "ab_glyph", + "bevy_app", + "bevy_asset", + "bevy_ecs", + "bevy_math", + "bevy_reflect", + "bevy_render", + "bevy_sprite", + "bevy_transform", + "bevy_utils", + "bevy_window", + "glyph_brush_layout", + "serde", + "thiserror", +] + +[[package]] +name = "bevy_time" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b29709cadf22d318a0b7c79f763e9c5ac414292bd0e850066fa935959021b276" +dependencies = [ + "bevy_app", + "bevy_ecs", + "bevy_reflect", + "bevy_utils", + "crossbeam-channel", + "serde", + "thiserror", +] + +[[package]] +name = "bevy_transform" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70262c51e915b6224129206d23823364e650cf5eb5f4b6ce3ee379f608c180d2" +dependencies = [ + "bevy_app", + "bevy_ecs", + "bevy_hierarchy", + "bevy_math", + "bevy_reflect", + "serde", + "thiserror", +] + +[[package]] +name = "bevy_ui" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd5ecbf2dceaab118769dd870e34d780bfde556af561fd10d8d613b0f237297e" +dependencies = [ + "bevy_a11y", + "bevy_app", + "bevy_asset", + "bevy_core_pipeline", + "bevy_derive", + "bevy_ecs", + "bevy_hierarchy", + "bevy_input", + "bevy_log", + "bevy_math", + "bevy_reflect", + "bevy_render", + "bevy_sprite", + "bevy_text", + "bevy_transform", + "bevy_utils", + "bevy_window", + "bytemuck", + "serde", + "smallvec", + "taffy", + "thiserror", +] + +[[package]] +name = "bevy_utils" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8e75d4a34ef0b15dffd1ee9079ef1f0f5139527e192b9d5708b3e158777c753" +dependencies = [ + "ahash", + "bevy_utils_proc_macros", + "getrandom", + "hashbrown 0.14.2", + "instant", + "nonmax", + "petgraph", + "thiserror", + "tracing", + "uuid", +] + +[[package]] +name = "bevy_utils_proc_macros" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f7dfd3735a61a1b681ed1e176afe4eae731bbb03e51ad871e9eb39e76a2d170e" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.39", +] + +[[package]] +name = "bevy_window" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e60d1830b3fbd7db5bfea7ac9fcd0f5e1d1af88c91ab469e697ab176d8b3140b" +dependencies = [ + "bevy_a11y", + "bevy_app", + "bevy_ecs", + "bevy_input", + "bevy_math", + "bevy_reflect", + "bevy_utils", + "raw-window-handle", + "serde", +] + +[[package]] +name = "bevy_winit" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f8294e78c6a1f9c34d36501a377c5d20bf0fa23a0958187bb270187741448ba" +dependencies = [ + "accesskit_winit", + "approx", + "bevy_a11y", + "bevy_app", + "bevy_derive", + "bevy_ecs", + "bevy_hierarchy", + "bevy_input", + "bevy_math", + "bevy_tasks", + "bevy_utils", + "bevy_window", + "crossbeam-channel", + "raw-window-handle", + "wasm-bindgen", + "web-sys", + "winit", +] + +[[package]] +name = "bindgen" +version = "0.68.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "726e4313eb6ec35d2730258ad4e15b547ee75d6afaa1361a922e78e59b7d8078" +dependencies = [ + "bitflags 2.4.1", + "cexpr", + "clang-sys", + "lazy_static", + "lazycell", + "peeking_take_while", + "proc-macro2", + "quote", + "regex", + "rustc-hash", + "shlex", + "syn 2.0.39", +] + +[[package]] +name = "bit-set" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1" +dependencies = [ + "bit-vec", +] + +[[package]] +name = "bit-vec" +version = "0.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb" +dependencies = [ + "serde", +] + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "bitflags" +version = "2.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "327762f6e5a765692301e5bb513e0d9fef63be86bbc14528052b1cd3e6f03e07" +dependencies = [ + "serde", +] + +[[package]] +name = "blake3" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0231f06152bf547e9c2b5194f247cd97aacf6dcd8b15d8e5ec0663f64580da87" +dependencies = [ + "arrayref", + "arrayvec", + "cc", + "cfg-if", + "constant_time_eq", +] + +[[package]] +name = "block" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d8c1fef690941d3e7788d328517591fecc684c084084702d6ff1641e993699a" + +[[package]] +name = "block-sys" +version = "0.1.0-beta.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fa55741ee90902547802152aaf3f8e5248aab7e21468089560d4c8840561146" +dependencies = [ + "objc-sys", +] + +[[package]] +name = "block2" +version = "0.2.0-alpha.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8dd9e63c1744f755c2f60332b88de39d341e5e86239014ad839bd71c106dec42" +dependencies = [ + "block-sys", + "objc2-encode", +] + +[[package]] +name = "blocking" +version = "1.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c36a4d0d48574b3dd360b4b7d95cc651d2b6557b6402848a27d4b228a473e2a" +dependencies = [ + "async-channel", + "async-lock", + "async-task", + "fastrand 2.0.1", + "futures-io", + "futures-lite", + "piper", + "tracing", +] + +[[package]] +name = "bstr" +version = "1.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "542f33a8835a0884b006a0c3df3dadd99c0c3f296ed26c2fdc8028e01ad6230c" +dependencies = [ + "memchr", + "regex-automata 0.4.3", + "serde", +] + +[[package]] +name = "bumpalo" +version = "3.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f30e7476521f6f8af1a1c4c0b8cc94f0bee37d91763d0ca2665f299b6cd8aec" + +[[package]] +name = "bytemuck" +version = "1.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "374d28ec25809ee0e23827c2ab573d729e293f281dfe393500e7ad618baa61c6" +dependencies = [ + "bytemuck_derive", +] + +[[package]] +name = "bytemuck_derive" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "965ab7eb5f8f97d2a083c799f3a1b994fc397b2fe2da5d1da1626ce15a39f2b1" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.39", +] + +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + +[[package]] +name = "bytes" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223" + +[[package]] +name = "cc" +version = "1.0.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0" +dependencies = [ + "jobserver", + "libc", +] + +[[package]] +name = "cesu8" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c" + +[[package]] +name = "cexpr" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766" +dependencies = [ + "nom", +] + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "cfg_aliases" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e" + +[[package]] +name = "clang-sys" +version = "1.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c688fc74432808e3eb684cae8830a86be1d66a2bd58e1f248ed0960a590baf6f" +dependencies = [ + "glob", + "libc", + "libloading 0.7.4", +] + +[[package]] +name = "clipboard-win" +version = "4.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7191c27c2357d9b7ef96baac1773290d4ca63b24205b82a3fd8a0637afcf0362" +dependencies = [ + "error-code", + "str-buf", + "winapi", +] + +[[package]] +name = "codespan-reporting" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e" +dependencies = [ + "termcolor", + "unicode-width", +] + +[[package]] +name = "color_quant" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b" + +[[package]] +name = "com-rs" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf43edc576402991846b093a7ca18a3477e0ef9c588cde84964b5d3e43016642" + +[[package]] +name = "combine" +version = "4.6.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "35ed6e9d84f0b51a7f52daf1c7d71dd136fd7a3f41a8462b8cdb8c78d920fad4" +dependencies = [ + "bytes", + "memchr", +] + +[[package]] +name = "concurrent-queue" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f057a694a54f12365049b0958a1685bb52d567f5593b355fbf685838e873d400" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "console_error_panic_hook" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc" +dependencies = [ + "cfg-if", + "wasm-bindgen", +] + +[[package]] +name = "const_panic" +version = "0.2.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6051f239ecec86fde3410901ab7860d458d160371533842974fc61f96d15879b" + +[[package]] +name = "const_soft_float" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87ca1caa64ef4ed453e68bb3db612e51cf1b2f5b871337f0fcab1c8f87cc3dff" + +[[package]] +name = "constant_time_eq" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f7144d30dcf0fafbce74250a3963025d8d52177934239851c917d29f1df280c2" + +[[package]] +name = "constgebra" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edd23e864550e6dafc1e41ac78ce4f1ccddc8672b40c403524a04ff3f0518420" +dependencies = [ + "const_soft_float", +] + +[[package]] +name = "core-foundation" +version = "0.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e496a50fda8aacccc86d7529e2c1e0892dbd0f898a6b5645b5561b89c3210efa" + +[[package]] +name = "core-graphics" +version = "0.22.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2581bbab3b8ffc6fcbd550bf46c355135d16e9ff2a6ea032ad6b9bf1d7efe4fb" +dependencies = [ + "bitflags 1.3.2", + "core-foundation", + "core-graphics-types", + "foreign-types 0.3.2", + "libc", +] + +[[package]] +name = "core-graphics-types" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2bb142d41022986c1d8ff29103a1411c8a3dfad3552f87a4f8dc50d61d4f4e33" +dependencies = [ + "bitflags 1.3.2", + "core-foundation", + "libc", +] + +[[package]] +name = "coreaudio-rs" +version = "0.11.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "321077172d79c662f64f5071a03120748d5bb652f5231570141be24cfcd2bace" +dependencies = [ + "bitflags 1.3.2", + "core-foundation-sys", + "coreaudio-sys", +] + +[[package]] +name = "coreaudio-sys" +version = "0.2.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8478e5bdad14dce236b9898ea002eabfa87cbe14f0aa538dbe3b6a4bec4332d" +dependencies = [ + "bindgen", +] + +[[package]] +name = "cpal" +version = "0.15.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d959d90e938c5493000514b446987c07aed46c668faaa7d34d6c7a67b1a578c" +dependencies = [ + "alsa", + "core-foundation-sys", + "coreaudio-rs", + "dasp_sample", + "jni 0.19.0", + "js-sys", + "libc", + "mach2", + "ndk", + "ndk-context", + "oboe", + "once_cell", + "parking_lot", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "windows 0.46.0", +] + +[[package]] +name = "crc32fast" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "crossbeam" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2801af0d36612ae591caa9568261fddce32ce6e08a7275ea334a06a4ad021a2c" +dependencies = [ + "cfg-if", + "crossbeam-channel", + "crossbeam-deque", + "crossbeam-epoch", + "crossbeam-queue", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-channel" +version = "0.5.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a33c2bf77f2df06183c3aa30d1e96c0695a313d4f9c453cc3762a6db39f99200" +dependencies = [ + "cfg-if", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-deque" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce6fd6f855243022dcecf8702fef0c297d4338e226845fe067f6341ad9fa0cef" +dependencies = [ + "cfg-if", + "crossbeam-epoch", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-epoch" +version = "0.9.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae211234986c545741a7dc064309f67ee1e5ad243d0e48335adc0484d960bcc7" +dependencies = [ + "autocfg", + "cfg-if", + "crossbeam-utils", + "memoffset 0.9.0", + "scopeguard", +] + +[[package]] +name = "crossbeam-queue" +version = "0.3.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d1cfb3ea8a53f37c40dea2c7bedcbd88bdfae54f5e2175d6ecaff1c988353add" +dependencies = [ + "cfg-if", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a22b2d63d4d1dc0b7f1b6b2747dd0088008a9be28b6ddf0b1e7d335e3037294" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "d3d12" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e16e44ab292b1dddfdaf7be62cfd8877df52f2f3fde5858d95bab606be259f20" +dependencies = [ + "bitflags 2.4.1", + "libloading 0.8.1", + "winapi", +] + +[[package]] +name = "dasp_sample" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f" + +[[package]] +name = "data-encoding" +version = "2.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2e66c9d817f1720209181c316d28635c050fa304f9c79e47a520882661b7308" + +[[package]] +name = "dispatch" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd0c93bb4b0c6d9b77f4435b0ae98c24d17f1c45b2ff844c6151a07256ca923b" + +[[package]] +name = "downcast-rs" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ea835d29036a4087793836fa931b08837ad5e957da9e23886b29586fb9b6650" + +[[package]] +name = "duplicate" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "de78e66ac9061e030587b2a2e75cc88f22304913c907b11307bca737141230cb" +dependencies = [ + "heck", + "proc-macro-error", +] + +[[package]] +name = "ecolor" +version = "0.23.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfdf4e52dbbb615cfd30cf5a5265335c217b5fd8d669593cea74a517d9c605af" +dependencies = [ + "bytemuck", +] + +[[package]] +name = "egui" +version = "0.23.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8bd69fed5fcf4fbb8225b24e80ea6193b61e17a625db105ef0c4d71dde6eb8b7" +dependencies = [ + "ahash", + "epaint", + "nohash-hasher", +] + +[[package]] +name = "egui-gizmo" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f732ad247afe275d6cf901e0f134025ad735007c8f4d82e667a6871f1b4a5441" +dependencies = [ + "egui", + "glam", +] + +[[package]] +name = "egui_dock" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a52f67bcab0eb6050cf8051c614966c1c57129fab23dbeae9c157214779053c7" +dependencies = [ + "duplicate", + "egui", + "paste", +] + +[[package]] +name = "either" +version = "1.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07" + +[[package]] +name = "emath" +version = "0.23.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ef2b29de53074e575c18b694167ccbe6e5191f7b25fe65175a0d905a32eeec0" +dependencies = [ + "bytemuck", +] + +[[package]] +name = "encase" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fce2eeef77fd4a293a54b62aa00ac9daebfbcda4bf8998c5a815635b004aa1c" +dependencies = [ + "const_panic", + "encase_derive", + "glam", + "thiserror", +] + +[[package]] +name = "encase_derive" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0e520cde08cbf4f7cc097f61573ec06ce467019803de8ae82fb2823fa1554a0e" +dependencies = [ + "encase_derive_impl", +] + +[[package]] +name = "encase_derive_impl" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3fe2568f851fd6144a45fa91cfed8fe5ca8fc0b56ba6797bfc1ed2771b90e37c" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.39", +] + +[[package]] +name = "epaint" +version = "0.23.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "58067b840d009143934d91d8dcb8ded054d8301d7c11a517ace0a99bb1e1595e" +dependencies = [ + "ab_glyph", + "ahash", + "bytemuck", + "ecolor", + "emath", + "nohash-hasher", + "parking_lot", +] + +[[package]] +name = "equivalent" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" + +[[package]] +name = "erased-serde" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c138974f9d5e7fe373eb04df7cae98833802ae4b11c24ac7039a21d5af4b26c" +dependencies = [ + "serde", +] + +[[package]] +name = "error-code" +version = "2.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "64f18991e7bf11e7ffee451b5318b5c1a73c52d0d0ada6e5a3017c8c1ced6a21" +dependencies = [ + "libc", + "str-buf", +] + +[[package]] +name = "euclid" +version = "0.22.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87f253bc5c813ca05792837a0ff4b3a580336b224512d48f7eda1d7dd9210787" +dependencies = [ + "num-traits", +] + +[[package]] +name = "event-listener" +version = "2.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0" + +[[package]] +name = "fastrand" +version = "1.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e51093e27b0797c359783294ca4f0a911c270184cb10f85783b118614a1501be" +dependencies = [ + "instant", +] + +[[package]] +name = "fastrand" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "25cbce373ec4653f1a01a31e8a5e5ec0c622dc27ff9c4e6606eefef5cbbed4a5" + +[[package]] +name = "fdeflate" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "64d6dafc854908ff5da46ff3f8f473c6984119a2876a383a860246dd7841a868" +dependencies = [ + "simd-adler32", +] + +[[package]] +name = "fixedbitset" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80" + +[[package]] +name = "flate2" +version = "1.0.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46303f565772937ffe1d394a4fac6f411c6013172fadde9dcdb1e147a086940e" +dependencies = [ + "crc32fast", + "miniz_oxide", +] + +[[package]] +name = "fnv" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" + +[[package]] +name = "foreign-types" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1" +dependencies = [ + "foreign-types-shared 0.1.1", +] + +[[package]] +name = "foreign-types" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965" +dependencies = [ + "foreign-types-macros", + "foreign-types-shared 0.3.1", +] + +[[package]] +name = "foreign-types-macros" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.39", +] + +[[package]] +name = "foreign-types-shared" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" + +[[package]] +name = "foreign-types-shared" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b" + +[[package]] +name = "form_urlencoded" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a62bc1cf6f830c2ec14a513a9fb124d0a213a629668a4186f329db21fe045652" +dependencies = [ + "percent-encoding", +] + +[[package]] +name = "futures-core" +version = "0.3.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eb1d22c66e66d9d72e1758f0bd7d4fd0bee04cad842ee34587d68c07e45d088c" + +[[package]] +name = "futures-io" +version = "0.3.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8bf34a163b5c4c52d0478a4d757da8fb65cabef42ba90515efee0f6f9fa45aaa" + +[[package]] +name = "futures-lite" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49a9d51ce47660b1e808d3c990b4709f2f415d928835a17dfd16991515c46bce" +dependencies = [ + "fastrand 1.9.0", + "futures-core", + "futures-io", + "memchr", + "parking", + "pin-project-lite", + "waker-fn", +] + +[[package]] +name = "gethostname" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c1ebd34e35c46e00bb73e81363248d627782724609fe1b6396f553f68fe3862e" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "getrandom" +version = "0.2.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe9006bed769170c11f845cf00c7c1e9092aeb3f268e007c3e760ac68008070f" +dependencies = [ + "cfg-if", + "js-sys", + "libc", + "wasi", + "wasm-bindgen", +] + +[[package]] +name = "gilrs" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e9eec02069fcbd7abe00a28adf216547774889129a777cb5e53fdfb75d59f09" +dependencies = [ + "fnv", + "gilrs-core", + "log", + "uuid", + "vec_map", +] + +[[package]] +name = "gilrs-core" +version = "0.5.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e11f4e03be4f1beda399e4791c11d33102fa48f368e864259e4e810d3a3d2ff5" +dependencies = [ + "core-foundation", + "inotify", + "io-kit-sys", + "js-sys", + "libc", + "libudev-sys", + "log", + "nix 0.27.1", + "uuid", + "vec_map", + "wasm-bindgen", + "web-sys", + "windows 0.51.1", +] + +[[package]] +name = "gimli" +version = "0.28.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6fb8d784f27acf97159b40fc4db5ecd8aa23b9ad5ef69cdd136d3bc80665f0c0" + +[[package]] +name = "glam" +version = "0.24.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5418c17512bdf42730f9032c74e1ae39afc408745ebb2acf72fbc4691c17945" +dependencies = [ + "bytemuck", + "serde", +] + +[[package]] +name = "glob" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b" + +[[package]] +name = "glow" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca0fe580e4b60a8ab24a868bc08e2f03cbcb20d3d676601fa909386713333728" +dependencies = [ + "js-sys", + "slotmap", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "gltf" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad2dcfb6dd7a66f9eb3d181a29dcfb22d146b0bcdc2e1ed1713cbf03939a88ea" +dependencies = [ + "byteorder", + "gltf-json", + "lazy_static", +] + +[[package]] +name = "gltf-derive" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2cbcea5dd47e7ad4e9ee6f040384fcd7204bbf671aa4f9e7ca7dfc9bfa1de20" +dependencies = [ + "inflections", + "proc-macro2", + "quote", + "syn 2.0.39", +] + +[[package]] +name = "gltf-json" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d5b810806b78dde4b71a95cc0e6fdcab34c4c617da3574df166f9987be97d03" +dependencies = [ + "gltf-derive", + "serde", + "serde_derive", + "serde_json", +] + +[[package]] +name = "glyph_brush_layout" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc32c2334f00ca5ac3695c5009ae35da21da8c62d255b5b96d56e2597a637a38" +dependencies = [ + "ab_glyph", + "approx", + "xi-unicode", +] + +[[package]] +name = "gpu-alloc" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fbcd2dba93594b227a1f57ee09b8b9da8892c34d55aa332e034a228d0fe6a171" +dependencies = [ + "bitflags 2.4.1", + "gpu-alloc-types", +] + +[[package]] +name = "gpu-alloc-types" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "98ff03b468aa837d70984d55f5d3f846f6ec31fe34bbb97c4f85219caeee1ca4" +dependencies = [ + "bitflags 2.4.1", +] + +[[package]] +name = "gpu-allocator" +version = "0.22.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce95f9e2e11c2c6fadfce42b5af60005db06576f231f5c92550fdded43c423e8" +dependencies = [ + "backtrace", + "log", + "thiserror", + "winapi", + "windows 0.44.0", +] + +[[package]] +name = "gpu-descriptor" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc11df1ace8e7e564511f53af41f3e42ddc95b56fd07b3f4445d2a6048bc682c" +dependencies = [ + "bitflags 2.4.1", + "gpu-descriptor-types", + "hashbrown 0.14.2", +] + +[[package]] +name = "gpu-descriptor-types" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6bf0b36e6f090b7e1d8a4b49c0cb81c1f8376f72198c65dd3ad9ff3556b8b78c" +dependencies = [ + "bitflags 2.4.1", +] + +[[package]] +name = "grid" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eec1c01eb1de97451ee0d60de7d81cf1e72aabefb021616027f3d1c3ec1c723c" + +[[package]] +name = "guillotiere" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b62d5865c036cb1393e23c50693df631d3f5d7bcca4c04fe4cc0fd592e74a782" +dependencies = [ + "euclid", + "svg_fmt", +] + +[[package]] +name = "hashbrown" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" + +[[package]] +name = "hashbrown" +version = "0.14.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f93e7192158dbcda357bdec5fb5788eebf8bbac027f3f33e719d29135ae84156" +dependencies = [ + "ahash", + "allocator-api2", + "serde", +] + +[[package]] +name = "hassle-rs" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1397650ee315e8891a0df210707f0fc61771b0cc518c3023896064c5407cb3b0" +dependencies = [ + "bitflags 1.3.2", + "com-rs", + "libc", + "libloading 0.7.4", + "thiserror", + "widestring", + "winapi", +] + +[[package]] +name = "heck" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8" + +[[package]] +name = "hexasphere" +version = "9.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7cb3df16a7bcb1b5bc092abd55e14f77ca70aea14445026e264586fc62889a10" +dependencies = [ + "constgebra", + "glam", +] + +[[package]] +name = "hexf-parse" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df" + +[[package]] +name = "home" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5444c27eef6923071f7ebcc33e3444508466a76f7a2b93da00ed6e19f30c1ddb" +dependencies = [ + "windows-sys 0.48.0", +] + +[[package]] +name = "idna" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d20d6b07bfbc108882d88ed8e37d39636dcc260e15e30c45e6ba089610b917c" +dependencies = [ + "unicode-bidi", + "unicode-normalization", +] + +[[package]] +name = "image" +version = "0.24.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f3dfdbdd72063086ff443e297b61695500514b1e41095b6fb9a5ab48a70a711" +dependencies = [ + "bytemuck", + "byteorder", + "color_quant", + "num-rational", + "num-traits", + "png", + "tiff", +] + +[[package]] +name = "indexmap" +version = "1.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99" +dependencies = [ + "autocfg", + "hashbrown 0.12.3", + "serde", +] + +[[package]] +name = "indexmap" +version = "2.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d530e1a18b1cb4c484e6e34556a0d948706958449fca0cab753d649f2bce3d1f" +dependencies = [ + "equivalent", + "hashbrown 0.14.2", +] + +[[package]] +name = "inflections" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a257582fdcde896fd96463bf2d40eefea0580021c0712a0e2b028b60b47a837a" + +[[package]] +name = "inotify" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdd168d97690d0b8c412d6b6c10360277f4d7ee495c5d0d5d5fe0854923255cc" +dependencies = [ + "bitflags 1.3.2", + "futures-core", + "inotify-sys", + "libc", + "tokio", +] + +[[package]] +name = "inotify-sys" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e05c02b5e89bff3b946cedeca278abc628fe811e604f027c45a8aa3cf793d0eb" +dependencies = [ + "libc", +] + +[[package]] +name = "instant" +version = "0.1.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c" +dependencies = [ + "cfg-if", + "js-sys", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "io-kit-sys" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4769cb30e5dcf1710fc6730d3e94f78c47723a014a567de385e113c737394640" +dependencies = [ + "core-foundation-sys", + "mach2", +] + +[[package]] +name = "itoa" +version = "1.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af150ab688ff2122fcef229be89cb50dd66af9e01a4ff320cc137eecc9bacc38" + +[[package]] +name = "jni" +version = "0.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6df18c2e3db7e453d3c6ac5b3e9d5182664d28788126d39b91f2d1e22b017ec" +dependencies = [ + "cesu8", + "combine", + "jni-sys", + "log", + "thiserror", + "walkdir", +] + +[[package]] +name = "jni" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "039022cdf4d7b1cf548d31f60ae783138e5fd42013f6271049d7df7afadef96c" +dependencies = [ + "cesu8", + "combine", + "jni-sys", + "log", + "thiserror", + "walkdir", +] + +[[package]] +name = "jni" +version = "0.21.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97" +dependencies = [ + "cesu8", + "cfg-if", + "combine", + "jni-sys", + "log", + "thiserror", + "walkdir", + "windows-sys 0.45.0", +] + +[[package]] +name = "jni-sys" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130" + +[[package]] +name = "jobserver" +version = "0.1.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c37f63953c4c63420ed5fd3d6d398c719489b9f872b9fa683262f8edd363c7d" +dependencies = [ + "libc", +] + +[[package]] +name = "jpeg-decoder" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bc0000e42512c92e31c2252315bda326620a4e034105e900c98ec492fa077b3e" + +[[package]] +name = "js-sys" +version = "0.3.65" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "54c0c35952f67de54bb584e9fd912b3023117cbafc0a77d8f3dee1fb5f572fe8" +dependencies = [ + "wasm-bindgen", +] + +[[package]] +name = "khronos-egl" +version = "4.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c2352bd1d0bceb871cb9d40f24360c8133c11d7486b68b5381c1dd1a32015e3" +dependencies = [ + "libc", + "libloading 0.7.4", + "pkg-config", +] + +[[package]] +name = "ktx2" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87d65e08a9ec02e409d27a0139eaa6b9756b4d81fe7cde71f6941a83730ce838" +dependencies = [ + "bitflags 1.3.2", +] + +[[package]] +name = "lazy_static" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" + +[[package]] +name = "lazycell" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55" + +[[package]] +name = "lewton" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "777b48df9aaab155475a83a7df3070395ea1ac6902f5cd062b8f2b028075c030" +dependencies = [ + "byteorder", + "ogg", + "tinyvec", +] + +[[package]] +name = "libc" +version = "0.2.150" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "89d92a4743f9a61002fae18374ed11e7973f530cb3a3255fb354818118b2203c" + +[[package]] +name = "libloading" +version = "0.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f" +dependencies = [ + "cfg-if", + "winapi", +] + +[[package]] +name = "libloading" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c571b676ddfc9a8c12f1f3d3085a7b163966a8fd8098a90640953ce5f6170161" +dependencies = [ + "cfg-if", + "windows-sys 0.48.0", +] + +[[package]] +name = "libm" +version = "0.2.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058" + +[[package]] +name = "libredox" +version = "0.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3af92c55d7d839293953fcd0fda5ecfe93297cfde6ffbdec13b41d99c0ba6607" +dependencies = [ + "bitflags 2.4.1", + "libc", + "redox_syscall 0.4.1", +] + +[[package]] +name = "libudev-sys" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c8469b4a23b962c1396b9b451dda50ef5b283e8dd309d69033475fa9b334324" +dependencies = [ + "libc", + "pkg-config", +] + +[[package]] +name = "lock_api" +version = "0.4.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45" +dependencies = [ + "autocfg", + "scopeguard", +] + +[[package]] +name = "log" +version = "0.4.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f" + +[[package]] +name = "mach2" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d0d1830bcd151a6fc4aea1369af235b36c1528fe976b8ff678683c9995eade8" +dependencies = [ + "libc", +] + +[[package]] +name = "malloc_buf" +version = "0.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb" +dependencies = [ + "libc", +] + +[[package]] +name = "matchers" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558" +dependencies = [ + "regex-automata 0.1.10", +] + +[[package]] +name = "matrixmultiply" +version = "0.3.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7574c1cf36da4798ab73da5b215bbf444f50718207754cb522201d78d1cd0ff2" +dependencies = [ + "autocfg", + "rawpointer", +] + +[[package]] +name = "memchr" +version = "2.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f665ee40bc4a3c5590afb1e9677db74a508659dfd71e126420da8274909a0167" + +[[package]] +name = "memoffset" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce" +dependencies = [ + "autocfg", +] + +[[package]] +name = "memoffset" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a634b1c61a95585bd15607c6ab0c4e5b226e695ff2800ba0cdccddf208c406c" +dependencies = [ + "autocfg", +] + +[[package]] +name = "metal" +version = "0.26.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "623b5e6cefd76e58f774bd3cc0c6f5c7615c58c03a97815245a25c3c9bdee318" +dependencies = [ + "bitflags 2.4.1", + "block", + "core-graphics-types", + "foreign-types 0.5.0", + "log", + "objc", + "paste", +] + +[[package]] +name = "minimal-lexical" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" + +[[package]] +name = "miniz_oxide" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7" +dependencies = [ + "adler", + "simd-adler32", +] + +[[package]] +name = "mio" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3dce281c5e46beae905d4de1870d8b1509a9142b62eedf18b443b011ca8343d0" +dependencies = [ + "libc", + "log", + "wasi", + "windows-sys 0.48.0", +] + +[[package]] +name = "naga" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c1ceaaa4eedaece7e4ec08c55c640ba03dbb73fb812a6570a59bcf1930d0f70e" +dependencies = [ + "bit-set", + "bitflags 2.4.1", + "codespan-reporting", + "hexf-parse", + "indexmap 1.9.3", + "log", + "num-traits", + "pp-rs", + "rustc-hash", + "spirv", + "termcolor", + "thiserror", + "unicode-xid", +] + +[[package]] +name = "naga_oil" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1fa9518ff79ae8a98c3abe3897d873a85561d1b5642981c2245c1c4b9b2429d" +dependencies = [ + "bit-set", + "codespan-reporting", + "data-encoding", + "indexmap 1.9.3", + "naga", + "once_cell", + "regex", + "regex-syntax 0.7.5", + "rustc-hash", + "thiserror", + "tracing", + "unicode-ident", +] + +[[package]] +name = "nalgebra" +version = "0.32.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "307ed9b18cc2423f29e83f84fd23a8e73628727990181f18641a8b5dc2ab1caa" +dependencies = [ + "approx", + "glam", + "matrixmultiply", + "nalgebra-macros", + "num-complex", + "num-rational", + "num-traits", + "serde", + "simba", + "typenum", +] + +[[package]] +name = "nalgebra-macros" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91761aed67d03ad966ef783ae962ef9bbaca728d2dd7ceb7939ec110fffad998" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "ndk" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "451422b7e4718271c8b5b3aadf5adedba43dc76312454b387e98fae0fc951aa0" +dependencies = [ + "bitflags 1.3.2", + "jni-sys", + "ndk-sys", + "num_enum 0.5.11", + "raw-window-handle", + "thiserror", +] + +[[package]] +name = "ndk-context" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b" + +[[package]] +name = "ndk-sys" +version = "0.4.1+23.1.7779620" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3cf2aae958bd232cac5069850591667ad422d263686d75b52a065f9badeee5a3" +dependencies = [ + "jni-sys", +] + +[[package]] +name = "nix" +version = "0.24.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa52e972a9a719cecb6864fb88568781eb706bac2cd1d4f04a648542dbf78069" +dependencies = [ + "bitflags 1.3.2", + "cfg-if", + "libc", + "memoffset 0.6.5", +] + +[[package]] +name = "nix" +version = "0.27.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2eb04e9c688eff1c89d72b407f168cf79bb9e867a9d3323ed6c01519eb9cc053" +dependencies = [ + "bitflags 2.4.1", + "cfg-if", + "libc", +] + +[[package]] +name = "nohash-hasher" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451" + +[[package]] +name = "nom" +version = "7.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a" +dependencies = [ + "memchr", + "minimal-lexical", +] + +[[package]] +name = "nonmax" +version = "0.5.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e4a593ea4fffed8684ad13d75c82cf0b6dc2b88947e0ed85b9e70f555a7e422" + +[[package]] +name = "normpath" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec60c60a693226186f5d6edf073232bfb6464ed97eb22cf3b01c1e8198fd97f5" +dependencies = [ + "windows-sys 0.48.0", +] + +[[package]] +name = "ntapi" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e8a3895c6391c39d7fe7ebc444a87eb2991b2a0bc718fdabd071eec617fc68e4" +dependencies = [ + "winapi", +] + +[[package]] +name = "nu-ansi-term" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84" +dependencies = [ + "overload", + "winapi", +] + +[[package]] +name = "num-complex" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ba157ca0885411de85d6ca030ba7e2a83a28636056c7c699b07c8b6f7383214" +dependencies = [ + "num-traits", + "serde", +] + +[[package]] +name = "num-derive" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "876a53fff98e03a936a674b29568b0e605f06b29372c2489ff4de23f1949743d" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "num-integer" +version = "0.1.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9" +dependencies = [ + "autocfg", + "num-traits", +] + +[[package]] +name = "num-rational" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0638a1c9d0a3c0914158145bc76cff373a75a627e6ecbfb71cbe6f453a5a19b0" +dependencies = [ + "autocfg", + "num-integer", + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39e3200413f237f41ab11ad6d161bc7239c84dcb631773ccd7de3dfe4b5c267c" +dependencies = [ + "autocfg", + "libm", +] + +[[package]] +name = "num_enum" +version = "0.5.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1f646caf906c20226733ed5b1374287eb97e3c2a5c227ce668c1f2ce20ae57c9" +dependencies = [ + "num_enum_derive 0.5.11", +] + +[[package]] +name = "num_enum" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a015b430d3c108a207fd776d2e2196aaf8b1cf8cf93253e3a097ff3085076a1" +dependencies = [ + "num_enum_derive 0.6.1", +] + +[[package]] +name = "num_enum_derive" +version = "0.5.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dcbff9bc912032c62bf65ef1d5aea88983b420f4f839db1e9b0c281a25c9c799" +dependencies = [ + "proc-macro-crate", + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "num_enum_derive" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96667db765a921f7b295ffee8b60472b686a51d4f21c2ee4ffdb94c7013b65a6" +dependencies = [ + "proc-macro-crate", + "proc-macro2", + "quote", + "syn 2.0.39", +] + +[[package]] +name = "objc" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1" +dependencies = [ + "malloc_buf", + "objc_exception", +] + +[[package]] +name = "objc-foundation" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1add1b659e36c9607c7aab864a76c7a4c2760cd0cd2e120f3fb8b952c7e22bf9" +dependencies = [ + "block", + "objc", + "objc_id", +] + +[[package]] +name = "objc-sys" +version = "0.2.0-beta.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df3b9834c1e95694a05a828b59f55fa2afec6288359cda67146126b3f90a55d7" + +[[package]] +name = "objc2" +version = "0.3.0-beta.3.patch-leaks.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e01640f9f2cb1220bbe80325e179e532cb3379ebcd1bf2279d703c19fe3a468" +dependencies = [ + "block2", + "objc-sys", + "objc2-encode", +] + +[[package]] +name = "objc2-encode" +version = "2.0.0-pre.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "abfcac41015b00a120608fdaa6938c44cb983fee294351cc4bac7638b4e50512" +dependencies = [ + "objc-sys", +] + +[[package]] +name = "objc_exception" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad970fb455818ad6cba4c122ad012fae53ae8b4795f86378bce65e4f6bab2ca4" +dependencies = [ + "cc", +] + +[[package]] +name = "objc_id" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c92d4ddb4bd7b50d730c215ff871754d0da6b2178849f8a2a2ab69712d0c073b" +dependencies = [ + "objc", +] + +[[package]] +name = "object" +version = "0.32.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9cf5f9dd3933bd50a9e1f149ec995f39ae2c496d31fd772c1fd45ebc27e902b0" +dependencies = [ + "memchr", +] + +[[package]] +name = "oboe" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8868cc237ee02e2d9618539a23a8d228b9bb3fc2e7a5b11eed3831de77c395d0" +dependencies = [ + "jni 0.20.0", + "ndk", + "ndk-context", + "num-derive", + "num-traits", + "oboe-sys", +] + +[[package]] +name = "oboe-sys" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f44155e7fb718d3cfddcf70690b2b51ac4412f347cd9e4fbe511abe9cd7b5f2" +dependencies = [ + "cc", +] + +[[package]] +name = "ogg" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6951b4e8bf21c8193da321bcce9c9dd2e13c858fe078bf9054a288b419ae5d6e" +dependencies = [ + "byteorder", +] + +[[package]] +name = "once_cell" +version = "1.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d" + +[[package]] +name = "opener" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c62dcb6174f9cb326eac248f07e955d5d559c272730b6c03e396b443b562788" +dependencies = [ + "bstr", + "normpath", + "winapi", +] + +[[package]] +name = "orbclient" +version = "0.3.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52f0d54bde9774d3a51dcf281a5def240c71996bc6ca05d2c847ec8b2b216166" +dependencies = [ + "libredox", +] + +[[package]] +name = "overload" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39" + +[[package]] +name = "owned_ttf_parser" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4586edfe4c648c71797a74c84bacb32b52b212eff5dfe2bb9f2c599844023e7" +dependencies = [ + "ttf-parser", +] + +[[package]] +name = "parking" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb813b8af86854136c6922af0598d719255ecb2179515e6e7730d468f05c9cae" + +[[package]] +name = "parking_lot" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f" +dependencies = [ + "lock_api", + "parking_lot_core", +] + +[[package]] +name = "parking_lot_core" +version = "0.9.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall 0.4.1", + "smallvec", + "windows-targets 0.48.5", +] + +[[package]] +name = "parry3d" +version = "0.13.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b55dc0e6db79bddbc5fd583569f7356cdcc63e1e9b2b93a9ab70dd8e717160e0" +dependencies = [ + "approx", + "arrayvec", + "bitflags 1.3.2", + "downcast-rs", + "either", + "indexmap 1.9.3", + "nalgebra", + "num-derive", + "num-traits", + "rustc-hash", + "serde", + "simba", + "slab", + "smallvec", + "spade", +] + +[[package]] +name = "paste" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "de3145af08024dea9fa9914f381a17b8fc6034dfb00f3a84013f7ff43f29ed4c" + +[[package]] +name = "path-slash" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e91099d4268b0e11973f036e885d652fb0b21fedcf69738c627f94db6a44f42" + +[[package]] +name = "peeking_take_while" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099" + +[[package]] +name = "percent-encoding" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b2a4787296e9989611394c33f193f676704af1686e70b8f8033ab5ba9a35a94" + +[[package]] +name = "petgraph" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1d3afd2628e69da2be385eb6f2fd57c8ac7977ceeff6dc166ff1657b0e386a9" +dependencies = [ + "fixedbitset", + "indexmap 2.1.0", +] + +[[package]] +name = "pin-project-lite" +version = "0.2.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58" + +[[package]] +name = "piper" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "668d31b1c4eba19242f2088b2bf3316b82ca31082a8335764db4e083db7485d4" +dependencies = [ + "atomic-waker", + "fastrand 2.0.1", + "futures-io", +] + +[[package]] +name = "pkg-config" +version = "0.3.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26072860ba924cbfa98ea39c8c19b4dd6a4a25423dbdf219c1eca91aa0cf6964" + +[[package]] +name = "png" +version = "0.17.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd75bf2d8dd3702b9707cdbc56a5b9ef42cec752eb8b3bafc01234558442aa64" +dependencies = [ + "bitflags 1.3.2", + "crc32fast", + "fdeflate", + "flate2", + "miniz_oxide", +] + +[[package]] +name = "pp-rs" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb458bb7f6e250e6eb79d5026badc10a3ebb8f9a15d1fff0f13d17c71f4d6dee" +dependencies = [ + "unicode-xid", +] + +[[package]] +name = "ppv-lite86" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" + +[[package]] +name = "pretty-type-name" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0f73cdaf19b52e6143685c3606206e114a4dfa969d6b14ec3894c88eb38bd4b" + +[[package]] +name = "proc-macro-crate" +version = "1.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919" +dependencies = [ + "once_cell", + "toml_edit 0.19.15", +] + +[[package]] +name = "proc-macro-error" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c" +dependencies = [ + "proc-macro-error-attr", + "proc-macro2", + "quote", + "syn 1.0.109", + "version_check", +] + +[[package]] +name = "proc-macro-error-attr" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869" +dependencies = [ + "proc-macro2", + "quote", + "version_check", +] + +[[package]] +name = "proc-macro2" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "134c189feb4956b20f6f547d2cf727d4c0fe06722b20a0eec87ed445a97f92da" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "profiling" +version = "1.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f89dff0959d98c9758c88826cc002e2c3d0b9dfac4139711d1f30de442f1139b" + +[[package]] +name = "quote" +version = "1.0.33" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "radsort" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "17fd96390ed3feda12e1dfe2645ed587e0bea749e319333f104a33ff62f77a0b" + +[[package]] +name = "rand" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +dependencies = [ + "libc", + "rand_chacha", + "rand_core", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom", +] + +[[package]] +name = "range-alloc" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c8a99fddc9f0ba0a85884b8d14e3592853e787d581ca1816c91349b10e4eeab" + +[[package]] +name = "rapier3d" +version = "0.17.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62a8a0bd9d3135f7b4eb45d0796540e7bab47b6b7c974f90567ccc5a0454f42b" +dependencies = [ + "approx", + "arrayvec", + "bit-vec", + "bitflags 1.3.2", + "crossbeam", + "downcast-rs", + "nalgebra", + "num-derive", + "num-traits", + "parry3d", + "rustc-hash", + "serde", + "simba", +] + +[[package]] +name = "raw-window-handle" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2ff9a1f06a88b01621b7ae906ef0211290d1c8a168a15542486a8f61c0833b9" + +[[package]] +name = "rawpointer" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3" + +[[package]] +name = "rectangle-pack" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a0d463f2884048e7153449a55166f91028d5b0ea53c79377099ce4e8cf0cf9bb" + +[[package]] +name = "redox_syscall" +version = "0.3.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29" +dependencies = [ + "bitflags 1.3.2", +] + +[[package]] +name = "redox_syscall" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa" +dependencies = [ + "bitflags 1.3.2", +] + +[[package]] +name = "regex" +version = "1.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "380b951a9c5e80ddfd6136919eef32310721aa4aacd4889a8d39124b026ab343" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata 0.4.3", + "regex-syntax 0.8.2", +] + +[[package]] +name = "regex-automata" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132" +dependencies = [ + "regex-syntax 0.6.29", +] + +[[package]] +name = "regex-automata" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f804c7828047e88b2d32e2d7fe5a105da8ee3264f01902f796c8e067dc2483f" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax 0.8.2", +] + +[[package]] +name = "regex-syntax" +version = "0.6.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1" + +[[package]] +name = "regex-syntax" +version = "0.7.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da" + +[[package]] +name = "regex-syntax" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f" + +[[package]] +name = "renderdoc-sys" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "216080ab382b992234dda86873c18d4c48358f5cfcb70fd693d7f6f2131b628b" + +[[package]] +name = "robust" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cbf4a6aa5f6d6888f39e980649f3ad6b666acdce1d78e95b8a2cb076e687ae30" + +[[package]] +name = "rodio" +version = "0.17.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b1bb7b48ee48471f55da122c0044fcc7600cfcc85db88240b89cb832935e611" +dependencies = [ + "cpal", + "lewton", +] + +[[package]] +name = "ron" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b91f7eff05f748767f183df4320a63d6936e9c6107d97c9e6bdd9784f4289c94" +dependencies = [ + "base64 0.21.5", + "bitflags 2.4.1", + "serde", + "serde_derive", +] + +[[package]] +name = "rustc-demangle" +version = "0.1.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76" + +[[package]] +name = "rustc-hash" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" + +[[package]] +name = "ruzstd" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3ffab8f9715a0d455df4bbb9d21e91135aab3cd3ca187af0cd0c3c3f868fdc" +dependencies = [ + "byteorder", + "thiserror-core", + "twox-hash", +] + +[[package]] +name = "ryu" +version = "1.0.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ad4cc8da4ef723ed60bced201181d83791ad433213d8c24efffda1eec85d741" + +[[package]] +name = "safe_arch" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f398075ce1e6a179b46f51bd88d0598b92b00d3551f1a2d4ac49e771b56ac354" +dependencies = [ + "bytemuck", +] + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "scopeguard" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" + +[[package]] +name = "serde" +version = "1.0.192" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bca2a08484b285dcb282d0f67b26cadc0df8b19f8c12502c13d966bf9482f001" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.192" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6c7207fbec9faa48073f3e3074cbe553af6ea512d7c21ba46e434e70ea9fbc1" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.39", +] + +[[package]] +name = "serde_json" +version = "1.0.108" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d1c7e3eac408d115102c4c24ad393e0821bb3a5df4d506a80f85f7a742a526b" +dependencies = [ + "itoa", + "ryu", + "serde", +] + +[[package]] +name = "sharded-slab" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6" +dependencies = [ + "lazy_static", +] + +[[package]] +name = "shlex" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7cee0529a6d40f580e7a5e6c495c8fbfe21b7b52795ed4bb5e62cdf92bc6380" + +[[package]] +name = "simba" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "061507c94fc6ab4ba1c9a0305018408e312e17c041eb63bef8aa726fa33aceae" +dependencies = [ + "approx", + "libm", + "num-complex", + "num-traits", + "paste", + "wide", +] + +[[package]] +name = "simd-adler32" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe" + +[[package]] +name = "slab" +version = "0.4.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67" +dependencies = [ + "autocfg", +] + +[[package]] +name = "slotmap" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1e08e261d0e8f5c43123b7adf3e4ca1690d655377ac93a03b2c9d3e98de1342" +dependencies = [ + "version_check", +] + +[[package]] +name = "smallvec" +version = "1.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4dccd0940a2dcdf68d092b8cbab7dc0ad8fa938bf95787e1b916b0e3d0e8e970" +dependencies = [ + "serde", +] + +[[package]] +name = "smol_str" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74212e6bbe9a4352329b2f68ba3130c15a3f26fe88ff22dbdc6cdd58fa85e99c" +dependencies = [ + "serde", +] + +[[package]] +name = "socket2" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b5fac59a5cb5dd637972e5fca70daf0523c9067fcdc4842f053dae04a18f8e9" +dependencies = [ + "libc", + "windows-sys 0.48.0", +] + +[[package]] +name = "spade" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c39e369d9638e42586b226e67df08a7358d1e02eb80629d596b944b7c16f44f" +dependencies = [ + "hashbrown 0.14.2", + "num-traits", + "robust", + "smallvec", +] + +[[package]] +name = "spirv" +version = "0.2.0+1.5.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "246bfa38fe3db3f1dfc8ca5a2cdeb7348c78be2112740cc0ec8ef18b6d94f830" +dependencies = [ + "bitflags 1.3.2", + "num-traits", +] + +[[package]] +name = "static_assertions" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" + +[[package]] +name = "str-buf" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e08d8363704e6c71fc928674353e6b7c23dcea9d82d7012c8faf2a3a025f8d0" + +[[package]] +name = "svg_fmt" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fb1df15f412ee2e9dfc1c504260fa695c1c3f10fe9f4a6ee2d2184d7d6450e2" + +[[package]] +name = "syn" +version = "1.0.109" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "2.0.39" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23e78b90f2fcf45d3e842032ce32e3f2d1545ba6636271dcbf24fa306d87be7a" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "sysinfo" +version = "0.29.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a18d114d420ada3a891e6bc8e96a2023402203296a47cdd65083377dad18ba5" +dependencies = [ + "cfg-if", + "core-foundation-sys", + "libc", + "ntapi", + "once_cell", + "winapi", +] + +[[package]] +name = "taffy" +version = "0.3.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c2287b6d7f721ada4cddf61ade5e760b2c6207df041cac9bfaa192897362fd3" +dependencies = [ + "arrayvec", + "grid", + "num-traits", + "slotmap", +] + +[[package]] +name = "termcolor" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6093bad37da69aab9d123a8091e4be0aa4a03e4d601ec641c327398315f62b64" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "thiserror" +version = "1.0.50" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9a7210f5c9a7156bb50aa36aed4c95afb51df0df00713949448cf9e97d382d2" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-core" +version = "1.0.38" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d97345f6437bb2004cd58819d8a9ef8e36cdd7661c2abc4bbde0a7c40d9f497" +dependencies = [ + "thiserror-core-impl", +] + +[[package]] +name = "thiserror-core-impl" +version = "1.0.38" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "10ac1c5050e43014d16b2f94d0d2ce79e65ffdd8b38d8048f9c8f6a8a6da62ac" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.50" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "266b2e40bc00e5a6c09c3584011e08b06f123c00362c92b975ba9843aaaa14b8" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.39", +] + +[[package]] +name = "thread_local" +version = "1.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3fdd6f064ccff2d6567adcb3873ca630700f00b5ad3f060c25b5dcfd9a4ce152" +dependencies = [ + "cfg-if", + "once_cell", +] + +[[package]] +name = "tiff" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d172b0f4d3fba17ba89811858b9d3d97f928aece846475bbda076ca46736211" +dependencies = [ + "flate2", + "jpeg-decoder", + "weezl", +] + +[[package]] +name = "tinyvec" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50" +dependencies = [ + "tinyvec_macros", +] + +[[package]] +name = "tinyvec_macros" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" + +[[package]] +name = "tokio" +version = "1.34.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0c014766411e834f7af5b8f4cf46257aab4036ca95e9d2c144a10f59ad6f5b9" +dependencies = [ + "backtrace", + "libc", + "mio", + "pin-project-lite", + "socket2", + "windows-sys 0.48.0", +] + +[[package]] +name = "toml_datetime" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1" + +[[package]] +name = "toml_edit" +version = "0.19.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421" +dependencies = [ + "indexmap 2.1.0", + "toml_datetime", + "winnow", +] + +[[package]] +name = "toml_edit" +version = "0.20.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70f427fce4d84c72b5b732388bf4a9f4531b53f74e2887e3ecb2481f68f66d81" +dependencies = [ + "indexmap 2.1.0", + "toml_datetime", + "winnow", +] + +[[package]] +name = "tracing" +version = "0.1.40" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef" +dependencies = [ + "pin-project-lite", + "tracing-attributes", + "tracing-core", +] + +[[package]] +name = "tracing-attributes" +version = "0.1.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.39", +] + +[[package]] +name = "tracing-core" +version = "0.1.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54" +dependencies = [ + "once_cell", + "valuable", +] + +[[package]] +name = "tracing-log" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f751112709b4e791d8ce53e32c4ed2d353565a795ce84da2285393f41557bdf2" +dependencies = [ + "log", + "once_cell", + "tracing-core", +] + +[[package]] +name = "tracing-subscriber" +version = "0.3.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "30a651bc37f915e81f087d86e62a18eec5f79550c7faff886f7090b4ea757c77" +dependencies = [ + "matchers", + "nu-ansi-term", + "once_cell", + "regex", + "sharded-slab", + "smallvec", + "thread_local", + "tracing", + "tracing-core", + "tracing-log", +] + +[[package]] +name = "tracing-wasm" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4575c663a174420fa2d78f4108ff68f65bf2fbb7dd89f33749b6e826b3626e07" +dependencies = [ + "tracing", + "tracing-subscriber", + "wasm-bindgen", +] + +[[package]] +name = "ttf-parser" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "17f77d76d837a7830fe1d4f12b7b4ba4192c1888001c7164257e4bc6d21d96b4" + +[[package]] +name = "twox-hash" +version = "1.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675" +dependencies = [ + "cfg-if", + "static_assertions", +] + +[[package]] +name = "typenum" +version = "1.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825" + +[[package]] +name = "unicode-bidi" +version = "0.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92888ba5573ff080736b3648696b70cafad7d250551175acbaa4e0385b3e1460" + +[[package]] +name = "unicode-ident" +version = "1.0.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" + +[[package]] +name = "unicode-normalization" +version = "0.1.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921" +dependencies = [ + "tinyvec", +] + +[[package]] +name = "unicode-width" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e51733f11c9c4f72aa0c160008246859e340b00807569a0da0e7a1079b27ba85" + +[[package]] +name = "unicode-xid" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c" + +[[package]] +name = "url" +version = "2.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "143b538f18257fac9cad154828a57c6bf5157e1aa604d4816b5995bf6de87ae5" +dependencies = [ + "form_urlencoded", + "idna", + "percent-encoding", +] + +[[package]] +name = "uuid" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "88ad59a7560b41a70d191093a945f0b87bc1deeda46fb237479708a1d6b6cdfc" +dependencies = [ + "getrandom", + "serde", +] + +[[package]] +name = "valuable" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d" + +[[package]] +name = "vec_map" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191" + +[[package]] +name = "version_check" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" + +[[package]] +name = "waker-fn" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f3c4517f54858c779bbcbf228f4fca63d121bf85fbecb2dc578cdf4a39395690" + +[[package]] +name = "walkdir" +version = "2.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d71d857dc86794ca4c280d616f7da00d2dbfd8cd788846559a6813e6aa4b54ee" +dependencies = [ + "same-file", + "winapi-util", +] + +[[package]] +name = "wasi" +version = "0.11.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" + +[[package]] +name = "wasm-bindgen" +version = "0.2.88" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7daec296f25a1bae309c0cd5c29c4b260e510e6d813c286b19eaadf409d40fce" +dependencies = [ + "cfg-if", + "wasm-bindgen-macro", +] + +[[package]] +name = "wasm-bindgen-backend" +version = "0.2.88" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e397f4664c0e4e428e8313a469aaa58310d302159845980fd23b0f22a847f217" +dependencies = [ + "bumpalo", + "log", + "once_cell", + "proc-macro2", + "quote", + "syn 2.0.39", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.38" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9afec9963e3d0994cac82455b2b3502b81a7f40f9a0d32181f7528d9f4b43e02" +dependencies = [ + "cfg-if", + "js-sys", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.88" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5961017b3b08ad5f3fe39f1e79877f8ee7c23c5e5fd5eb80de95abc41f1f16b2" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.88" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c5353b8dab669f5e10f5bd76df26a9360c748f054f862ff5f3f8aae0c7fb3907" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.39", + "wasm-bindgen-backend", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.88" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d046c5d029ba91a1ed14da14dca44b68bf2f124cfbaf741c54151fdb3e0750b" + +[[package]] +name = "wayland-scanner" +version = "0.29.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f4303d8fa22ab852f789e75a967f0a2cdc430a607751c0499bada3e451cbd53" +dependencies = [ + "proc-macro2", + "quote", + "xml-rs", +] + +[[package]] +name = "web-sys" +version = "0.3.65" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5db499c5f66323272151db0e666cd34f78617522fb0c1604d31a27c50c206a85" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "webbrowser" +version = "0.8.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82b2391658b02c27719fc5a0a73d6e696285138e8b12fba9d4baa70451023c71" +dependencies = [ + "core-foundation", + "home", + "jni 0.21.1", + "log", + "ndk-context", + "objc", + "raw-window-handle", + "url", + "web-sys", +] + +[[package]] +name = "weezl" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9193164d4de03a926d909d3bc7c30543cecb35400c02114792c2cae20d5e2dbb" + +[[package]] +name = "wgpu" +version = "0.17.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed547920565c56c7a29afb4538ac5ae5048865a5d2f05bff3ad4fbeb921a9a2c" +dependencies = [ + "arrayvec", + "cfg-if", + "js-sys", + "log", + "naga", + "parking_lot", + "profiling", + "raw-window-handle", + "smallvec", + "static_assertions", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "wgpu-core", + "wgpu-hal", + "wgpu-types", +] + +[[package]] +name = "wgpu-core" +version = "0.17.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f8a44dd301a30ceeed3c27d8c0090433d3da04d7b2a4042738095a424d12ae7" +dependencies = [ + "arrayvec", + "bit-vec", + "bitflags 2.4.1", + "codespan-reporting", + "log", + "naga", + "parking_lot", + "profiling", + "raw-window-handle", + "rustc-hash", + "smallvec", + "thiserror", + "web-sys", + "wgpu-hal", + "wgpu-types", +] + +[[package]] +name = "wgpu-hal" +version = "0.17.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a80bf0e3c77399bb52850cb0830af9bad073d5cfcb9dd8253bef8125c42db17" +dependencies = [ + "android_system_properties", + "arrayvec", + "ash", + "bit-set", + "bitflags 2.4.1", + "block", + "core-graphics-types", + "d3d12", + "glow", + "gpu-alloc", + "gpu-allocator", + "gpu-descriptor", + "hassle-rs", + "js-sys", + "khronos-egl", + "libc", + "libloading 0.8.1", + "log", + "metal", + "naga", + "objc", + "parking_lot", + "profiling", + "range-alloc", + "raw-window-handle", + "renderdoc-sys", + "rustc-hash", + "smallvec", + "thiserror", + "wasm-bindgen", + "web-sys", + "wgpu-types", + "winapi", +] + +[[package]] +name = "wgpu-types" +version = "0.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee64d7398d0c2f9ca48922c902ef69c42d000c759f3db41e355f4a570b052b67" +dependencies = [ + "bitflags 2.4.1", + "js-sys", + "web-sys", +] + +[[package]] +name = "wide" +version = "0.7.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c68938b57b33da363195412cfc5fc37c9ed49aa9cfe2156fde64b8d2c9498242" +dependencies = [ + "bytemuck", + "safe_arch", +] + +[[package]] +name = "widestring" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "653f141f39ec16bba3c5abe400a0c60da7468261cc2cbf36805022876bc721a8" + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f29e6f9198ba0d26b4c9f07dbe6f9ed633e1f3d5b8b414090084349e46a52596" +dependencies = [ + "winapi", +] + +[[package]] +name = "winapi-wsapoll" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44c17110f57155602a80dca10be03852116403c9ff3cd25b079d666f2aa3df6e" +dependencies = [ + "winapi", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows" +version = "0.44.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e745dab35a0c4c77aa3ce42d595e13d2003d6902d6b08c9ef5fc326d08da12b" +dependencies = [ + "windows-targets 0.42.2", +] + +[[package]] +name = "windows" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdacb41e6a96a052c6cb63a144f24900236121c6f63f4f8219fef5977ecb0c25" +dependencies = [ + "windows-targets 0.42.2", +] + +[[package]] +name = "windows" +version = "0.48.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e686886bc078bc1b0b600cac0147aadb815089b6e4da64016cbd754b6342700f" +dependencies = [ + "windows-implement", + "windows-interface", + "windows-targets 0.48.5", +] + +[[package]] +name = "windows" +version = "0.51.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca229916c5ee38c2f2bc1e9d8f04df975b4bd93f9955dc69fabb5d91270045c9" +dependencies = [ + "windows-core", + "windows-targets 0.48.5", +] + +[[package]] +name = "windows-core" +version = "0.51.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1f8cf84f35d2db49a46868f947758c7a1138116f7fac3bc844f43ade1292e64" +dependencies = [ + "windows-targets 0.48.5", +] + +[[package]] +name = "windows-implement" +version = "0.48.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e2ee588991b9e7e6c8338edf3333fbe4da35dc72092643958ebb43f0ab2c49c" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "windows-interface" +version = "0.48.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6fb8df20c9bcaa8ad6ab513f7b40104840c8867d5751126e4df3b08388d0cc7" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "windows-sys" +version = "0.45.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0" +dependencies = [ + "windows-targets 0.42.2", +] + +[[package]] +name = "windows-sys" +version = "0.48.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9" +dependencies = [ + "windows-targets 0.48.5", +] + +[[package]] +name = "windows-targets" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071" +dependencies = [ + "windows_aarch64_gnullvm 0.42.2", + "windows_aarch64_msvc 0.42.2", + "windows_i686_gnu 0.42.2", + "windows_i686_msvc 0.42.2", + "windows_x86_64_gnu 0.42.2", + "windows_x86_64_gnullvm 0.42.2", + "windows_x86_64_msvc 0.42.2", +] + +[[package]] +name = "windows-targets" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c" +dependencies = [ + "windows_aarch64_gnullvm 0.48.5", + "windows_aarch64_msvc 0.48.5", + "windows_i686_gnu 0.48.5", + "windows_i686_msvc 0.48.5", + "windows_x86_64_gnu 0.48.5", + "windows_x86_64_gnullvm 0.48.5", + "windows_x86_64_msvc 0.48.5", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8" + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" + +[[package]] +name = "windows_i686_gnu" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f" + +[[package]] +name = "windows_i686_gnu" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" + +[[package]] +name = "windows_i686_msvc" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060" + +[[package]] +name = "windows_i686_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" + +[[package]] +name = "winit" +version = "0.28.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9596d90b45384f5281384ab204224876e8e8bf7d58366d9b795ad99aa9894b94" +dependencies = [ + "android-activity", + "bitflags 1.3.2", + "cfg_aliases", + "core-foundation", + "core-graphics", + "dispatch", + "instant", + "libc", + "log", + "mio", + "ndk", + "objc2", + "once_cell", + "orbclient", + "percent-encoding", + "raw-window-handle", + "redox_syscall 0.3.5", + "wasm-bindgen", + "wayland-scanner", + "web-sys", + "windows-sys 0.45.0", + "x11-dl", +] + +[[package]] +name = "winnow" +version = "0.5.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "829846f3e3db426d4cee4510841b71a8e58aa2a76b1132579487ae430ccd9c7b" +dependencies = [ + "memchr", +] + +[[package]] +name = "x11-dl" +version = "2.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38735924fedd5314a6e548792904ed8c6de6636285cb9fec04d5b1db85c1516f" +dependencies = [ + "libc", + "once_cell", + "pkg-config", +] + +[[package]] +name = "x11rb" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "592b4883219f345e712b3209c62654ebda0bb50887f330cbd018d0f654bfd507" +dependencies = [ + "gethostname", + "nix 0.24.3", + "winapi", + "winapi-wsapoll", + "x11rb-protocol", +] + +[[package]] +name = "x11rb-protocol" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56b245751c0ac9db0e006dc812031482784e434630205a93c73cfefcaabeac67" +dependencies = [ + "nix 0.24.3", +] + +[[package]] +name = "xi-unicode" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a67300977d3dc3f8034dae89778f502b6ba20b269527b3223ba59c0cf393bb8a" + +[[package]] +name = "xml-rs" +version = "0.8.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fcb9cbac069e033553e8bb871be2fbdffcab578eb25bd0f7c508cedc6dcd75a" + +[[package]] +name = "zerocopy" +version = "0.7.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8cd369a67c0edfef15010f980c3cbe45d7f651deac2cd67ce097cd801de16557" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.7.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2f140bda219a26ccc0cdb03dba58af72590c53b22642577d88a927bc5c87d6b" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.39", +] diff --git a/examples/bevy_registry_export/basic/Cargo.toml b/examples/bevy_registry_export/basic/Cargo.toml new file mode 100644 index 0000000..9bdecc5 --- /dev/null +++ b/examples/bevy_registry_export/basic/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "bevy_bevy_registry_export_basic_example" +version = "0.3.0" +edition = "2021" +license = "MIT OR Apache-2.0" + +[dependencies] +bevy="0.12" +bevy_gltf_blueprints = { path = "../../../crates/bevy_gltf_blueprints" } +bevy_registry_export = { path = "../../../crates/bevy_registry_export" } +bevy_rapier3d = { version = "0.23.0", features = [ "serde-serialize", "debug-render-3d", "enhanced-determinism"] } +bevy_asset_loader = { version = "0.18", features = ["standard_dynamic_assets" ]} +bevy_editor_pls = { version = "0.6" } +rand = "0.8.5" diff --git a/examples/bevy_registry_export/basic/README.md b/examples/bevy_registry_export/basic/README.md new file mode 100644 index 0000000..5d2e087 --- /dev/null +++ b/examples/bevy_registry_export/basic/README.md @@ -0,0 +1,15 @@ +# Bevy registry export example/demo + +This example showcases +* the use of the bevy_registry_export crate to extract all components & types information into a json file. +* That file is then used by the [Blender addon](https://github.com/kaosat-dev/Blender_bevy_components_workflow/tree/main/tools/bevy_components) to create Uis for each component, +to be able to add & edit Bevy components easilly in Blender ! + + +## Running this example + +``` +cargo run --features bevy/dynamic_linking +``` + +Running the example also regenerates the registry.json file. diff --git a/examples/bevy_registry_export/basic/assets/assets_core.assets.ron b/examples/bevy_registry_export/basic/assets/assets_core.assets.ron new file mode 100644 index 0000000..8d0a099 --- /dev/null +++ b/examples/bevy_registry_export/basic/assets/assets_core.assets.ron @@ -0,0 +1 @@ +({}) \ No newline at end of file diff --git a/examples/bevy_registry_export/basic/assets/assets_game.assets.ron b/examples/bevy_registry_export/basic/assets/assets_game.assets.ron new file mode 100644 index 0000000..5b1e969 --- /dev/null +++ b/examples/bevy_registry_export/basic/assets/assets_game.assets.ron @@ -0,0 +1,6 @@ +({ + "world":File (path: "models/World.glb"), + "models": Folder ( + path: "models/library", + ), +}) \ No newline at end of file diff --git a/examples/bevy_registry_export/basic/assets/basic.blend b/examples/bevy_registry_export/basic/assets/basic.blend new file mode 100644 index 0000000..bcfe0ff Binary files /dev/null and b/examples/bevy_registry_export/basic/assets/basic.blend differ diff --git a/examples/bevy_registry_export/basic/assets/models/World.glb b/examples/bevy_registry_export/basic/assets/models/World.glb new file mode 100644 index 0000000..7ed6e73 Binary files /dev/null and b/examples/bevy_registry_export/basic/assets/models/World.glb differ diff --git a/examples/bevy_registry_export/basic/assets/models/library/Container.glb b/examples/bevy_registry_export/basic/assets/models/library/Container.glb new file mode 100644 index 0000000..5818d2c Binary files /dev/null and b/examples/bevy_registry_export/basic/assets/models/library/Container.glb differ diff --git a/examples/bevy_registry_export/basic/assets/models/library/Health_Pickup.glb b/examples/bevy_registry_export/basic/assets/models/library/Health_Pickup.glb new file mode 100644 index 0000000..f5d97cb Binary files /dev/null and b/examples/bevy_registry_export/basic/assets/models/library/Health_Pickup.glb differ diff --git a/examples/bevy_registry_export/basic/assets/models/library/MagicTeapot.glb b/examples/bevy_registry_export/basic/assets/models/library/MagicTeapot.glb new file mode 100644 index 0000000..47c37cd Binary files /dev/null and b/examples/bevy_registry_export/basic/assets/models/library/MagicTeapot.glb differ diff --git a/examples/bevy_registry_export/basic/assets/models/library/Pillar.glb b/examples/bevy_registry_export/basic/assets/models/library/Pillar.glb new file mode 100644 index 0000000..9a6f3e0 Binary files /dev/null and b/examples/bevy_registry_export/basic/assets/models/library/Pillar.glb differ diff --git a/examples/bevy_registry_export/basic/assets/models/library/Player.glb b/examples/bevy_registry_export/basic/assets/models/library/Player.glb new file mode 100644 index 0000000..2d749b2 Binary files /dev/null and b/examples/bevy_registry_export/basic/assets/models/library/Player.glb differ diff --git a/examples/bevy_registry_export/basic/assets/models/library/Unused_in_level_test.glb b/examples/bevy_registry_export/basic/assets/models/library/Unused_in_level_test.glb new file mode 100644 index 0000000..c80b966 Binary files /dev/null and b/examples/bevy_registry_export/basic/assets/models/library/Unused_in_level_test.glb differ diff --git a/examples/bevy_registry_export/basic/assets/registry.json b/examples/bevy_registry_export/basic/assets/registry.json new file mode 100644 index 0000000..5eeefca --- /dev/null +++ b/examples/bevy_registry_export/basic/assets/registry.json @@ -0,0 +1,10548 @@ +{ + "$defs": { + "(f32, f32)": { + "isComponent": false, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + }, + { + "type": { + "$ref": "#/$defs/f32" + } + } + ], + "short_name": "(f32, f32)", + "title": "(f32, f32)", + "type": "array", + "typeInfo": "Tuple" + }, + "alloc::borrow::Cow": { + "isComponent": false, + "isResource": false, + "short_name": "Cow", + "title": "alloc::borrow::Cow", + "type": "object", + "typeInfo": "Value" + }, + "alloc::borrow::Cow": { + "isComponent": false, + "isResource": false, + "short_name": "Cow", + "title": "alloc::borrow::Cow", + "type": "object", + "typeInfo": "Value" + }, + "alloc::string::String": { + "isComponent": false, + "isResource": false, + "short_name": "String", + "title": "alloc::string::String", + "type": "string", + "typeInfo": "Value" + }, + "alloc::vec::Vec<(f32, f32)>": { + "isComponent": false, + "isResource": false, + "items": { + "type": { + "$ref": "#/$defs/(f32, f32)" + } + }, + "short_name": "Vec<(f32, f32)>", + "title": "alloc::vec::Vec<(f32, f32)>", + "type": "array", + "typeInfo": "List" + }, + "alloc::vec::Vec": { + "isComponent": false, + "isResource": false, + "items": { + "type": { + "$ref": "#/$defs/alloc::string::String" + } + }, + "short_name": "Vec", + "title": "alloc::vec::Vec", + "type": "array", + "typeInfo": "List" + }, + "alloc::vec::Vec": { + "isComponent": false, + "isResource": false, + "items": { + "type": { + "$ref": "#/$defs/bevy_bevy_registry_export_basic_example::test_components::TuppleVec3" + } + }, + "short_name": "Vec", + "title": "alloc::vec::Vec", + "type": "array", + "typeInfo": "List" + }, + "alloc::vec::Vec": { + "isComponent": false, + "isResource": false, + "items": { + "type": { + "$ref": "#/$defs/bevy_ecs::Entity" + } + }, + "short_name": "Vec", + "title": "alloc::vec::Vec", + "type": "array", + "typeInfo": "List" + }, + "alloc::vec::Vec": { + "isComponent": false, + "isResource": false, + "items": { + "type": { + "$ref": "#/$defs/bevy_render::color::Color" + } + }, + "short_name": "Vec", + "title": "alloc::vec::Vec", + "type": "array", + "typeInfo": "List" + }, + "alloc::vec::Vec": { + "isComponent": false, + "isResource": false, + "items": { + "type": { + "$ref": "#/$defs/bevy_text::text::TextSection" + } + }, + "short_name": "Vec", + "title": "alloc::vec::Vec", + "type": "array", + "typeInfo": "List" + }, + "bevy_animation::AnimationClip": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "curves": { + "type": { + "$ref": "#/$defs/alloc::vec::Vec>" + } + }, + "duration": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "paths": { + "type": { + "$ref": "#/$defs/bevy_utils::hashbrown::HashMap" + } + } + }, + "required": [ + "curves", + "paths", + "duration" + ], + "short_name": "AnimationClip", + "title": "bevy_animation::AnimationClip", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_animation::AnimationPlayer": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "animation": { + "type": { + "$ref": "#/$defs/bevy_animation::PlayingAnimation" + } + }, + "paused": { + "type": { + "$ref": "#/$defs/bool" + } + } + }, + "required": [ + "paused", + "animation" + ], + "short_name": "AnimationPlayer", + "title": "bevy_animation::AnimationPlayer", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_asset::handle::Handle<()>": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/std::sync::Arc" + } + } + ], + "short_name": "Strong", + "title": "Strong", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::id::AssetId<()>" + } + } + ], + "short_name": "Weak", + "title": "Weak", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Handle<()>", + "title": "bevy_asset::handle::Handle<()>", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::handle::Handle": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/std::sync::Arc" + } + } + ], + "short_name": "Strong", + "title": "Strong", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::id::AssetId" + } + } + ], + "short_name": "Weak", + "title": "Weak", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Handle", + "title": "bevy_asset::handle::Handle", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::handle::Handle": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/std::sync::Arc" + } + } + ], + "short_name": "Strong", + "title": "Strong", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::id::AssetId" + } + } + ], + "short_name": "Weak", + "title": "Weak", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Handle", + "title": "bevy_asset::handle::Handle", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::handle::Handle": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/std::sync::Arc" + } + } + ], + "short_name": "Strong", + "title": "Strong", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::id::AssetId" + } + } + ], + "short_name": "Weak", + "title": "Weak", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Handle", + "title": "bevy_asset::handle::Handle", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::handle::Handle": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/std::sync::Arc" + } + } + ], + "short_name": "Strong", + "title": "Strong", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::id::AssetId" + } + } + ], + "short_name": "Weak", + "title": "Weak", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Handle", + "title": "bevy_asset::handle::Handle", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::handle::Handle": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/std::sync::Arc" + } + } + ], + "short_name": "Strong", + "title": "Strong", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::id::AssetId" + } + } + ], + "short_name": "Weak", + "title": "Weak", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Handle", + "title": "bevy_asset::handle::Handle", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::handle::Handle": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/std::sync::Arc" + } + } + ], + "short_name": "Strong", + "title": "Strong", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::id::AssetId" + } + } + ], + "short_name": "Weak", + "title": "Weak", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Handle", + "title": "bevy_asset::handle::Handle", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::handle::Handle": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/std::sync::Arc" + } + } + ], + "short_name": "Strong", + "title": "Strong", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::id::AssetId" + } + } + ], + "short_name": "Weak", + "title": "Weak", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Handle", + "title": "bevy_asset::handle::Handle", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::handle::Handle": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/std::sync::Arc" + } + } + ], + "short_name": "Strong", + "title": "Strong", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::id::AssetId" + } + } + ], + "short_name": "Weak", + "title": "Weak", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Handle", + "title": "bevy_asset::handle::Handle", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::handle::Handle": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/std::sync::Arc" + } + } + ], + "short_name": "Strong", + "title": "Strong", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::id::AssetId" + } + } + ], + "short_name": "Weak", + "title": "Weak", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Handle", + "title": "bevy_asset::handle::Handle", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::handle::Handle": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/std::sync::Arc" + } + } + ], + "short_name": "Strong", + "title": "Strong", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::id::AssetId" + } + } + ], + "short_name": "Weak", + "title": "Weak", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Handle", + "title": "bevy_asset::handle::Handle", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::handle::Handle": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/std::sync::Arc" + } + } + ], + "short_name": "Strong", + "title": "Strong", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::id::AssetId" + } + } + ], + "short_name": "Weak", + "title": "Weak", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Handle", + "title": "bevy_asset::handle::Handle", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::handle::Handle": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/std::sync::Arc" + } + } + ], + "short_name": "Strong", + "title": "Strong", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::id::AssetId" + } + } + ], + "short_name": "Weak", + "title": "Weak", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Handle", + "title": "bevy_asset::handle::Handle", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::handle::Handle": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/std::sync::Arc" + } + } + ], + "short_name": "Strong", + "title": "Strong", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::id::AssetId" + } + } + ], + "short_name": "Weak", + "title": "Weak", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Handle", + "title": "bevy_asset::handle::Handle", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::handle::Handle": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/std::sync::Arc" + } + } + ], + "short_name": "Strong", + "title": "Strong", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::id::AssetId" + } + } + ], + "short_name": "Weak", + "title": "Weak", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Handle", + "title": "bevy_asset::handle::Handle", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::handle::Handle": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/std::sync::Arc" + } + } + ], + "short_name": "Strong", + "title": "Strong", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::id::AssetId" + } + } + ], + "short_name": "Weak", + "title": "Weak", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Handle", + "title": "bevy_asset::handle::Handle", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::handle::Handle": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/std::sync::Arc" + } + } + ], + "short_name": "Strong", + "title": "Strong", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::id::AssetId" + } + } + ], + "short_name": "Weak", + "title": "Weak", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Handle", + "title": "bevy_asset::handle::Handle", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::handle::Handle": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/std::sync::Arc" + } + } + ], + "short_name": "Strong", + "title": "Strong", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::id::AssetId" + } + } + ], + "short_name": "Weak", + "title": "Weak", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Handle", + "title": "bevy_asset::handle::Handle", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::handle::Handle": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/std::sync::Arc" + } + } + ], + "short_name": "Strong", + "title": "Strong", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::id::AssetId" + } + } + ], + "short_name": "Weak", + "title": "Weak", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Handle", + "title": "bevy_asset::handle::Handle", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::handle::Handle": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/std::sync::Arc" + } + } + ], + "short_name": "Strong", + "title": "Strong", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::id::AssetId" + } + } + ], + "short_name": "Weak", + "title": "Weak", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Handle", + "title": "bevy_asset::handle::Handle", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::handle::Handle": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/std::sync::Arc" + } + } + ], + "short_name": "Strong", + "title": "Strong", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::id::AssetId" + } + } + ], + "short_name": "Weak", + "title": "Weak", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Handle", + "title": "bevy_asset::handle::Handle", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::handle::Handle": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/std::sync::Arc" + } + } + ], + "short_name": "Strong", + "title": "Strong", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::id::AssetId" + } + } + ], + "short_name": "Weak", + "title": "Weak", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Handle", + "title": "bevy_asset::handle::Handle", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::handle::Handle": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/std::sync::Arc" + } + } + ], + "short_name": "Strong", + "title": "Strong", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::id::AssetId" + } + } + ], + "short_name": "Weak", + "title": "Weak", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Handle", + "title": "bevy_asset::handle::Handle", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::id::AssetId<()>": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "index": { + "title": "index", + "type": { + "$ref": "#/$defs/bevy_asset::assets::AssetIndex" + } + } + }, + "required": [ + "index" + ], + "short_name": "Index", + "title": "Index", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "uuid": { + "title": "uuid", + "type": { + "$ref": "#/$defs/bevy_utils::Uuid" + } + } + }, + "required": [ + "uuid" + ], + "short_name": "Uuid", + "title": "Uuid", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "AssetId<()>", + "title": "bevy_asset::id::AssetId<()>", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::id::AssetId": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "index": { + "title": "index", + "type": { + "$ref": "#/$defs/bevy_asset::assets::AssetIndex" + } + } + }, + "required": [ + "index" + ], + "short_name": "Index", + "title": "Index", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "uuid": { + "title": "uuid", + "type": { + "$ref": "#/$defs/bevy_utils::Uuid" + } + } + }, + "required": [ + "uuid" + ], + "short_name": "Uuid", + "title": "Uuid", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "AssetId", + "title": "bevy_asset::id::AssetId", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::id::AssetId": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "index": { + "title": "index", + "type": { + "$ref": "#/$defs/bevy_asset::assets::AssetIndex" + } + } + }, + "required": [ + "index" + ], + "short_name": "Index", + "title": "Index", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "uuid": { + "title": "uuid", + "type": { + "$ref": "#/$defs/bevy_utils::Uuid" + } + } + }, + "required": [ + "uuid" + ], + "short_name": "Uuid", + "title": "Uuid", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "AssetId", + "title": "bevy_asset::id::AssetId", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::id::AssetId": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "index": { + "title": "index", + "type": { + "$ref": "#/$defs/bevy_asset::assets::AssetIndex" + } + } + }, + "required": [ + "index" + ], + "short_name": "Index", + "title": "Index", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "uuid": { + "title": "uuid", + "type": { + "$ref": "#/$defs/bevy_utils::Uuid" + } + } + }, + "required": [ + "uuid" + ], + "short_name": "Uuid", + "title": "Uuid", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "AssetId", + "title": "bevy_asset::id::AssetId", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::id::AssetId": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "index": { + "title": "index", + "type": { + "$ref": "#/$defs/bevy_asset::assets::AssetIndex" + } + } + }, + "required": [ + "index" + ], + "short_name": "Index", + "title": "Index", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "uuid": { + "title": "uuid", + "type": { + "$ref": "#/$defs/bevy_utils::Uuid" + } + } + }, + "required": [ + "uuid" + ], + "short_name": "Uuid", + "title": "Uuid", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "AssetId", + "title": "bevy_asset::id::AssetId", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::id::AssetId": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "index": { + "title": "index", + "type": { + "$ref": "#/$defs/bevy_asset::assets::AssetIndex" + } + } + }, + "required": [ + "index" + ], + "short_name": "Index", + "title": "Index", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "uuid": { + "title": "uuid", + "type": { + "$ref": "#/$defs/bevy_utils::Uuid" + } + } + }, + "required": [ + "uuid" + ], + "short_name": "Uuid", + "title": "Uuid", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "AssetId", + "title": "bevy_asset::id::AssetId", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::id::AssetId": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "index": { + "title": "index", + "type": { + "$ref": "#/$defs/bevy_asset::assets::AssetIndex" + } + } + }, + "required": [ + "index" + ], + "short_name": "Index", + "title": "Index", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "uuid": { + "title": "uuid", + "type": { + "$ref": "#/$defs/bevy_utils::Uuid" + } + } + }, + "required": [ + "uuid" + ], + "short_name": "Uuid", + "title": "Uuid", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "AssetId", + "title": "bevy_asset::id::AssetId", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::id::AssetId": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "index": { + "title": "index", + "type": { + "$ref": "#/$defs/bevy_asset::assets::AssetIndex" + } + } + }, + "required": [ + "index" + ], + "short_name": "Index", + "title": "Index", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "uuid": { + "title": "uuid", + "type": { + "$ref": "#/$defs/bevy_utils::Uuid" + } + } + }, + "required": [ + "uuid" + ], + "short_name": "Uuid", + "title": "Uuid", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "AssetId", + "title": "bevy_asset::id::AssetId", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::id::AssetId": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "index": { + "title": "index", + "type": { + "$ref": "#/$defs/bevy_asset::assets::AssetIndex" + } + } + }, + "required": [ + "index" + ], + "short_name": "Index", + "title": "Index", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "uuid": { + "title": "uuid", + "type": { + "$ref": "#/$defs/bevy_utils::Uuid" + } + } + }, + "required": [ + "uuid" + ], + "short_name": "Uuid", + "title": "Uuid", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "AssetId", + "title": "bevy_asset::id::AssetId", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::id::AssetId": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "index": { + "title": "index", + "type": { + "$ref": "#/$defs/bevy_asset::assets::AssetIndex" + } + } + }, + "required": [ + "index" + ], + "short_name": "Index", + "title": "Index", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "uuid": { + "title": "uuid", + "type": { + "$ref": "#/$defs/bevy_utils::Uuid" + } + } + }, + "required": [ + "uuid" + ], + "short_name": "Uuid", + "title": "Uuid", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "AssetId", + "title": "bevy_asset::id::AssetId", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::id::AssetId": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "index": { + "title": "index", + "type": { + "$ref": "#/$defs/bevy_asset::assets::AssetIndex" + } + } + }, + "required": [ + "index" + ], + "short_name": "Index", + "title": "Index", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "uuid": { + "title": "uuid", + "type": { + "$ref": "#/$defs/bevy_utils::Uuid" + } + } + }, + "required": [ + "uuid" + ], + "short_name": "Uuid", + "title": "Uuid", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "AssetId", + "title": "bevy_asset::id::AssetId", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::id::AssetId": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "index": { + "title": "index", + "type": { + "$ref": "#/$defs/bevy_asset::assets::AssetIndex" + } + } + }, + "required": [ + "index" + ], + "short_name": "Index", + "title": "Index", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "uuid": { + "title": "uuid", + "type": { + "$ref": "#/$defs/bevy_utils::Uuid" + } + } + }, + "required": [ + "uuid" + ], + "short_name": "Uuid", + "title": "Uuid", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "AssetId", + "title": "bevy_asset::id::AssetId", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::id::AssetId": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "index": { + "title": "index", + "type": { + "$ref": "#/$defs/bevy_asset::assets::AssetIndex" + } + } + }, + "required": [ + "index" + ], + "short_name": "Index", + "title": "Index", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "uuid": { + "title": "uuid", + "type": { + "$ref": "#/$defs/bevy_utils::Uuid" + } + } + }, + "required": [ + "uuid" + ], + "short_name": "Uuid", + "title": "Uuid", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "AssetId", + "title": "bevy_asset::id::AssetId", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::id::AssetId": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "index": { + "title": "index", + "type": { + "$ref": "#/$defs/bevy_asset::assets::AssetIndex" + } + } + }, + "required": [ + "index" + ], + "short_name": "Index", + "title": "Index", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "uuid": { + "title": "uuid", + "type": { + "$ref": "#/$defs/bevy_utils::Uuid" + } + } + }, + "required": [ + "uuid" + ], + "short_name": "Uuid", + "title": "Uuid", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "AssetId", + "title": "bevy_asset::id::AssetId", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::id::AssetId": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "index": { + "title": "index", + "type": { + "$ref": "#/$defs/bevy_asset::assets::AssetIndex" + } + } + }, + "required": [ + "index" + ], + "short_name": "Index", + "title": "Index", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "uuid": { + "title": "uuid", + "type": { + "$ref": "#/$defs/bevy_utils::Uuid" + } + } + }, + "required": [ + "uuid" + ], + "short_name": "Uuid", + "title": "Uuid", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "AssetId", + "title": "bevy_asset::id::AssetId", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::id::AssetId": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "index": { + "title": "index", + "type": { + "$ref": "#/$defs/bevy_asset::assets::AssetIndex" + } + } + }, + "required": [ + "index" + ], + "short_name": "Index", + "title": "Index", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "uuid": { + "title": "uuid", + "type": { + "$ref": "#/$defs/bevy_utils::Uuid" + } + } + }, + "required": [ + "uuid" + ], + "short_name": "Uuid", + "title": "Uuid", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "AssetId", + "title": "bevy_asset::id::AssetId", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::id::AssetId": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "index": { + "title": "index", + "type": { + "$ref": "#/$defs/bevy_asset::assets::AssetIndex" + } + } + }, + "required": [ + "index" + ], + "short_name": "Index", + "title": "Index", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "uuid": { + "title": "uuid", + "type": { + "$ref": "#/$defs/bevy_utils::Uuid" + } + } + }, + "required": [ + "uuid" + ], + "short_name": "Uuid", + "title": "Uuid", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "AssetId", + "title": "bevy_asset::id::AssetId", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::id::AssetId": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "index": { + "title": "index", + "type": { + "$ref": "#/$defs/bevy_asset::assets::AssetIndex" + } + } + }, + "required": [ + "index" + ], + "short_name": "Index", + "title": "Index", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "uuid": { + "title": "uuid", + "type": { + "$ref": "#/$defs/bevy_utils::Uuid" + } + } + }, + "required": [ + "uuid" + ], + "short_name": "Uuid", + "title": "Uuid", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "AssetId", + "title": "bevy_asset::id::AssetId", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::id::AssetId": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "index": { + "title": "index", + "type": { + "$ref": "#/$defs/bevy_asset::assets::AssetIndex" + } + } + }, + "required": [ + "index" + ], + "short_name": "Index", + "title": "Index", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "uuid": { + "title": "uuid", + "type": { + "$ref": "#/$defs/bevy_utils::Uuid" + } + } + }, + "required": [ + "uuid" + ], + "short_name": "Uuid", + "title": "Uuid", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "AssetId", + "title": "bevy_asset::id::AssetId", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::id::AssetId": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "index": { + "title": "index", + "type": { + "$ref": "#/$defs/bevy_asset::assets::AssetIndex" + } + } + }, + "required": [ + "index" + ], + "short_name": "Index", + "title": "Index", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "uuid": { + "title": "uuid", + "type": { + "$ref": "#/$defs/bevy_utils::Uuid" + } + } + }, + "required": [ + "uuid" + ], + "short_name": "Uuid", + "title": "Uuid", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "AssetId", + "title": "bevy_asset::id::AssetId", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::id::AssetId": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "index": { + "title": "index", + "type": { + "$ref": "#/$defs/bevy_asset::assets::AssetIndex" + } + } + }, + "required": [ + "index" + ], + "short_name": "Index", + "title": "Index", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "uuid": { + "title": "uuid", + "type": { + "$ref": "#/$defs/bevy_utils::Uuid" + } + } + }, + "required": [ + "uuid" + ], + "short_name": "Uuid", + "title": "Uuid", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "AssetId", + "title": "bevy_asset::id::AssetId", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::id::AssetId": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "index": { + "title": "index", + "type": { + "$ref": "#/$defs/bevy_asset::assets::AssetIndex" + } + } + }, + "required": [ + "index" + ], + "short_name": "Index", + "title": "Index", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "uuid": { + "title": "uuid", + "type": { + "$ref": "#/$defs/bevy_utils::Uuid" + } + } + }, + "required": [ + "uuid" + ], + "short_name": "Uuid", + "title": "Uuid", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "AssetId", + "title": "bevy_asset::id::AssetId", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_asset::id::AssetId": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "index": { + "title": "index", + "type": { + "$ref": "#/$defs/bevy_asset::assets::AssetIndex" + } + } + }, + "required": [ + "index" + ], + "short_name": "Index", + "title": "Index", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "uuid": { + "title": "uuid", + "type": { + "$ref": "#/$defs/bevy_utils::Uuid" + } + } + }, + "required": [ + "uuid" + ], + "short_name": "Uuid", + "title": "Uuid", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "AssetId", + "title": "bevy_asset::id::AssetId", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_bevy_registry_export_basic_example::core::camera::camera_tracking::CameraTrackable": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "CameraTrackable", + "title": "bevy_bevy_registry_export_basic_example::core::camera::camera_tracking::CameraTrackable", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_bevy_registry_export_basic_example::core::camera::camera_tracking::CameraTracking": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "offset": { + "type": { + "$ref": "#/$defs/glam::Vec3" + } + } + }, + "required": [ + "offset" + ], + "short_name": "CameraTracking", + "title": "bevy_bevy_registry_export_basic_example::core::camera::camera_tracking::CameraTracking", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_bevy_registry_export_basic_example::core::camera::camera_tracking::CameraTrackingOffset": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/glam::Vec3" + } + } + ], + "short_name": "CameraTrackingOffset", + "title": "bevy_bevy_registry_export_basic_example::core::camera::camera_tracking::CameraTrackingOffset", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_bevy_registry_export_basic_example::core::physics::physics_replace_proxies::AutoAABBCollider": { + "isComponent": true, + "isResource": false, + "oneOf": [ + "Cuboid", + "Ball", + "Capsule" + ], + "short_name": "AutoAABBCollider", + "title": "bevy_bevy_registry_export_basic_example::core::physics::physics_replace_proxies::AutoAABBCollider", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_bevy_registry_export_basic_example::core::physics::physics_replace_proxies::Collider": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + } + ], + "short_name": "Ball", + "title": "Ball", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/glam::Vec3" + } + } + ], + "short_name": "Cuboid", + "title": "Cuboid", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/glam::Vec3" + } + }, + { + "type": { + "$ref": "#/$defs/glam::Vec3" + } + }, + { + "type": { + "$ref": "#/$defs/f32" + } + } + ], + "short_name": "Capsule", + "title": "Capsule", + "type": "array", + "typeInfo": "Tuple" + }, + { + "title": "Mesh" + } + ], + "short_name": "Collider", + "title": "bevy_bevy_registry_export_basic_example::core::physics::physics_replace_proxies::Collider", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_bevy_registry_export_basic_example::game::Interactible": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "Interactible", + "title": "bevy_bevy_registry_export_basic_example::game::Interactible", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_bevy_registry_export_basic_example::game::Player": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "Player", + "title": "bevy_bevy_registry_export_basic_example::game::Player", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_bevy_registry_export_basic_example::game::SoundMaterial": { + "isComponent": true, + "isResource": false, + "oneOf": [ + "Metal", + "Wood", + "Rock", + "Cloth", + "Squishy", + "None" + ], + "short_name": "SoundMaterial", + "title": "bevy_bevy_registry_export_basic_example::game::SoundMaterial", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_bevy_registry_export_basic_example::game::picking::Pickable": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "Pickable", + "title": "bevy_bevy_registry_export_basic_example::game::picking::Pickable", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_bevy_registry_export_basic_example::test_components::BasicTest": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "a": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "b": { + "type": { + "$ref": "#/$defs/u64" + } + }, + "c": { + "type": { + "$ref": "#/$defs/alloc::string::String" + } + } + }, + "required": [ + "a", + "b", + "c" + ], + "short_name": "BasicTest", + "title": "bevy_bevy_registry_export_basic_example::test_components::BasicTest", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_bevy_registry_export_basic_example::test_components::EnumComplex": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + } + ], + "short_name": "Float", + "title": "Float", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/alloc::string::String" + } + } + ], + "short_name": "Wood", + "title": "Wood", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_bevy_registry_export_basic_example::test_components::BasicTest" + } + } + ], + "short_name": "Vec", + "title": "Vec", + "type": "array", + "typeInfo": "Tuple" + }, + { + "title": "SomeThing" + }, + { + "title": "None" + } + ], + "short_name": "EnumComplex", + "title": "bevy_bevy_registry_export_basic_example::test_components::EnumComplex", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_bevy_registry_export_basic_example::test_components::EnumTest": { + "isComponent": true, + "isResource": false, + "oneOf": [ + "Metal", + "Wood", + "Rock", + "Cloth", + "Squishy", + "None" + ], + "short_name": "EnumTest", + "title": "bevy_bevy_registry_export_basic_example::test_components::EnumTest", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_bevy_registry_export_basic_example::test_components::NestedTuppleStuff": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + }, + { + "type": { + "$ref": "#/$defs/u64" + } + }, + { + "type": { + "$ref": "#/$defs/bevy_bevy_registry_export_basic_example::test_components::NestingTestLevel2" + } + } + ], + "short_name": "NestedTuppleStuff", + "title": "bevy_bevy_registry_export_basic_example::test_components::NestedTuppleStuff", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_bevy_registry_export_basic_example::test_components::NestingTestLevel2": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "basic": { + "type": { + "$ref": "#/$defs/bevy_bevy_registry_export_basic_example::test_components::BasicTest" + } + }, + "color": { + "type": { + "$ref": "#/$defs/bevy_bevy_registry_export_basic_example::test_components::TuppleTestColor" + } + }, + "colors_list": { + "type": { + "$ref": "#/$defs/bevy_bevy_registry_export_basic_example::test_components::VecOfColors" + } + }, + "enable": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "enum_inner": { + "type": { + "$ref": "#/$defs/bevy_bevy_registry_export_basic_example::test_components::EnumTest" + } + }, + "nested": { + "type": { + "$ref": "#/$defs/bevy_bevy_registry_export_basic_example::test_components::NestingTestLevel3" + } + }, + "text": { + "type": { + "$ref": "#/$defs/alloc::string::String" + } + }, + "toggle": { + "type": { + "$ref": "#/$defs/bevy_bevy_registry_export_basic_example::test_components::TuppleTestBool" + } + } + }, + "required": [ + "text", + "enable", + "enum_inner", + "color", + "toggle", + "basic", + "nested", + "colors_list" + ], + "short_name": "NestingTestLevel2", + "title": "bevy_bevy_registry_export_basic_example::test_components::NestingTestLevel2", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_bevy_registry_export_basic_example::test_components::NestingTestLevel3": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "vec": { + "type": { + "$ref": "#/$defs/bevy_bevy_registry_export_basic_example::test_components::TuppleVec3" + } + } + }, + "required": [ + "vec" + ], + "short_name": "NestingTestLevel3", + "title": "bevy_bevy_registry_export_basic_example::test_components::NestingTestLevel3", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_bevy_registry_export_basic_example::test_components::TuppleTest2": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + }, + { + "type": { + "$ref": "#/$defs/u64" + } + }, + { + "type": { + "$ref": "#/$defs/alloc::string::String" + } + } + ], + "short_name": "TuppleTest2", + "title": "bevy_bevy_registry_export_basic_example::test_components::TuppleTest2", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_bevy_registry_export_basic_example::test_components::TuppleTestBool": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bool" + } + } + ], + "short_name": "TuppleTestBool", + "title": "bevy_bevy_registry_export_basic_example::test_components::TuppleTestBool", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_bevy_registry_export_basic_example::test_components::TuppleTestColor": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_render::color::Color" + } + } + ], + "short_name": "TuppleTestColor", + "title": "bevy_bevy_registry_export_basic_example::test_components::TuppleTestColor", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_bevy_registry_export_basic_example::test_components::TuppleTestF32": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + } + ], + "short_name": "TuppleTestF32", + "title": "bevy_bevy_registry_export_basic_example::test_components::TuppleTestF32", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_bevy_registry_export_basic_example::test_components::TuppleTestStr": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/alloc::string::String" + } + } + ], + "short_name": "TuppleTestStr", + "title": "bevy_bevy_registry_export_basic_example::test_components::TuppleTestStr", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_bevy_registry_export_basic_example::test_components::TuppleTestU64": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/u64" + } + } + ], + "short_name": "TuppleTestU64", + "title": "bevy_bevy_registry_export_basic_example::test_components::TuppleTestU64", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_bevy_registry_export_basic_example::test_components::TuppleVec": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/alloc::vec::Vec" + } + } + ], + "short_name": "TuppleVec", + "title": "bevy_bevy_registry_export_basic_example::test_components::TuppleVec", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_bevy_registry_export_basic_example::test_components::TuppleVec2": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/glam::Vec2" + } + } + ], + "short_name": "TuppleVec2", + "title": "bevy_bevy_registry_export_basic_example::test_components::TuppleVec2", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_bevy_registry_export_basic_example::test_components::TuppleVec3": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/glam::Vec3" + } + } + ], + "short_name": "TuppleVec3", + "title": "bevy_bevy_registry_export_basic_example::test_components::TuppleVec3", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_bevy_registry_export_basic_example::test_components::TuppleVecF32F32": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/alloc::vec::Vec<(f32, f32)>" + } + } + ], + "short_name": "TuppleVecF32F32", + "title": "bevy_bevy_registry_export_basic_example::test_components::TuppleVecF32F32", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_bevy_registry_export_basic_example::test_components::UnitTest": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "UnitTest", + "title": "bevy_bevy_registry_export_basic_example::test_components::UnitTest", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_bevy_registry_export_basic_example::test_components::VecOfColors": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/alloc::vec::Vec" + } + } + ], + "short_name": "VecOfColors", + "title": "bevy_bevy_registry_export_basic_example::test_components::VecOfColors", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_bevy_registry_export_basic_example::test_components::VecOfVec3s2": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/alloc::vec::Vec" + } + } + ], + "short_name": "VecOfVec3s2", + "title": "bevy_bevy_registry_export_basic_example::test_components::VecOfVec3s2", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_core::name::Name": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "hash": { + "type": { + "$ref": "#/$defs/u64" + } + }, + "name": { + "type": { + "$ref": "#/$defs/alloc::borrow::Cow" + } + } + }, + "required": [ + "hash", + "name" + ], + "short_name": "Name", + "title": "bevy_core::name::Name", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_core_pipeline::bloom::settings::BloomCompositeMode": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "EnergyConserving", + "Additive" + ], + "short_name": "BloomCompositeMode", + "title": "bevy_core_pipeline::bloom::settings::BloomCompositeMode", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_core_pipeline::bloom::settings::BloomPrefilterSettings": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "threshold": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "threshold_softness": { + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "threshold", + "threshold_softness" + ], + "short_name": "BloomPrefilterSettings", + "title": "bevy_core_pipeline::bloom::settings::BloomPrefilterSettings", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_core_pipeline::bloom::settings::BloomSettings": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "composite_mode": { + "type": { + "$ref": "#/$defs/bevy_core_pipeline::bloom::settings::BloomCompositeMode" + } + }, + "high_pass_frequency": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "intensity": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "low_frequency_boost": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "low_frequency_boost_curvature": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "prefilter_settings": { + "type": { + "$ref": "#/$defs/bevy_core_pipeline::bloom::settings::BloomPrefilterSettings" + } + } + }, + "required": [ + "intensity", + "low_frequency_boost", + "low_frequency_boost_curvature", + "high_pass_frequency", + "prefilter_settings", + "composite_mode" + ], + "short_name": "BloomSettings", + "title": "bevy_core_pipeline::bloom::settings::BloomSettings", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_core_pipeline::clear_color::ClearColor": { + "isComponent": false, + "isResource": true, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_render::color::Color" + } + } + ], + "short_name": "ClearColor", + "title": "bevy_core_pipeline::clear_color::ClearColor", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_core_pipeline::clear_color::ClearColorConfig": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "title": "Default" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_render::color::Color" + } + } + ], + "short_name": "Custom", + "title": "Custom", + "type": "array", + "typeInfo": "Tuple" + }, + { + "title": "None" + } + ], + "short_name": "ClearColorConfig", + "title": "bevy_core_pipeline::clear_color::ClearColorConfig", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_core_pipeline::contrast_adaptive_sharpening::ContrastAdaptiveSharpeningSettings": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "denoise": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "enabled": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "sharpening_strength": { + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "enabled", + "sharpening_strength", + "denoise" + ], + "short_name": "ContrastAdaptiveSharpeningSettings", + "title": "bevy_core_pipeline::contrast_adaptive_sharpening::ContrastAdaptiveSharpeningSettings", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_core_pipeline::core_2d::camera_2d::Camera2d": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "clear_color": { + "type": { + "$ref": "#/$defs/bevy_core_pipeline::clear_color::ClearColorConfig" + } + } + }, + "required": [ + "clear_color" + ], + "short_name": "Camera2d", + "title": "bevy_core_pipeline::core_2d::camera_2d::Camera2d", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_core_pipeline::core_3d::camera_3d::Camera3d": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "clear_color": { + "type": { + "$ref": "#/$defs/bevy_core_pipeline::clear_color::ClearColorConfig" + } + }, + "depth_load_op": { + "type": { + "$ref": "#/$defs/bevy_core_pipeline::core_3d::camera_3d::Camera3dDepthLoadOp" + } + }, + "depth_texture_usages": { + "type": { + "$ref": "#/$defs/bevy_core_pipeline::core_3d::camera_3d::Camera3dDepthTextureUsage" + } + }, + "screen_space_specular_transmission_quality": { + "type": { + "$ref": "#/$defs/bevy_core_pipeline::core_3d::camera_3d::ScreenSpaceTransmissionQuality" + } + }, + "screen_space_specular_transmission_steps": { + "type": { + "$ref": "#/$defs/usize" + } + } + }, + "required": [ + "clear_color", + "depth_load_op", + "depth_texture_usages", + "screen_space_specular_transmission_steps", + "screen_space_specular_transmission_quality" + ], + "short_name": "Camera3d", + "title": "bevy_core_pipeline::core_3d::camera_3d::Camera3d", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_core_pipeline::core_3d::camera_3d::Camera3dDepthLoadOp": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + } + ], + "short_name": "Clear", + "title": "Clear", + "type": "array", + "typeInfo": "Tuple" + }, + { + "title": "Load" + } + ], + "short_name": "Camera3dDepthLoadOp", + "title": "bevy_core_pipeline::core_3d::camera_3d::Camera3dDepthLoadOp", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_core_pipeline::fxaa::Fxaa": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "edge_threshold": { + "type": { + "$ref": "#/$defs/bevy_core_pipeline::fxaa::Sensitivity" + } + }, + "edge_threshold_min": { + "type": { + "$ref": "#/$defs/bevy_core_pipeline::fxaa::Sensitivity" + } + }, + "enabled": { + "type": { + "$ref": "#/$defs/bool" + } + } + }, + "required": [ + "enabled", + "edge_threshold", + "edge_threshold_min" + ], + "short_name": "Fxaa", + "title": "bevy_core_pipeline::fxaa::Fxaa", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_core_pipeline::prepass::DepthPrepass": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "DepthPrepass", + "title": "bevy_core_pipeline::prepass::DepthPrepass", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_core_pipeline::prepass::NormalPrepass": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "NormalPrepass", + "title": "bevy_core_pipeline::prepass::NormalPrepass", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_core_pipeline::tonemapping::DebandDither": { + "isComponent": true, + "isResource": false, + "oneOf": [ + "Disabled", + "Enabled" + ], + "short_name": "DebandDither", + "title": "bevy_core_pipeline::tonemapping::DebandDither", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_core_pipeline::tonemapping::Tonemapping": { + "isComponent": true, + "isResource": false, + "oneOf": [ + "None", + "Reinhard", + "ReinhardLuminance", + "AcesFitted", + "AgX", + "SomewhatBoringDisplayTransform", + "TonyMcMapface", + "BlenderFilmic" + ], + "short_name": "Tonemapping", + "title": "bevy_core_pipeline::tonemapping::Tonemapping", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_ecs::Entity": { + "isComponent": false, + "isResource": false, + "short_name": "Entity", + "title": "bevy_ecs::Entity", + "type": "object", + "typeInfo": "Value" + }, + "bevy_egui::EguiSettings": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "default_open_url_target": { + "type": { + "$ref": "#/$defs/core::option::Option" + } + }, + "scale_factor": { + "type": { + "$ref": "#/$defs/f64" + } + } + }, + "required": [ + "scale_factor" + ], + "short_name": "EguiSettings", + "title": "bevy_egui::EguiSettings", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_gltf::GltfExtras": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "value": { + "type": { + "$ref": "#/$defs/alloc::string::String" + } + } + }, + "required": [ + "value" + ], + "short_name": "GltfExtras", + "title": "bevy_gltf::GltfExtras", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_gltf_blueprints::animation::Animations": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "named_animations": { + "type": { + "$ref": "#/$defs/bevy_utils::hashbrown::HashMap, bevy_utils::hashbrown::hash_map::DefaultHashBuilder>" + } + } + }, + "required": [ + "named_animations" + ], + "short_name": "Animations", + "title": "bevy_gltf_blueprints::animation::Animations", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_gltf_blueprints::materials::MaterialInfo": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "name": { + "type": { + "$ref": "#/$defs/alloc::string::String" + } + }, + "source": { + "type": { + "$ref": "#/$defs/alloc::string::String" + } + } + }, + "required": [ + "name", + "source" + ], + "short_name": "MaterialInfo", + "title": "bevy_gltf_blueprints::materials::MaterialInfo", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_gltf_blueprints::spawn_from_blueprints::BlueprintName": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/alloc::string::String" + } + } + ], + "short_name": "BlueprintName", + "title": "bevy_gltf_blueprints::spawn_from_blueprints::BlueprintName", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_gltf_blueprints::spawn_from_blueprints::SpawnHere": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "SpawnHere", + "title": "bevy_gltf_blueprints::spawn_from_blueprints::SpawnHere", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_hierarchy::components::children::Children": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/smallvec::SmallVec<[bevy_ecs::Entity; 8]>" + } + } + ], + "short_name": "Children", + "title": "bevy_hierarchy::components::children::Children", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_hierarchy::components::parent::Parent": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_ecs::Entity" + } + } + ], + "short_name": "Parent", + "title": "bevy_hierarchy::components::parent::Parent", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_input::ButtonState": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "Pressed", + "Released" + ], + "short_name": "ButtonState", + "title": "bevy_input::ButtonState", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_input::gamepad::AxisSettings": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "deadzone_lowerbound": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "deadzone_upperbound": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "livezone_lowerbound": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "livezone_upperbound": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "threshold": { + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "livezone_upperbound", + "deadzone_upperbound", + "deadzone_lowerbound", + "livezone_lowerbound", + "threshold" + ], + "short_name": "AxisSettings", + "title": "bevy_input::gamepad::AxisSettings", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_input::gamepad::ButtonAxisSettings": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "high": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "low": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "threshold": { + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "high", + "low", + "threshold" + ], + "short_name": "ButtonAxisSettings", + "title": "bevy_input::gamepad::ButtonAxisSettings", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_input::gamepad::ButtonSettings": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "press_threshold": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "release_threshold": { + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "press_threshold", + "release_threshold" + ], + "short_name": "ButtonSettings", + "title": "bevy_input::gamepad::ButtonSettings", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_input::gamepad::Gamepad": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "id": { + "type": { + "$ref": "#/$defs/usize" + } + } + }, + "required": [ + "id" + ], + "short_name": "Gamepad", + "title": "bevy_input::gamepad::Gamepad", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_input::gamepad::GamepadAxis": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "axis_type": { + "type": { + "$ref": "#/$defs/bevy_input::gamepad::GamepadAxisType" + } + }, + "gamepad": { + "type": { + "$ref": "#/$defs/bevy_input::gamepad::Gamepad" + } + } + }, + "required": [ + "gamepad", + "axis_type" + ], + "short_name": "GamepadAxis", + "title": "bevy_input::gamepad::GamepadAxis", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_input::gamepad::GamepadAxisType": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "title": "LeftStickX" + }, + { + "title": "LeftStickY" + }, + { + "title": "LeftZ" + }, + { + "title": "RightStickX" + }, + { + "title": "RightStickY" + }, + { + "title": "RightZ" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/u8" + } + } + ], + "short_name": "Other", + "title": "Other", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "GamepadAxisType", + "title": "bevy_input::gamepad::GamepadAxisType", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_input::gamepad::GamepadButton": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "button_type": { + "type": { + "$ref": "#/$defs/bevy_input::gamepad::GamepadButtonType" + } + }, + "gamepad": { + "type": { + "$ref": "#/$defs/bevy_input::gamepad::Gamepad" + } + } + }, + "required": [ + "gamepad", + "button_type" + ], + "short_name": "GamepadButton", + "title": "bevy_input::gamepad::GamepadButton", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_input::gamepad::GamepadButtonInput": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "button": { + "type": { + "$ref": "#/$defs/bevy_input::gamepad::GamepadButton" + } + }, + "state": { + "type": { + "$ref": "#/$defs/bevy_input::ButtonState" + } + } + }, + "required": [ + "button", + "state" + ], + "short_name": "GamepadButtonInput", + "title": "bevy_input::gamepad::GamepadButtonInput", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_input::gamepad::GamepadButtonType": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "title": "South" + }, + { + "title": "East" + }, + { + "title": "North" + }, + { + "title": "West" + }, + { + "title": "C" + }, + { + "title": "Z" + }, + { + "title": "LeftTrigger" + }, + { + "title": "LeftTrigger2" + }, + { + "title": "RightTrigger" + }, + { + "title": "RightTrigger2" + }, + { + "title": "Select" + }, + { + "title": "Start" + }, + { + "title": "Mode" + }, + { + "title": "LeftThumb" + }, + { + "title": "RightThumb" + }, + { + "title": "DPadUp" + }, + { + "title": "DPadDown" + }, + { + "title": "DPadLeft" + }, + { + "title": "DPadRight" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/u8" + } + } + ], + "short_name": "Other", + "title": "Other", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "GamepadButtonType", + "title": "bevy_input::gamepad::GamepadButtonType", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_input::gamepad::GamepadConnection": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_input::gamepad::GamepadInfo" + } + } + ], + "short_name": "Connected", + "title": "Connected", + "type": "array", + "typeInfo": "Tuple" + }, + { + "title": "Disconnected" + } + ], + "short_name": "GamepadConnection", + "title": "bevy_input::gamepad::GamepadConnection", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_input::gamepad::GamepadSettings": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "axis_settings": { + "type": { + "$ref": "#/$defs/bevy_utils::hashbrown::HashMap" + } + }, + "button_axis_settings": { + "type": { + "$ref": "#/$defs/bevy_utils::hashbrown::HashMap" + } + }, + "button_settings": { + "type": { + "$ref": "#/$defs/bevy_utils::hashbrown::HashMap" + } + }, + "default_axis_settings": { + "type": { + "$ref": "#/$defs/bevy_input::gamepad::AxisSettings" + } + }, + "default_button_axis_settings": { + "type": { + "$ref": "#/$defs/bevy_input::gamepad::ButtonAxisSettings" + } + }, + "default_button_settings": { + "type": { + "$ref": "#/$defs/bevy_input::gamepad::ButtonSettings" + } + } + }, + "required": [ + "default_button_settings", + "default_axis_settings", + "default_button_axis_settings", + "button_settings", + "axis_settings", + "button_axis_settings" + ], + "short_name": "GamepadSettings", + "title": "bevy_input::gamepad::GamepadSettings", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_input::keyboard::KeyCode": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "Key1", + "Key2", + "Key3", + "Key4", + "Key5", + "Key6", + "Key7", + "Key8", + "Key9", + "Key0", + "A", + "B", + "C", + "D", + "E", + "F", + "G", + "H", + "I", + "J", + "K", + "L", + "M", + "N", + "O", + "P", + "Q", + "R", + "S", + "T", + "U", + "V", + "W", + "X", + "Y", + "Z", + "Escape", + "F1", + "F2", + "F3", + "F4", + "F5", + "F6", + "F7", + "F8", + "F9", + "F10", + "F11", + "F12", + "F13", + "F14", + "F15", + "F16", + "F17", + "F18", + "F19", + "F20", + "F21", + "F22", + "F23", + "F24", + "Snapshot", + "Scroll", + "Pause", + "Insert", + "Home", + "Delete", + "End", + "PageDown", + "PageUp", + "Left", + "Up", + "Right", + "Down", + "Back", + "Return", + "Space", + "Compose", + "Caret", + "Numlock", + "Numpad0", + "Numpad1", + "Numpad2", + "Numpad3", + "Numpad4", + "Numpad5", + "Numpad6", + "Numpad7", + "Numpad8", + "Numpad9", + "AbntC1", + "AbntC2", + "NumpadAdd", + "Apostrophe", + "Apps", + "Asterisk", + "Plus", + "At", + "Ax", + "Backslash", + "Calculator", + "Capital", + "Colon", + "Comma", + "Convert", + "NumpadDecimal", + "NumpadDivide", + "Equals", + "Grave", + "Kana", + "Kanji", + "AltLeft", + "BracketLeft", + "ControlLeft", + "ShiftLeft", + "SuperLeft", + "Mail", + "MediaSelect", + "MediaStop", + "Minus", + "NumpadMultiply", + "Mute", + "MyComputer", + "NavigateForward", + "NavigateBackward", + "NextTrack", + "NoConvert", + "NumpadComma", + "NumpadEnter", + "NumpadEquals", + "Oem102", + "Period", + "PlayPause", + "Power", + "PrevTrack", + "AltRight", + "BracketRight", + "ControlRight", + "ShiftRight", + "SuperRight", + "Semicolon", + "Slash", + "Sleep", + "Stop", + "NumpadSubtract", + "Sysrq", + "Tab", + "Underline", + "Unlabeled", + "VolumeDown", + "VolumeUp", + "Wake", + "WebBack", + "WebFavorites", + "WebForward", + "WebHome", + "WebRefresh", + "WebSearch", + "WebStop", + "Yen", + "Copy", + "Paste", + "Cut" + ], + "short_name": "KeyCode", + "title": "bevy_input::keyboard::KeyCode", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_input::keyboard::KeyboardInput": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "key_code": { + "type": { + "$ref": "#/$defs/core::option::Option" + } + }, + "scan_code": { + "type": { + "$ref": "#/$defs/u32" + } + }, + "state": { + "type": { + "$ref": "#/$defs/bevy_input::ButtonState" + } + }, + "window": { + "type": { + "$ref": "#/$defs/bevy_ecs::Entity" + } + } + }, + "required": [ + "scan_code", + "state", + "window" + ], + "short_name": "KeyboardInput", + "title": "bevy_input::keyboard::KeyboardInput", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_input::keyboard::ScanCode": { + "isComponent": false, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/u32" + } + } + ], + "short_name": "ScanCode", + "title": "bevy_input::keyboard::ScanCode", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_input::mouse::MouseButton": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "title": "Left" + }, + { + "title": "Right" + }, + { + "title": "Middle" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/u16" + } + } + ], + "short_name": "Other", + "title": "Other", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "MouseButton", + "title": "bevy_input::mouse::MouseButton", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_input::mouse::MouseButtonInput": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "button": { + "type": { + "$ref": "#/$defs/bevy_input::mouse::MouseButton" + } + }, + "state": { + "type": { + "$ref": "#/$defs/bevy_input::ButtonState" + } + }, + "window": { + "type": { + "$ref": "#/$defs/bevy_ecs::Entity" + } + } + }, + "required": [ + "button", + "state", + "window" + ], + "short_name": "MouseButtonInput", + "title": "bevy_input::mouse::MouseButtonInput", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_input::mouse::MouseMotion": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "delta": { + "type": { + "$ref": "#/$defs/glam::Vec2" + } + } + }, + "required": [ + "delta" + ], + "short_name": "MouseMotion", + "title": "bevy_input::mouse::MouseMotion", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_input::mouse::MouseScrollUnit": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "Line", + "Pixel" + ], + "short_name": "MouseScrollUnit", + "title": "bevy_input::mouse::MouseScrollUnit", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_input::mouse::MouseWheel": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "unit": { + "type": { + "$ref": "#/$defs/bevy_input::mouse::MouseScrollUnit" + } + }, + "window": { + "type": { + "$ref": "#/$defs/bevy_ecs::Entity" + } + }, + "x": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "y": { + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "unit", + "x", + "y", + "window" + ], + "short_name": "MouseWheel", + "title": "bevy_input::mouse::MouseWheel", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_input::touch::ForceTouch": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "altitude_angle": { + "title": "altitude_angle", + "type": { + "$ref": "#/$defs/core::option::Option" + } + }, + "force": { + "title": "force", + "type": { + "$ref": "#/$defs/f64" + } + }, + "max_possible_force": { + "title": "max_possible_force", + "type": { + "$ref": "#/$defs/f64" + } + } + }, + "required": [ + "force", + "max_possible_force" + ], + "short_name": "Calibrated", + "title": "Calibrated", + "type": "object", + "typeInfo": "Struct" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f64" + } + } + ], + "short_name": "Normalized", + "title": "Normalized", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "ForceTouch", + "title": "bevy_input::touch::ForceTouch", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_input::touch::TouchInput": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "force": { + "type": { + "$ref": "#/$defs/core::option::Option" + } + }, + "id": { + "type": { + "$ref": "#/$defs/u64" + } + }, + "phase": { + "type": { + "$ref": "#/$defs/bevy_input::touch::TouchPhase" + } + }, + "position": { + "type": { + "$ref": "#/$defs/glam::Vec2" + } + } + }, + "required": [ + "phase", + "position", + "id" + ], + "short_name": "TouchInput", + "title": "bevy_input::touch::TouchInput", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_input::touch::TouchPhase": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "Started", + "Moved", + "Ended", + "Canceled" + ], + "short_name": "TouchPhase", + "title": "bevy_input::touch::TouchPhase", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_input::touchpad::TouchpadMagnify": { + "isComponent": false, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + } + ], + "short_name": "TouchpadMagnify", + "title": "bevy_input::touchpad::TouchpadMagnify", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_input::touchpad::TouchpadRotate": { + "isComponent": false, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + } + ], + "short_name": "TouchpadRotate", + "title": "bevy_input::touchpad::TouchpadRotate", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_math::Rect": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "max": { + "type": { + "$ref": "#/$defs/glam::Vec2" + } + }, + "min": { + "type": { + "$ref": "#/$defs/glam::Vec2" + } + } + }, + "required": [ + "min", + "max" + ], + "short_name": "Rect", + "title": "bevy_math::Rect", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_pbr::alpha::AlphaMode": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "title": "Opaque" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + } + ], + "short_name": "Mask", + "title": "Mask", + "type": "array", + "typeInfo": "Tuple" + }, + { + "title": "Blend" + }, + { + "title": "Premultiplied" + }, + { + "title": "Add" + }, + { + "title": "Multiply" + } + ], + "short_name": "AlphaMode", + "title": "bevy_pbr::alpha::AlphaMode", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_pbr::bundle::CascadesVisibleEntities": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "CascadesVisibleEntities", + "title": "bevy_pbr::bundle::CascadesVisibleEntities", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_pbr::bundle::CubemapVisibleEntities": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "CubemapVisibleEntities", + "title": "bevy_pbr::bundle::CubemapVisibleEntities", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_pbr::environment_map::EnvironmentMapLight": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "diffuse_map": { + "type": { + "$ref": "#/$defs/bevy_asset::handle::Handle" + } + }, + "specular_map": { + "type": { + "$ref": "#/$defs/bevy_asset::handle::Handle" + } + } + }, + "required": [ + "diffuse_map", + "specular_map" + ], + "short_name": "EnvironmentMapLight", + "title": "bevy_pbr::environment_map::EnvironmentMapLight", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_pbr::fog::FogSettings": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "color": { + "type": { + "$ref": "#/$defs/bevy_render::color::Color" + } + }, + "directional_light_color": { + "type": { + "$ref": "#/$defs/bevy_render::color::Color" + } + }, + "directional_light_exponent": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "falloff": { + "type": { + "$ref": "#/$defs/bevy_pbr::fog::FogFalloff" + } + } + }, + "required": [ + "color", + "directional_light_color", + "directional_light_exponent", + "falloff" + ], + "short_name": "FogSettings", + "title": "bevy_pbr::fog::FogSettings", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_pbr::light::AmbientLight": { + "additionalProperties": false, + "isComponent": false, + "isResource": true, + "properties": { + "brightness": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "color": { + "type": { + "$ref": "#/$defs/bevy_render::color::Color" + } + } + }, + "required": [ + "color", + "brightness" + ], + "short_name": "AmbientLight", + "title": "bevy_pbr::light::AmbientLight", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_pbr::light::Cascade": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "projection": { + "type": { + "$ref": "#/$defs/glam::Mat4" + } + }, + "texel_size": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "view_projection": { + "type": { + "$ref": "#/$defs/glam::Mat4" + } + }, + "view_transform": { + "type": { + "$ref": "#/$defs/glam::Mat4" + } + } + }, + "required": [ + "view_transform", + "projection", + "view_projection", + "texel_size" + ], + "short_name": "Cascade", + "title": "bevy_pbr::light::Cascade", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_pbr::light::CascadeShadowConfig": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "bounds": { + "type": { + "$ref": "#/$defs/alloc::vec::Vec" + } + }, + "minimum_distance": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "overlap_proportion": { + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "bounds", + "overlap_proportion", + "minimum_distance" + ], + "short_name": "CascadeShadowConfig", + "title": "bevy_pbr::light::CascadeShadowConfig", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_pbr::light::Cascades": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "cascades": { + "type": { + "$ref": "#/$defs/bevy_utils::hashbrown::HashMap, bevy_utils::hashbrown::hash_map::DefaultHashBuilder>" + } + } + }, + "required": [ + "cascades" + ], + "short_name": "Cascades", + "title": "bevy_pbr::light::Cascades", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_pbr::light::ClusterConfig": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "title": "None" + }, + { + "title": "Single" + }, + { + "additionalProperties": false, + "properties": { + "dimensions": { + "title": "dimensions", + "type": { + "$ref": "#/$defs/glam::UVec3" + } + }, + "dynamic_resizing": { + "title": "dynamic_resizing", + "type": { + "$ref": "#/$defs/bool" + } + }, + "z_config": { + "title": "z_config", + "type": { + "$ref": "#/$defs/bevy_pbr::light::ClusterZConfig" + } + } + }, + "required": [ + "dimensions", + "z_config", + "dynamic_resizing" + ], + "short_name": "XYZ", + "title": "XYZ", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "dynamic_resizing": { + "title": "dynamic_resizing", + "type": { + "$ref": "#/$defs/bool" + } + }, + "total": { + "title": "total", + "type": { + "$ref": "#/$defs/u32" + } + }, + "z_config": { + "title": "z_config", + "type": { + "$ref": "#/$defs/bevy_pbr::light::ClusterZConfig" + } + }, + "z_slices": { + "title": "z_slices", + "type": { + "$ref": "#/$defs/u32" + } + } + }, + "required": [ + "total", + "z_slices", + "z_config", + "dynamic_resizing" + ], + "short_name": "FixedZ", + "title": "FixedZ", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "ClusterConfig", + "title": "bevy_pbr::light::ClusterConfig", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_pbr::light::ClusterFarZMode": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "title": "MaxLightRange" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + } + ], + "short_name": "Constant", + "title": "Constant", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "ClusterFarZMode", + "title": "bevy_pbr::light::ClusterFarZMode", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_pbr::light::ClusterZConfig": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "far_z_mode": { + "type": { + "$ref": "#/$defs/bevy_pbr::light::ClusterFarZMode" + } + }, + "first_slice_depth": { + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "first_slice_depth", + "far_z_mode" + ], + "short_name": "ClusterZConfig", + "title": "bevy_pbr::light::ClusterZConfig", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_pbr::light::DirectionalLight": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "color": { + "type": { + "$ref": "#/$defs/bevy_render::color::Color" + } + }, + "illuminance": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "shadow_depth_bias": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "shadow_normal_bias": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "shadows_enabled": { + "type": { + "$ref": "#/$defs/bool" + } + } + }, + "required": [ + "color", + "illuminance", + "shadows_enabled", + "shadow_depth_bias", + "shadow_normal_bias" + ], + "short_name": "DirectionalLight", + "title": "bevy_pbr::light::DirectionalLight", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_pbr::light::DirectionalLightShadowMap": { + "additionalProperties": false, + "isComponent": false, + "isResource": true, + "properties": { + "size": { + "type": { + "$ref": "#/$defs/usize" + } + } + }, + "required": [ + "size" + ], + "short_name": "DirectionalLightShadowMap", + "title": "bevy_pbr::light::DirectionalLightShadowMap", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_pbr::light::NotShadowCaster": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "NotShadowCaster", + "title": "bevy_pbr::light::NotShadowCaster", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_pbr::light::NotShadowReceiver": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "NotShadowReceiver", + "title": "bevy_pbr::light::NotShadowReceiver", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_pbr::light::PointLight": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "color": { + "type": { + "$ref": "#/$defs/bevy_render::color::Color" + } + }, + "intensity": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "radius": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "range": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "shadow_depth_bias": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "shadow_normal_bias": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "shadows_enabled": { + "type": { + "$ref": "#/$defs/bool" + } + } + }, + "required": [ + "color", + "intensity", + "range", + "radius", + "shadows_enabled", + "shadow_depth_bias", + "shadow_normal_bias" + ], + "short_name": "PointLight", + "title": "bevy_pbr::light::PointLight", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_pbr::light::PointLightShadowMap": { + "additionalProperties": false, + "isComponent": false, + "isResource": true, + "properties": { + "size": { + "type": { + "$ref": "#/$defs/usize" + } + } + }, + "required": [ + "size" + ], + "short_name": "PointLightShadowMap", + "title": "bevy_pbr::light::PointLightShadowMap", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_pbr::light::ShadowFilteringMethod": { + "isComponent": true, + "isResource": false, + "oneOf": [ + "Hardware2x2", + "Castano13", + "Jimenez14" + ], + "short_name": "ShadowFilteringMethod", + "title": "bevy_pbr::light::ShadowFilteringMethod", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_pbr::light::SpotLight": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "color": { + "type": { + "$ref": "#/$defs/bevy_render::color::Color" + } + }, + "inner_angle": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "intensity": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "outer_angle": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "radius": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "range": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "shadow_depth_bias": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "shadow_normal_bias": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "shadows_enabled": { + "type": { + "$ref": "#/$defs/bool" + } + } + }, + "required": [ + "color", + "intensity", + "range", + "radius", + "shadows_enabled", + "shadow_depth_bias", + "shadow_normal_bias", + "outer_angle", + "inner_angle" + ], + "short_name": "SpotLight", + "title": "bevy_pbr::light::SpotLight", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_pbr::material::DefaultOpaqueRendererMethod": { + "isComponent": false, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_pbr::material::OpaqueRendererMethod" + } + } + ], + "short_name": "DefaultOpaqueRendererMethod", + "title": "bevy_pbr::material::DefaultOpaqueRendererMethod", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_pbr::pbr_material::StandardMaterial": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "alpha_mode": { + "type": { + "$ref": "#/$defs/bevy_pbr::alpha::AlphaMode" + } + }, + "attenuation_color": { + "type": { + "$ref": "#/$defs/bevy_render::color::Color" + } + }, + "attenuation_distance": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "base_color": { + "type": { + "$ref": "#/$defs/bevy_render::color::Color" + } + }, + "base_color_texture": { + "type": { + "$ref": "#/$defs/core::option::Option>" + } + }, + "deferred_lighting_pass_id": { + "type": { + "$ref": "#/$defs/u8" + } + }, + "depth_bias": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "depth_map": { + "type": { + "$ref": "#/$defs/core::option::Option>" + } + }, + "diffuse_transmission": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "double_sided": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "emissive": { + "type": { + "$ref": "#/$defs/bevy_render::color::Color" + } + }, + "emissive_texture": { + "type": { + "$ref": "#/$defs/core::option::Option>" + } + }, + "flip_normal_map_y": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "fog_enabled": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "ior": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "max_parallax_layer_count": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "metallic": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "metallic_roughness_texture": { + "type": { + "$ref": "#/$defs/core::option::Option>" + } + }, + "normal_map_texture": { + "type": { + "$ref": "#/$defs/core::option::Option>" + } + }, + "occlusion_texture": { + "type": { + "$ref": "#/$defs/core::option::Option>" + } + }, + "opaque_render_method": { + "type": { + "$ref": "#/$defs/bevy_pbr::material::OpaqueRendererMethod" + } + }, + "parallax_depth_scale": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "parallax_mapping_method": { + "type": { + "$ref": "#/$defs/bevy_pbr::parallax::ParallaxMappingMethod" + } + }, + "perceptual_roughness": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "reflectance": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "specular_transmission": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "thickness": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "unlit": { + "type": { + "$ref": "#/$defs/bool" + } + } + }, + "required": [ + "base_color", + "emissive", + "perceptual_roughness", + "metallic", + "reflectance", + "diffuse_transmission", + "specular_transmission", + "thickness", + "ior", + "attenuation_distance", + "attenuation_color", + "flip_normal_map_y", + "double_sided", + "unlit", + "fog_enabled", + "alpha_mode", + "depth_bias", + "parallax_depth_scale", + "parallax_mapping_method", + "max_parallax_layer_count", + "opaque_render_method", + "deferred_lighting_pass_id" + ], + "short_name": "StandardMaterial", + "title": "bevy_pbr::pbr_material::StandardMaterial", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_pbr::ssao::ScreenSpaceAmbientOcclusionSettings": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "quality_level": { + "type": { + "$ref": "#/$defs/bevy_pbr::ssao::ScreenSpaceAmbientOcclusionQualityLevel" + } + } + }, + "required": [ + "quality_level" + ], + "short_name": "ScreenSpaceAmbientOcclusionSettings", + "title": "bevy_pbr::ssao::ScreenSpaceAmbientOcclusionSettings", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_pbr::wireframe::NoWireframe": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "NoWireframe", + "title": "bevy_pbr::wireframe::NoWireframe", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_pbr::wireframe::Wireframe": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "Wireframe", + "title": "bevy_pbr::wireframe::Wireframe", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_pbr::wireframe::WireframeConfig": { + "additionalProperties": false, + "isComponent": false, + "isResource": true, + "properties": { + "default_color": { + "type": { + "$ref": "#/$defs/bevy_render::color::Color" + } + }, + "global": { + "type": { + "$ref": "#/$defs/bool" + } + } + }, + "required": [ + "global", + "default_color" + ], + "short_name": "WireframeConfig", + "title": "bevy_pbr::wireframe::WireframeConfig", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_rapier3d::dynamics::rigid_body::AdditionalMassProperties": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + } + ], + "short_name": "Mass", + "title": "Mass", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_rapier3d::dynamics::rigid_body::MassProperties" + } + } + ], + "short_name": "MassProperties", + "title": "MassProperties", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "AdditionalMassProperties", + "title": "bevy_rapier3d::dynamics::rigid_body::AdditionalMassProperties", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_rapier3d::dynamics::rigid_body::Ccd": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "enabled": { + "type": { + "$ref": "#/$defs/bool" + } + } + }, + "required": [ + "enabled" + ], + "short_name": "Ccd", + "title": "bevy_rapier3d::dynamics::rigid_body::Ccd", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_rapier3d::dynamics::rigid_body::Damping": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "angular_damping": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "linear_damping": { + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "linear_damping", + "angular_damping" + ], + "short_name": "Damping", + "title": "bevy_rapier3d::dynamics::rigid_body::Damping", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_rapier3d::dynamics::rigid_body::Dominance": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "groups": { + "type": { + "$ref": "#/$defs/i8" + } + } + }, + "required": [ + "groups" + ], + "short_name": "Dominance", + "title": "bevy_rapier3d::dynamics::rigid_body::Dominance", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_rapier3d::dynamics::rigid_body::ExternalForce": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "force": { + "type": { + "$ref": "#/$defs/glam::Vec3" + } + }, + "torque": { + "type": { + "$ref": "#/$defs/glam::Vec3" + } + } + }, + "required": [ + "force", + "torque" + ], + "short_name": "ExternalForce", + "title": "bevy_rapier3d::dynamics::rigid_body::ExternalForce", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_rapier3d::dynamics::rigid_body::ExternalImpulse": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "impulse": { + "type": { + "$ref": "#/$defs/glam::Vec3" + } + }, + "torque_impulse": { + "type": { + "$ref": "#/$defs/glam::Vec3" + } + } + }, + "required": [ + "impulse", + "torque_impulse" + ], + "short_name": "ExternalImpulse", + "title": "bevy_rapier3d::dynamics::rigid_body::ExternalImpulse", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_rapier3d::dynamics::rigid_body::GravityScale": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + } + ], + "short_name": "GravityScale", + "title": "bevy_rapier3d::dynamics::rigid_body::GravityScale", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_rapier3d::dynamics::rigid_body::LockedAxes": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/u8" + } + } + ], + "short_name": "LockedAxes", + "title": "bevy_rapier3d::dynamics::rigid_body::LockedAxes", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_rapier3d::dynamics::rigid_body::MassProperties": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "local_center_of_mass": { + "type": { + "$ref": "#/$defs/glam::Vec3" + } + }, + "mass": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "principal_inertia": { + "type": { + "$ref": "#/$defs/glam::Vec3" + } + }, + "principal_inertia_local_frame": { + "type": { + "$ref": "#/$defs/glam::Quat" + } + } + }, + "required": [ + "local_center_of_mass", + "mass", + "principal_inertia_local_frame", + "principal_inertia" + ], + "short_name": "MassProperties", + "title": "bevy_rapier3d::dynamics::rigid_body::MassProperties", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_rapier3d::dynamics::rigid_body::RigidBody": { + "isComponent": true, + "isResource": false, + "oneOf": [ + "Dynamic", + "Fixed", + "KinematicPositionBased", + "KinematicVelocityBased" + ], + "short_name": "RigidBody", + "title": "bevy_rapier3d::dynamics::rigid_body::RigidBody", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_rapier3d::dynamics::rigid_body::Sleeping": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "angular_threshold": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "linear_threshold": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "sleeping": { + "type": { + "$ref": "#/$defs/bool" + } + } + }, + "required": [ + "linear_threshold", + "angular_threshold", + "sleeping" + ], + "short_name": "Sleeping", + "title": "bevy_rapier3d::dynamics::rigid_body::Sleeping", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_rapier3d::dynamics::rigid_body::Velocity": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "angvel": { + "type": { + "$ref": "#/$defs/glam::Vec3" + } + }, + "linvel": { + "type": { + "$ref": "#/$defs/glam::Vec3" + } + } + }, + "required": [ + "linvel", + "angvel" + ], + "short_name": "Velocity", + "title": "bevy_rapier3d::dynamics::rigid_body::Velocity", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_rapier3d::geometry::collider::CollidingEntities": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_utils::HashSet" + } + } + ], + "short_name": "CollidingEntities", + "title": "bevy_rapier3d::geometry::collider::CollidingEntities", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_rapier3d::geometry::collider::CollisionGroups": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "filters": { + "type": { + "$ref": "#/$defs/bevy_rapier3d::geometry::collider::Group" + } + }, + "memberships": { + "type": { + "$ref": "#/$defs/bevy_rapier3d::geometry::collider::Group" + } + } + }, + "required": [ + "memberships", + "filters" + ], + "short_name": "CollisionGroups", + "title": "bevy_rapier3d::geometry::collider::CollisionGroups", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_rapier3d::geometry::collider::ContactForceEventThreshold": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + } + ], + "short_name": "ContactForceEventThreshold", + "title": "bevy_rapier3d::geometry::collider::ContactForceEventThreshold", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_rapier3d::geometry::collider::Friction": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "coefficient": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "combine_rule": { + "type": { + "$ref": "#/$defs/bevy_rapier3d::dynamics::CoefficientCombineRule" + } + } + }, + "required": [ + "coefficient", + "combine_rule" + ], + "short_name": "Friction", + "title": "bevy_rapier3d::geometry::collider::Friction", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_rapier3d::geometry::collider::Group": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/u32" + } + } + ], + "short_name": "Group", + "title": "bevy_rapier3d::geometry::collider::Group", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_rapier3d::geometry::collider::Restitution": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "coefficient": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "combine_rule": { + "type": { + "$ref": "#/$defs/bevy_rapier3d::dynamics::CoefficientCombineRule" + } + } + }, + "required": [ + "coefficient", + "combine_rule" + ], + "short_name": "Restitution", + "title": "bevy_rapier3d::geometry::collider::Restitution", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_rapier3d::geometry::collider::Sensor": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "Sensor", + "title": "bevy_rapier3d::geometry::collider::Sensor", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_rapier3d::geometry::collider::SolverGroups": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "filters": { + "type": { + "$ref": "#/$defs/bevy_rapier3d::geometry::collider::Group" + } + }, + "memberships": { + "type": { + "$ref": "#/$defs/bevy_rapier3d::geometry::collider::Group" + } + } + }, + "required": [ + "memberships", + "filters" + ], + "short_name": "SolverGroups", + "title": "bevy_rapier3d::geometry::collider::SolverGroups", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_rapier3d::render::DebugRenderContext": { + "additionalProperties": false, + "isComponent": false, + "isResource": true, + "properties": { + "enabled": { + "type": { + "$ref": "#/$defs/bool" + } + } + }, + "required": [ + "enabled" + ], + "short_name": "DebugRenderContext", + "title": "bevy_rapier3d::render::DebugRenderContext", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_render::camera::camera::Camera": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "hdr": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "is_active": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "msaa_writeback": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "order": { + "type": { + "$ref": "#/$defs/isize" + } + }, + "viewport": { + "type": { + "$ref": "#/$defs/core::option::Option" + } + } + }, + "required": [ + "order", + "is_active", + "hdr", + "msaa_writeback" + ], + "short_name": "Camera", + "title": "bevy_render::camera::camera::Camera", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_render::camera::camera::CameraRenderGraph": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/alloc::borrow::Cow" + } + } + ], + "short_name": "CameraRenderGraph", + "title": "bevy_render::camera::camera::CameraRenderGraph", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_render::camera::camera::RenderTarget": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_window::window::WindowRef" + } + } + ], + "short_name": "Window", + "title": "Window", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::handle::Handle" + } + } + ], + "short_name": "Image", + "title": "Image", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_render::camera::manual_texture_view::ManualTextureViewHandle" + } + } + ], + "short_name": "TextureView", + "title": "TextureView", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "RenderTarget", + "title": "bevy_render::camera::camera::RenderTarget", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_render::camera::camera::Viewport": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "depth": { + "type": { + "$ref": "#/$defs/core::ops::Range" + } + }, + "physical_position": { + "type": { + "$ref": "#/$defs/glam::UVec2" + } + }, + "physical_size": { + "type": { + "$ref": "#/$defs/glam::UVec2" + } + } + }, + "required": [ + "physical_position", + "physical_size", + "depth" + ], + "short_name": "Viewport", + "title": "bevy_render::camera::camera::Viewport", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_render::camera::projection::OrthographicProjection": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "area": { + "type": { + "$ref": "#/$defs/bevy_math::Rect" + } + }, + "far": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "near": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "scale": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "scaling_mode": { + "type": { + "$ref": "#/$defs/bevy_render::camera::projection::ScalingMode" + } + }, + "viewport_origin": { + "type": { + "$ref": "#/$defs/glam::Vec2" + } + } + }, + "required": [ + "near", + "far", + "viewport_origin", + "scaling_mode", + "scale", + "area" + ], + "short_name": "OrthographicProjection", + "title": "bevy_render::camera::projection::OrthographicProjection", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_render::camera::projection::PerspectiveProjection": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "aspect_ratio": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "far": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "fov": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "near": { + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "fov", + "aspect_ratio", + "near", + "far" + ], + "short_name": "PerspectiveProjection", + "title": "bevy_render::camera::projection::PerspectiveProjection", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_render::camera::projection::Projection": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_render::camera::projection::PerspectiveProjection" + } + } + ], + "short_name": "Perspective", + "title": "Perspective", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_render::camera::projection::OrthographicProjection" + } + } + ], + "short_name": "Orthographic", + "title": "Orthographic", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Projection", + "title": "bevy_render::camera::projection::Projection", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_render::camera::projection::ScalingMode": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "height": { + "title": "height", + "type": { + "$ref": "#/$defs/f32" + } + }, + "width": { + "title": "width", + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "width", + "height" + ], + "short_name": "Fixed", + "title": "Fixed", + "type": "object", + "typeInfo": "Struct" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + } + ], + "short_name": "WindowSize", + "title": "WindowSize", + "type": "array", + "typeInfo": "Tuple" + }, + { + "additionalProperties": false, + "properties": { + "min_height": { + "title": "min_height", + "type": { + "$ref": "#/$defs/f32" + } + }, + "min_width": { + "title": "min_width", + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "min_width", + "min_height" + ], + "short_name": "AutoMin", + "title": "AutoMin", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "max_height": { + "title": "max_height", + "type": { + "$ref": "#/$defs/f32" + } + }, + "max_width": { + "title": "max_width", + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "max_width", + "max_height" + ], + "short_name": "AutoMax", + "title": "AutoMax", + "type": "object", + "typeInfo": "Struct" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + } + ], + "short_name": "FixedVertical", + "title": "FixedVertical", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + } + ], + "short_name": "FixedHorizontal", + "title": "FixedHorizontal", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "ScalingMode", + "title": "bevy_render::camera::projection::ScalingMode", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_render::color::Color": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "alpha": { + "title": "alpha", + "type": { + "$ref": "#/$defs/f32" + } + }, + "blue": { + "title": "blue", + "type": { + "$ref": "#/$defs/f32" + } + }, + "green": { + "title": "green", + "type": { + "$ref": "#/$defs/f32" + } + }, + "red": { + "title": "red", + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "red", + "green", + "blue", + "alpha" + ], + "short_name": "Rgba", + "title": "Rgba", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "alpha": { + "title": "alpha", + "type": { + "$ref": "#/$defs/f32" + } + }, + "blue": { + "title": "blue", + "type": { + "$ref": "#/$defs/f32" + } + }, + "green": { + "title": "green", + "type": { + "$ref": "#/$defs/f32" + } + }, + "red": { + "title": "red", + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "red", + "green", + "blue", + "alpha" + ], + "short_name": "RgbaLinear", + "title": "RgbaLinear", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "alpha": { + "title": "alpha", + "type": { + "$ref": "#/$defs/f32" + } + }, + "hue": { + "title": "hue", + "type": { + "$ref": "#/$defs/f32" + } + }, + "lightness": { + "title": "lightness", + "type": { + "$ref": "#/$defs/f32" + } + }, + "saturation": { + "title": "saturation", + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "hue", + "saturation", + "lightness", + "alpha" + ], + "short_name": "Hsla", + "title": "Hsla", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "alpha": { + "title": "alpha", + "type": { + "$ref": "#/$defs/f32" + } + }, + "chroma": { + "title": "chroma", + "type": { + "$ref": "#/$defs/f32" + } + }, + "hue": { + "title": "hue", + "type": { + "$ref": "#/$defs/f32" + } + }, + "lightness": { + "title": "lightness", + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "lightness", + "chroma", + "hue", + "alpha" + ], + "short_name": "Lcha", + "title": "Lcha", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "Color", + "title": "bevy_render::color::Color", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_render::globals::GlobalsUniform": { + "additionalProperties": false, + "isComponent": false, + "isResource": true, + "properties": { + "delta_time": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "frame_count": { + "type": { + "$ref": "#/$defs/u32" + } + }, + "time": { + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "time", + "delta_time", + "frame_count" + ], + "short_name": "GlobalsUniform", + "title": "bevy_render::globals::GlobalsUniform", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_render::mesh::mesh::Indices": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/alloc::vec::Vec" + } + } + ], + "short_name": "U16", + "title": "U16", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/alloc::vec::Vec" + } + } + ], + "short_name": "U32", + "title": "U32", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Indices", + "title": "bevy_render::mesh::mesh::Indices", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_render::mesh::mesh::Mesh": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "indices": { + "type": { + "$ref": "#/$defs/core::option::Option" + } + }, + "morph_target_names": { + "type": { + "$ref": "#/$defs/core::option::Option>" + } + }, + "morph_targets": { + "type": { + "$ref": "#/$defs/core::option::Option>" + } + } + }, + "required": [], + "short_name": "Mesh", + "title": "bevy_render::mesh::mesh::Mesh", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_render::mesh::mesh::skinning::SkinnedMesh": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "inverse_bindposes": { + "type": { + "$ref": "#/$defs/bevy_asset::handle::Handle" + } + }, + "joints": { + "type": { + "$ref": "#/$defs/alloc::vec::Vec" + } + } + }, + "required": [ + "inverse_bindposes", + "joints" + ], + "short_name": "SkinnedMesh", + "title": "bevy_render::mesh::mesh::skinning::SkinnedMesh", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_render::mesh::morph::MeshMorphWeights": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "weights": { + "type": { + "$ref": "#/$defs/alloc::vec::Vec" + } + } + }, + "required": [ + "weights" + ], + "short_name": "MeshMorphWeights", + "title": "bevy_render::mesh::morph::MeshMorphWeights", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_render::mesh::morph::MorphWeights": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "first_mesh": { + "type": { + "$ref": "#/$defs/core::option::Option>" + } + }, + "weights": { + "type": { + "$ref": "#/$defs/alloc::vec::Vec" + } + } + }, + "required": [ + "weights" + ], + "short_name": "MorphWeights", + "title": "bevy_render::mesh::morph::MorphWeights", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_render::primitives::Aabb": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "center": { + "type": { + "$ref": "#/$defs/glam::Vec3A" + } + }, + "half_extents": { + "type": { + "$ref": "#/$defs/glam::Vec3A" + } + } + }, + "required": [ + "center", + "half_extents" + ], + "short_name": "Aabb", + "title": "bevy_render::primitives::Aabb", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_render::primitives::CascadesFrusta": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "CascadesFrusta", + "title": "bevy_render::primitives::CascadesFrusta", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_render::primitives::CubemapFrusta": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "CubemapFrusta", + "title": "bevy_render::primitives::CubemapFrusta", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_render::primitives::Frustum": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "Frustum", + "title": "bevy_render::primitives::Frustum", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_render::texture::image::Image": { + "isComponent": false, + "isResource": false, + "short_name": "Image", + "title": "bevy_render::texture::image::Image", + "type": "object", + "typeInfo": "Value" + }, + "bevy_render::view::ColorGrading": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "exposure": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "gamma": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "post_saturation": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "pre_saturation": { + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "exposure", + "gamma", + "pre_saturation", + "post_saturation" + ], + "short_name": "ColorGrading", + "title": "bevy_render::view::ColorGrading", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_render::view::Msaa": { + "isComponent": false, + "isResource": true, + "oneOf": [ + "Off", + "Sample2", + "Sample4", + "Sample8" + ], + "short_name": "Msaa", + "title": "bevy_render::view::Msaa", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_render::view::visibility::InheritedVisibility": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bool" + } + } + ], + "short_name": "InheritedVisibility", + "title": "bevy_render::view::visibility::InheritedVisibility", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_render::view::visibility::NoFrustumCulling": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "NoFrustumCulling", + "title": "bevy_render::view::visibility::NoFrustumCulling", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_render::view::visibility::ViewVisibility": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bool" + } + } + ], + "short_name": "ViewVisibility", + "title": "bevy_render::view::visibility::ViewVisibility", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_render::view::visibility::Visibility": { + "isComponent": true, + "isResource": false, + "oneOf": [ + "Inherited", + "Hidden", + "Visible" + ], + "short_name": "Visibility", + "title": "bevy_render::view::visibility::Visibility", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_render::view::visibility::VisibleEntities": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "VisibleEntities", + "title": "bevy_render::view::visibility::VisibleEntities", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_render::view::visibility::render_layers::RenderLayers": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/u32" + } + } + ], + "short_name": "RenderLayers", + "title": "bevy_render::view::visibility::render_layers::RenderLayers", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_sprite::mesh2d::color_material::ColorMaterial": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "color": { + "type": { + "$ref": "#/$defs/bevy_render::color::Color" + } + }, + "texture": { + "type": { + "$ref": "#/$defs/core::option::Option>" + } + } + }, + "required": [ + "color" + ], + "short_name": "ColorMaterial", + "title": "bevy_sprite::mesh2d::color_material::ColorMaterial", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_sprite::mesh2d::mesh::Mesh2dHandle": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::handle::Handle" + } + } + ], + "short_name": "Mesh2dHandle", + "title": "bevy_sprite::mesh2d::mesh::Mesh2dHandle", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_sprite::sprite::Anchor": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "title": "Center" + }, + { + "title": "BottomLeft" + }, + { + "title": "BottomCenter" + }, + { + "title": "BottomRight" + }, + { + "title": "CenterLeft" + }, + { + "title": "CenterRight" + }, + { + "title": "TopLeft" + }, + { + "title": "TopCenter" + }, + { + "title": "TopRight" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/glam::Vec2" + } + } + ], + "short_name": "Custom", + "title": "Custom", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Anchor", + "title": "bevy_sprite::sprite::Anchor", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_sprite::sprite::Sprite": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "anchor": { + "type": { + "$ref": "#/$defs/bevy_sprite::sprite::Anchor" + } + }, + "color": { + "type": { + "$ref": "#/$defs/bevy_render::color::Color" + } + }, + "custom_size": { + "type": { + "$ref": "#/$defs/core::option::Option" + } + }, + "flip_x": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "flip_y": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "rect": { + "type": { + "$ref": "#/$defs/core::option::Option" + } + } + }, + "required": [ + "color", + "flip_x", + "flip_y", + "anchor" + ], + "short_name": "Sprite", + "title": "bevy_sprite::sprite::Sprite", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_sprite::texture_atlas::TextureAtlas": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "size": { + "type": { + "$ref": "#/$defs/glam::Vec2" + } + }, + "texture": { + "type": { + "$ref": "#/$defs/bevy_asset::handle::Handle" + } + }, + "texture_handles": { + "type": { + "$ref": "#/$defs/core::option::Option, usize, bevy_utils::hashbrown::hash_map::DefaultHashBuilder>>" + } + }, + "textures": { + "type": { + "$ref": "#/$defs/alloc::vec::Vec" + } + } + }, + "required": [ + "texture", + "size", + "textures" + ], + "short_name": "TextureAtlas", + "title": "bevy_sprite::texture_atlas::TextureAtlas", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_sprite::texture_atlas::TextureAtlasSprite": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "anchor": { + "type": { + "$ref": "#/$defs/bevy_sprite::sprite::Anchor" + } + }, + "color": { + "type": { + "$ref": "#/$defs/bevy_render::color::Color" + } + }, + "custom_size": { + "type": { + "$ref": "#/$defs/core::option::Option" + } + }, + "flip_x": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "flip_y": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "index": { + "type": { + "$ref": "#/$defs/usize" + } + } + }, + "required": [ + "color", + "index", + "flip_x", + "flip_y", + "anchor" + ], + "short_name": "TextureAtlasSprite", + "title": "bevy_sprite::texture_atlas::TextureAtlasSprite", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_text::pipeline::TextLayoutInfo": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "glyphs": { + "type": { + "$ref": "#/$defs/alloc::vec::Vec" + } + }, + "logical_size": { + "type": { + "$ref": "#/$defs/glam::Vec2" + } + } + }, + "required": [ + "glyphs", + "logical_size" + ], + "short_name": "TextLayoutInfo", + "title": "bevy_text::pipeline::TextLayoutInfo", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_text::text2d::Text2dBounds": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "size": { + "type": { + "$ref": "#/$defs/glam::Vec2" + } + } + }, + "required": [ + "size" + ], + "short_name": "Text2dBounds", + "title": "bevy_text::text2d::Text2dBounds", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_text::text::BreakLineOn": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "WordBoundary", + "AnyCharacter", + "NoWrap" + ], + "short_name": "BreakLineOn", + "title": "bevy_text::text::BreakLineOn", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_text::text::Text": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "alignment": { + "type": { + "$ref": "#/$defs/bevy_text::text::TextAlignment" + } + }, + "linebreak_behavior": { + "type": { + "$ref": "#/$defs/bevy_text::text::BreakLineOn" + } + }, + "sections": { + "type": { + "$ref": "#/$defs/alloc::vec::Vec" + } + } + }, + "required": [ + "sections", + "alignment", + "linebreak_behavior" + ], + "short_name": "Text", + "title": "bevy_text::text::Text", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_text::text::TextAlignment": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "Left", + "Center", + "Right" + ], + "short_name": "TextAlignment", + "title": "bevy_text::text::TextAlignment", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_text::text::TextSection": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "style": { + "type": { + "$ref": "#/$defs/bevy_text::text::TextStyle" + } + }, + "value": { + "type": { + "$ref": "#/$defs/alloc::string::String" + } + } + }, + "required": [ + "value", + "style" + ], + "short_name": "TextSection", + "title": "bevy_text::text::TextSection", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_text::text::TextStyle": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "color": { + "type": { + "$ref": "#/$defs/bevy_render::color::Color" + } + }, + "font": { + "type": { + "$ref": "#/$defs/bevy_asset::handle::Handle" + } + }, + "font_size": { + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "font", + "font_size", + "color" + ], + "short_name": "TextStyle", + "title": "bevy_text::text::TextStyle", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_time::stopwatch::Stopwatch": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "elapsed": { + "type": { + "$ref": "#/$defs/bevy_utils::Duration" + } + }, + "paused": { + "type": { + "$ref": "#/$defs/bool" + } + } + }, + "required": [ + "elapsed", + "paused" + ], + "short_name": "Stopwatch", + "title": "bevy_time::stopwatch::Stopwatch", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_time::time::Time<()>": { + "additionalProperties": false, + "isComponent": false, + "isResource": true, + "properties": { + "context": { + "type": { + "$ref": "#/$defs/()" + } + }, + "delta": { + "type": { + "$ref": "#/$defs/bevy_utils::Duration" + } + }, + "delta_seconds": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "delta_seconds_f64": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "elapsed": { + "type": { + "$ref": "#/$defs/bevy_utils::Duration" + } + }, + "elapsed_seconds": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "elapsed_seconds_f64": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "elapsed_seconds_wrapped": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "elapsed_seconds_wrapped_f64": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "elapsed_wrapped": { + "type": { + "$ref": "#/$defs/bevy_utils::Duration" + } + }, + "wrap_period": { + "type": { + "$ref": "#/$defs/bevy_utils::Duration" + } + } + }, + "required": [ + "context", + "wrap_period", + "delta", + "delta_seconds", + "delta_seconds_f64", + "elapsed", + "elapsed_seconds", + "elapsed_seconds_f64", + "elapsed_wrapped", + "elapsed_seconds_wrapped", + "elapsed_seconds_wrapped_f64" + ], + "short_name": "Time<()>", + "title": "bevy_time::time::Time<()>", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_time::time::Time": { + "additionalProperties": false, + "isComponent": false, + "isResource": true, + "properties": { + "context": { + "type": { + "$ref": "#/$defs/bevy_time::fixed::Fixed" + } + }, + "delta": { + "type": { + "$ref": "#/$defs/bevy_utils::Duration" + } + }, + "delta_seconds": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "delta_seconds_f64": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "elapsed": { + "type": { + "$ref": "#/$defs/bevy_utils::Duration" + } + }, + "elapsed_seconds": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "elapsed_seconds_f64": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "elapsed_seconds_wrapped": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "elapsed_seconds_wrapped_f64": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "elapsed_wrapped": { + "type": { + "$ref": "#/$defs/bevy_utils::Duration" + } + }, + "wrap_period": { + "type": { + "$ref": "#/$defs/bevy_utils::Duration" + } + } + }, + "required": [ + "context", + "wrap_period", + "delta", + "delta_seconds", + "delta_seconds_f64", + "elapsed", + "elapsed_seconds", + "elapsed_seconds_f64", + "elapsed_wrapped", + "elapsed_seconds_wrapped", + "elapsed_seconds_wrapped_f64" + ], + "short_name": "Time", + "title": "bevy_time::time::Time", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_time::time::Time": { + "additionalProperties": false, + "isComponent": false, + "isResource": true, + "properties": { + "context": { + "type": { + "$ref": "#/$defs/bevy_time::real::Real" + } + }, + "delta": { + "type": { + "$ref": "#/$defs/bevy_utils::Duration" + } + }, + "delta_seconds": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "delta_seconds_f64": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "elapsed": { + "type": { + "$ref": "#/$defs/bevy_utils::Duration" + } + }, + "elapsed_seconds": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "elapsed_seconds_f64": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "elapsed_seconds_wrapped": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "elapsed_seconds_wrapped_f64": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "elapsed_wrapped": { + "type": { + "$ref": "#/$defs/bevy_utils::Duration" + } + }, + "wrap_period": { + "type": { + "$ref": "#/$defs/bevy_utils::Duration" + } + } + }, + "required": [ + "context", + "wrap_period", + "delta", + "delta_seconds", + "delta_seconds_f64", + "elapsed", + "elapsed_seconds", + "elapsed_seconds_f64", + "elapsed_wrapped", + "elapsed_seconds_wrapped", + "elapsed_seconds_wrapped_f64" + ], + "short_name": "Time", + "title": "bevy_time::time::Time", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_time::time::Time": { + "additionalProperties": false, + "isComponent": false, + "isResource": true, + "properties": { + "context": { + "type": { + "$ref": "#/$defs/bevy_time::virt::Virtual" + } + }, + "delta": { + "type": { + "$ref": "#/$defs/bevy_utils::Duration" + } + }, + "delta_seconds": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "delta_seconds_f64": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "elapsed": { + "type": { + "$ref": "#/$defs/bevy_utils::Duration" + } + }, + "elapsed_seconds": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "elapsed_seconds_f64": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "elapsed_seconds_wrapped": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "elapsed_seconds_wrapped_f64": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "elapsed_wrapped": { + "type": { + "$ref": "#/$defs/bevy_utils::Duration" + } + }, + "wrap_period": { + "type": { + "$ref": "#/$defs/bevy_utils::Duration" + } + } + }, + "required": [ + "context", + "wrap_period", + "delta", + "delta_seconds", + "delta_seconds_f64", + "elapsed", + "elapsed_seconds", + "elapsed_seconds_f64", + "elapsed_wrapped", + "elapsed_seconds_wrapped", + "elapsed_seconds_wrapped_f64" + ], + "short_name": "Time", + "title": "bevy_time::time::Time", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_time::timer::Timer": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "duration": { + "type": { + "$ref": "#/$defs/bevy_utils::Duration" + } + }, + "finished": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "mode": { + "type": { + "$ref": "#/$defs/bevy_time::timer::TimerMode" + } + }, + "stopwatch": { + "type": { + "$ref": "#/$defs/bevy_time::stopwatch::Stopwatch" + } + }, + "times_finished_this_tick": { + "type": { + "$ref": "#/$defs/u32" + } + } + }, + "required": [ + "stopwatch", + "duration", + "mode", + "finished", + "times_finished_this_tick" + ], + "short_name": "Timer", + "title": "bevy_time::timer::Timer", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_transform::components::global_transform::GlobalTransform": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/glam::Affine3A" + } + } + ], + "short_name": "GlobalTransform", + "title": "bevy_transform::components::global_transform::GlobalTransform", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_transform::components::transform::Transform": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "rotation": { + "type": { + "$ref": "#/$defs/glam::Quat" + } + }, + "scale": { + "type": { + "$ref": "#/$defs/glam::Vec3" + } + }, + "translation": { + "type": { + "$ref": "#/$defs/glam::Vec3" + } + } + }, + "required": [ + "translation", + "rotation", + "scale" + ], + "short_name": "Transform", + "title": "bevy_transform::components::transform::Transform", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_ui::UiScale": { + "isComponent": false, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f64" + } + } + ], + "short_name": "UiScale", + "title": "bevy_ui::UiScale", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_ui::camera_config::UiCameraConfig": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "show_ui": { + "type": { + "$ref": "#/$defs/bool" + } + } + }, + "required": [ + "show_ui" + ], + "short_name": "UiCameraConfig", + "title": "bevy_ui::camera_config::UiCameraConfig", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_ui::focus::FocusPolicy": { + "isComponent": true, + "isResource": false, + "oneOf": [ + "Block", + "Pass" + ], + "short_name": "FocusPolicy", + "title": "bevy_ui::focus::FocusPolicy", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_ui::focus::Interaction": { + "isComponent": true, + "isResource": false, + "oneOf": [ + "Pressed", + "Hovered", + "None" + ], + "short_name": "Interaction", + "title": "bevy_ui::focus::Interaction", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_ui::focus::RelativeCursorPosition": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "normalized": { + "type": { + "$ref": "#/$defs/core::option::Option" + } + }, + "normalized_visible_node_rect": { + "type": { + "$ref": "#/$defs/bevy_math::Rect" + } + } + }, + "required": [ + "normalized_visible_node_rect" + ], + "short_name": "RelativeCursorPosition", + "title": "bevy_ui::focus::RelativeCursorPosition", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_ui::geometry::UiRect": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "bottom": { + "type": { + "$ref": "#/$defs/bevy_ui::geometry::Val" + } + }, + "left": { + "type": { + "$ref": "#/$defs/bevy_ui::geometry::Val" + } + }, + "right": { + "type": { + "$ref": "#/$defs/bevy_ui::geometry::Val" + } + }, + "top": { + "type": { + "$ref": "#/$defs/bevy_ui::geometry::Val" + } + } + }, + "required": [ + "left", + "right", + "top", + "bottom" + ], + "short_name": "UiRect", + "title": "bevy_ui::geometry::UiRect", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_ui::geometry::Val": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "title": "Auto" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + } + ], + "short_name": "Px", + "title": "Px", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + } + ], + "short_name": "Percent", + "title": "Percent", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + } + ], + "short_name": "Vw", + "title": "Vw", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + } + ], + "short_name": "Vh", + "title": "Vh", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + } + ], + "short_name": "VMin", + "title": "VMin", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + } + ], + "short_name": "VMax", + "title": "VMax", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Val", + "title": "bevy_ui::geometry::Val", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_ui::measurement::ContentSize": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "ContentSize", + "title": "bevy_ui::measurement::ContentSize", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_ui::ui_node::AlignContent": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "Default", + "Start", + "End", + "FlexStart", + "FlexEnd", + "Center", + "Stretch", + "SpaceBetween", + "SpaceEvenly", + "SpaceAround" + ], + "short_name": "AlignContent", + "title": "bevy_ui::ui_node::AlignContent", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_ui::ui_node::AlignItems": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "Default", + "Start", + "End", + "FlexStart", + "FlexEnd", + "Center", + "Baseline", + "Stretch" + ], + "short_name": "AlignItems", + "title": "bevy_ui::ui_node::AlignItems", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_ui::ui_node::AlignSelf": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "Auto", + "Start", + "End", + "FlexStart", + "FlexEnd", + "Center", + "Baseline", + "Stretch" + ], + "short_name": "AlignSelf", + "title": "bevy_ui::ui_node::AlignSelf", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_ui::ui_node::BackgroundColor": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_render::color::Color" + } + } + ], + "short_name": "BackgroundColor", + "title": "bevy_ui::ui_node::BackgroundColor", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_ui::ui_node::BorderColor": { + "isComponent": true, + "isResource": false, + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_render::color::Color" + } + } + ], + "short_name": "BorderColor", + "title": "bevy_ui::ui_node::BorderColor", + "type": "array", + "typeInfo": "TupleStruct" + }, + "bevy_ui::ui_node::CalculatedClip": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "clip": { + "type": { + "$ref": "#/$defs/bevy_math::Rect" + } + } + }, + "required": [ + "clip" + ], + "short_name": "CalculatedClip", + "title": "bevy_ui::ui_node::CalculatedClip", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_ui::ui_node::Direction": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "Inherit", + "LeftToRight", + "RightToLeft" + ], + "short_name": "Direction", + "title": "bevy_ui::ui_node::Direction", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_ui::ui_node::Display": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "Flex", + "Grid", + "None" + ], + "short_name": "Display", + "title": "bevy_ui::ui_node::Display", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_ui::ui_node::FlexDirection": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "Row", + "Column", + "RowReverse", + "ColumnReverse" + ], + "short_name": "FlexDirection", + "title": "bevy_ui::ui_node::FlexDirection", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_ui::ui_node::FlexWrap": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "NoWrap", + "Wrap", + "WrapReverse" + ], + "short_name": "FlexWrap", + "title": "bevy_ui::ui_node::FlexWrap", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_ui::ui_node::GridAutoFlow": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "Row", + "Column", + "RowDense", + "ColumnDense" + ], + "short_name": "GridAutoFlow", + "title": "bevy_ui::ui_node::GridAutoFlow", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_ui::ui_node::GridPlacement": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "end": { + "type": { + "$ref": "#/$defs/core::option::Option" + } + }, + "span": { + "type": { + "$ref": "#/$defs/core::option::Option" + } + }, + "start": { + "type": { + "$ref": "#/$defs/core::option::Option" + } + } + }, + "required": [], + "short_name": "GridPlacement", + "title": "bevy_ui::ui_node::GridPlacement", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_ui::ui_node::GridTrack": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "max_sizing_function": { + "type": { + "$ref": "#/$defs/bevy_ui::ui_node::MaxTrackSizingFunction" + } + }, + "min_sizing_function": { + "type": { + "$ref": "#/$defs/bevy_ui::ui_node::MinTrackSizingFunction" + } + } + }, + "required": [ + "min_sizing_function", + "max_sizing_function" + ], + "short_name": "GridTrack", + "title": "bevy_ui::ui_node::GridTrack", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_ui::ui_node::JustifyContent": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "Default", + "Start", + "End", + "FlexStart", + "FlexEnd", + "Center", + "Stretch", + "SpaceBetween", + "SpaceEvenly", + "SpaceAround" + ], + "short_name": "JustifyContent", + "title": "bevy_ui::ui_node::JustifyContent", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_ui::ui_node::JustifyItems": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "Default", + "Start", + "End", + "Center", + "Baseline", + "Stretch" + ], + "short_name": "JustifyItems", + "title": "bevy_ui::ui_node::JustifyItems", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_ui::ui_node::JustifySelf": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "Auto", + "Start", + "End", + "Center", + "Baseline", + "Stretch" + ], + "short_name": "JustifySelf", + "title": "bevy_ui::ui_node::JustifySelf", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_ui::ui_node::Node": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "calculated_size": { + "type": { + "$ref": "#/$defs/glam::Vec2" + } + }, + "outline_offset": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "outline_width": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "stack_index": { + "type": { + "$ref": "#/$defs/u32" + } + }, + "unrounded_size": { + "type": { + "$ref": "#/$defs/glam::Vec2" + } + } + }, + "required": [ + "stack_index", + "calculated_size", + "outline_width", + "outline_offset", + "unrounded_size" + ], + "short_name": "Node", + "title": "bevy_ui::ui_node::Node", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_ui::ui_node::Outline": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "color": { + "type": { + "$ref": "#/$defs/bevy_render::color::Color" + } + }, + "offset": { + "type": { + "$ref": "#/$defs/bevy_ui::geometry::Val" + } + }, + "width": { + "type": { + "$ref": "#/$defs/bevy_ui::geometry::Val" + } + } + }, + "required": [ + "width", + "offset", + "color" + ], + "short_name": "Outline", + "title": "bevy_ui::ui_node::Outline", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_ui::ui_node::Overflow": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "x": { + "type": { + "$ref": "#/$defs/bevy_ui::ui_node::OverflowAxis" + } + }, + "y": { + "type": { + "$ref": "#/$defs/bevy_ui::ui_node::OverflowAxis" + } + } + }, + "required": [ + "x", + "y" + ], + "short_name": "Overflow", + "title": "bevy_ui::ui_node::Overflow", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_ui::ui_node::OverflowAxis": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "Visible", + "Clip" + ], + "short_name": "OverflowAxis", + "title": "bevy_ui::ui_node::OverflowAxis", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_ui::ui_node::PositionType": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "Relative", + "Absolute" + ], + "short_name": "PositionType", + "title": "bevy_ui::ui_node::PositionType", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_ui::ui_node::RepeatedGridTrack": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "repetition": { + "type": { + "$ref": "#/$defs/bevy_ui::ui_node::GridTrackRepetition" + } + }, + "tracks": { + "type": { + "$ref": "#/$defs/smallvec::SmallVec<[bevy_ui::ui_node::GridTrack; 1]>" + } + } + }, + "required": [ + "repetition", + "tracks" + ], + "short_name": "RepeatedGridTrack", + "title": "bevy_ui::ui_node::RepeatedGridTrack", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_ui::ui_node::Style": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "align_content": { + "type": { + "$ref": "#/$defs/bevy_ui::ui_node::AlignContent" + } + }, + "align_items": { + "type": { + "$ref": "#/$defs/bevy_ui::ui_node::AlignItems" + } + }, + "align_self": { + "type": { + "$ref": "#/$defs/bevy_ui::ui_node::AlignSelf" + } + }, + "aspect_ratio": { + "type": { + "$ref": "#/$defs/core::option::Option" + } + }, + "border": { + "type": { + "$ref": "#/$defs/bevy_ui::geometry::UiRect" + } + }, + "bottom": { + "type": { + "$ref": "#/$defs/bevy_ui::geometry::Val" + } + }, + "column_gap": { + "type": { + "$ref": "#/$defs/bevy_ui::geometry::Val" + } + }, + "direction": { + "type": { + "$ref": "#/$defs/bevy_ui::ui_node::Direction" + } + }, + "display": { + "type": { + "$ref": "#/$defs/bevy_ui::ui_node::Display" + } + }, + "flex_basis": { + "type": { + "$ref": "#/$defs/bevy_ui::geometry::Val" + } + }, + "flex_direction": { + "type": { + "$ref": "#/$defs/bevy_ui::ui_node::FlexDirection" + } + }, + "flex_grow": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "flex_shrink": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "flex_wrap": { + "type": { + "$ref": "#/$defs/bevy_ui::ui_node::FlexWrap" + } + }, + "grid_auto_columns": { + "type": { + "$ref": "#/$defs/alloc::vec::Vec" + } + }, + "grid_auto_flow": { + "type": { + "$ref": "#/$defs/bevy_ui::ui_node::GridAutoFlow" + } + }, + "grid_auto_rows": { + "type": { + "$ref": "#/$defs/alloc::vec::Vec" + } + }, + "grid_column": { + "type": { + "$ref": "#/$defs/bevy_ui::ui_node::GridPlacement" + } + }, + "grid_row": { + "type": { + "$ref": "#/$defs/bevy_ui::ui_node::GridPlacement" + } + }, + "grid_template_columns": { + "type": { + "$ref": "#/$defs/alloc::vec::Vec" + } + }, + "grid_template_rows": { + "type": { + "$ref": "#/$defs/alloc::vec::Vec" + } + }, + "height": { + "type": { + "$ref": "#/$defs/bevy_ui::geometry::Val" + } + }, + "justify_content": { + "type": { + "$ref": "#/$defs/bevy_ui::ui_node::JustifyContent" + } + }, + "justify_items": { + "type": { + "$ref": "#/$defs/bevy_ui::ui_node::JustifyItems" + } + }, + "justify_self": { + "type": { + "$ref": "#/$defs/bevy_ui::ui_node::JustifySelf" + } + }, + "left": { + "type": { + "$ref": "#/$defs/bevy_ui::geometry::Val" + } + }, + "margin": { + "type": { + "$ref": "#/$defs/bevy_ui::geometry::UiRect" + } + }, + "max_height": { + "type": { + "$ref": "#/$defs/bevy_ui::geometry::Val" + } + }, + "max_width": { + "type": { + "$ref": "#/$defs/bevy_ui::geometry::Val" + } + }, + "min_height": { + "type": { + "$ref": "#/$defs/bevy_ui::geometry::Val" + } + }, + "min_width": { + "type": { + "$ref": "#/$defs/bevy_ui::geometry::Val" + } + }, + "overflow": { + "type": { + "$ref": "#/$defs/bevy_ui::ui_node::Overflow" + } + }, + "padding": { + "type": { + "$ref": "#/$defs/bevy_ui::geometry::UiRect" + } + }, + "position_type": { + "type": { + "$ref": "#/$defs/bevy_ui::ui_node::PositionType" + } + }, + "right": { + "type": { + "$ref": "#/$defs/bevy_ui::geometry::Val" + } + }, + "row_gap": { + "type": { + "$ref": "#/$defs/bevy_ui::geometry::Val" + } + }, + "top": { + "type": { + "$ref": "#/$defs/bevy_ui::geometry::Val" + } + }, + "width": { + "type": { + "$ref": "#/$defs/bevy_ui::geometry::Val" + } + } + }, + "required": [ + "display", + "position_type", + "overflow", + "direction", + "left", + "right", + "top", + "bottom", + "width", + "height", + "min_width", + "min_height", + "max_width", + "max_height", + "align_items", + "justify_items", + "align_self", + "justify_self", + "align_content", + "justify_content", + "margin", + "padding", + "border", + "flex_direction", + "flex_wrap", + "flex_grow", + "flex_shrink", + "flex_basis", + "row_gap", + "column_gap", + "grid_auto_flow", + "grid_template_rows", + "grid_template_columns", + "grid_auto_rows", + "grid_auto_columns", + "grid_row", + "grid_column" + ], + "short_name": "Style", + "title": "bevy_ui::ui_node::Style", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_ui::ui_node::UiImage": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "flip_x": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "flip_y": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "texture": { + "type": { + "$ref": "#/$defs/bevy_asset::handle::Handle" + } + } + }, + "required": [ + "texture", + "flip_x", + "flip_y" + ], + "short_name": "UiImage", + "title": "bevy_ui::ui_node::UiImage", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_ui::ui_node::UiTextureAtlasImage": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "flip_x": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "flip_y": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "index": { + "type": { + "$ref": "#/$defs/usize" + } + } + }, + "required": [ + "index", + "flip_x", + "flip_y" + ], + "short_name": "UiTextureAtlasImage", + "title": "bevy_ui::ui_node::UiTextureAtlasImage", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_ui::ui_node::ZIndex": { + "isComponent": true, + "isResource": false, + "oneOf": [ + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/i32" + } + } + ], + "short_name": "Local", + "title": "Local", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/i32" + } + } + ], + "short_name": "Global", + "title": "Global", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "ZIndex", + "title": "bevy_ui::ui_node::ZIndex", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_ui::widget::button::Button": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "Button", + "title": "bevy_ui::widget::button::Button", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_ui::widget::image::UiImageSize": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "size": { + "type": { + "$ref": "#/$defs/glam::Vec2" + } + } + }, + "required": [ + "size" + ], + "short_name": "UiImageSize", + "title": "bevy_ui::widget::image::UiImageSize", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_ui::widget::label::Label": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "Label", + "title": "bevy_ui::widget::label::Label", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_ui::widget::text::TextFlags": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "needs_new_measure_func": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "needs_recompute": { + "type": { + "$ref": "#/$defs/bool" + } + } + }, + "required": [ + "needs_new_measure_func", + "needs_recompute" + ], + "short_name": "TextFlags", + "title": "bevy_ui::widget::text::TextFlags", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_utils::Duration": { + "isComponent": false, + "isResource": false, + "short_name": "Duration", + "title": "bevy_utils::Duration", + "type": "object", + "typeInfo": "Value" + }, + "bevy_utils::HashSet": { + "isComponent": false, + "isResource": false, + "short_name": "HashSet", + "title": "bevy_utils::HashSet", + "type": "object", + "typeInfo": "Value" + }, + "bevy_utils::Instant": { + "isComponent": false, + "isResource": false, + "short_name": "Instant", + "title": "bevy_utils::Instant", + "type": "object", + "typeInfo": "Value" + }, + "bevy_utils::Uuid": { + "isComponent": false, + "isResource": false, + "short_name": "Uuid", + "title": "bevy_utils::Uuid", + "type": "object", + "typeInfo": "Value" + }, + "bevy_window::cursor::CursorIcon": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "Default", + "Crosshair", + "Hand", + "Arrow", + "Move", + "Text", + "Wait", + "Help", + "Progress", + "NotAllowed", + "ContextMenu", + "Cell", + "VerticalText", + "Alias", + "Copy", + "NoDrop", + "Grab", + "Grabbing", + "AllScroll", + "ZoomIn", + "ZoomOut", + "EResize", + "NResize", + "NeResize", + "NwResize", + "SResize", + "SeResize", + "SwResize", + "WResize", + "EwResize", + "NsResize", + "NeswResize", + "NwseResize", + "ColResize", + "RowResize" + ], + "short_name": "CursorIcon", + "title": "bevy_window::cursor::CursorIcon", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_window::event::ApplicationLifetime": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "Started", + "Suspended", + "Resumed" + ], + "short_name": "ApplicationLifetime", + "title": "bevy_window::event::ApplicationLifetime", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_window::event::CursorEntered": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "window": { + "type": { + "$ref": "#/$defs/bevy_ecs::Entity" + } + } + }, + "required": [ + "window" + ], + "short_name": "CursorEntered", + "title": "bevy_window::event::CursorEntered", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_window::event::CursorLeft": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "window": { + "type": { + "$ref": "#/$defs/bevy_ecs::Entity" + } + } + }, + "required": [ + "window" + ], + "short_name": "CursorLeft", + "title": "bevy_window::event::CursorLeft", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_window::event::CursorMoved": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "position": { + "type": { + "$ref": "#/$defs/glam::Vec2" + } + }, + "window": { + "type": { + "$ref": "#/$defs/bevy_ecs::Entity" + } + } + }, + "required": [ + "window", + "position" + ], + "short_name": "CursorMoved", + "title": "bevy_window::event::CursorMoved", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_window::event::FileDragAndDrop": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "additionalProperties": false, + "properties": { + "path_buf": { + "title": "path_buf", + "type": { + "$ref": "#/$defs/std::path::PathBuf" + } + }, + "window": { + "title": "window", + "type": { + "$ref": "#/$defs/bevy_ecs::Entity" + } + } + }, + "required": [ + "window", + "path_buf" + ], + "short_name": "DroppedFile", + "title": "DroppedFile", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "path_buf": { + "title": "path_buf", + "type": { + "$ref": "#/$defs/std::path::PathBuf" + } + }, + "window": { + "title": "window", + "type": { + "$ref": "#/$defs/bevy_ecs::Entity" + } + } + }, + "required": [ + "window", + "path_buf" + ], + "short_name": "HoveredFile", + "title": "HoveredFile", + "type": "object", + "typeInfo": "Struct" + }, + { + "additionalProperties": false, + "properties": { + "window": { + "title": "window", + "type": { + "$ref": "#/$defs/bevy_ecs::Entity" + } + } + }, + "required": [ + "window" + ], + "short_name": "HoveredFileCanceled", + "title": "HoveredFileCanceled", + "type": "object", + "typeInfo": "Struct" + } + ], + "short_name": "FileDragAndDrop", + "title": "bevy_window::event::FileDragAndDrop", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_window::event::ReceivedCharacter": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "char": { + "type": { + "$ref": "#/$defs/char" + } + }, + "window": { + "type": { + "$ref": "#/$defs/bevy_ecs::Entity" + } + } + }, + "required": [ + "window", + "char" + ], + "short_name": "ReceivedCharacter", + "title": "bevy_window::event::ReceivedCharacter", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_window::event::RequestRedraw": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "RequestRedraw", + "title": "bevy_window::event::RequestRedraw", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_window::event::WindowBackendScaleFactorChanged": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "scale_factor": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "window": { + "type": { + "$ref": "#/$defs/bevy_ecs::Entity" + } + } + }, + "required": [ + "window", + "scale_factor" + ], + "short_name": "WindowBackendScaleFactorChanged", + "title": "bevy_window::event::WindowBackendScaleFactorChanged", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_window::event::WindowCloseRequested": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "window": { + "type": { + "$ref": "#/$defs/bevy_ecs::Entity" + } + } + }, + "required": [ + "window" + ], + "short_name": "WindowCloseRequested", + "title": "bevy_window::event::WindowCloseRequested", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_window::event::WindowClosed": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "window": { + "type": { + "$ref": "#/$defs/bevy_ecs::Entity" + } + } + }, + "required": [ + "window" + ], + "short_name": "WindowClosed", + "title": "bevy_window::event::WindowClosed", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_window::event::WindowCreated": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "window": { + "type": { + "$ref": "#/$defs/bevy_ecs::Entity" + } + } + }, + "required": [ + "window" + ], + "short_name": "WindowCreated", + "title": "bevy_window::event::WindowCreated", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_window::event::WindowFocused": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "focused": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "window": { + "type": { + "$ref": "#/$defs/bevy_ecs::Entity" + } + } + }, + "required": [ + "window", + "focused" + ], + "short_name": "WindowFocused", + "title": "bevy_window::event::WindowFocused", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_window::event::WindowMoved": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "entity": { + "type": { + "$ref": "#/$defs/bevy_ecs::Entity" + } + }, + "position": { + "type": { + "$ref": "#/$defs/glam::IVec2" + } + } + }, + "required": [ + "entity", + "position" + ], + "short_name": "WindowMoved", + "title": "bevy_window::event::WindowMoved", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_window::event::WindowResized": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "height": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "width": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "window": { + "type": { + "$ref": "#/$defs/bevy_ecs::Entity" + } + } + }, + "required": [ + "window", + "width", + "height" + ], + "short_name": "WindowResized", + "title": "bevy_window::event::WindowResized", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_window::event::WindowScaleFactorChanged": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "scale_factor": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "window": { + "type": { + "$ref": "#/$defs/bevy_ecs::Entity" + } + } + }, + "required": [ + "window", + "scale_factor" + ], + "short_name": "WindowScaleFactorChanged", + "title": "bevy_window::event::WindowScaleFactorChanged", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_window::event::WindowThemeChanged": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "theme": { + "type": { + "$ref": "#/$defs/bevy_window::window::WindowTheme" + } + }, + "window": { + "type": { + "$ref": "#/$defs/bevy_ecs::Entity" + } + } + }, + "required": [ + "window", + "theme" + ], + "short_name": "WindowThemeChanged", + "title": "bevy_window::event::WindowThemeChanged", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_window::window::CompositeAlphaMode": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "Auto", + "Opaque", + "PreMultiplied", + "PostMultiplied", + "Inherit" + ], + "short_name": "CompositeAlphaMode", + "title": "bevy_window::window::CompositeAlphaMode", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_window::window::Cursor": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "grab_mode": { + "type": { + "$ref": "#/$defs/bevy_window::window::CursorGrabMode" + } + }, + "hit_test": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "icon": { + "type": { + "$ref": "#/$defs/bevy_window::cursor::CursorIcon" + } + }, + "visible": { + "type": { + "$ref": "#/$defs/bool" + } + } + }, + "required": [ + "icon", + "visible", + "grab_mode", + "hit_test" + ], + "short_name": "Cursor", + "title": "bevy_window::window::Cursor", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_window::window::CursorGrabMode": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "None", + "Confined", + "Locked" + ], + "short_name": "CursorGrabMode", + "title": "bevy_window::window::CursorGrabMode", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_window::window::EnabledButtons": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "close": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "maximize": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "minimize": { + "type": { + "$ref": "#/$defs/bool" + } + } + }, + "required": [ + "minimize", + "maximize", + "close" + ], + "short_name": "EnabledButtons", + "title": "bevy_window::window::EnabledButtons", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_window::window::InternalWindowState": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "maximize_request": { + "type": { + "$ref": "#/$defs/core::option::Option" + } + }, + "minimize_request": { + "type": { + "$ref": "#/$defs/core::option::Option" + } + }, + "physical_cursor_position": { + "type": { + "$ref": "#/$defs/core::option::Option" + } + } + }, + "required": [], + "short_name": "InternalWindowState", + "title": "bevy_window::window::InternalWindowState", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_window::window::MonitorSelection": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "title": "Current" + }, + { + "title": "Primary" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/usize" + } + } + ], + "short_name": "Index", + "title": "Index", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "MonitorSelection", + "title": "bevy_window::window::MonitorSelection", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_window::window::PresentMode": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "AutoVsync", + "AutoNoVsync", + "Fifo", + "FifoRelaxed", + "Immediate", + "Mailbox" + ], + "short_name": "PresentMode", + "title": "bevy_window::window::PresentMode", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_window::window::PrimaryWindow": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": {}, + "required": [], + "short_name": "PrimaryWindow", + "title": "bevy_window::window::PrimaryWindow", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_window::window::Window": { + "additionalProperties": false, + "isComponent": true, + "isResource": false, + "properties": { + "canvas": { + "type": { + "$ref": "#/$defs/core::option::Option" + } + }, + "composite_alpha_mode": { + "type": { + "$ref": "#/$defs/bevy_window::window::CompositeAlphaMode" + } + }, + "cursor": { + "type": { + "$ref": "#/$defs/bevy_window::window::Cursor" + } + }, + "decorations": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "enabled_buttons": { + "type": { + "$ref": "#/$defs/bevy_window::window::EnabledButtons" + } + }, + "fit_canvas_to_parent": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "focused": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "ime_enabled": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "ime_position": { + "type": { + "$ref": "#/$defs/glam::Vec2" + } + }, + "internal": { + "type": { + "$ref": "#/$defs/bevy_window::window::InternalWindowState" + } + }, + "mode": { + "type": { + "$ref": "#/$defs/bevy_window::window::WindowMode" + } + }, + "position": { + "type": { + "$ref": "#/$defs/bevy_window::window::WindowPosition" + } + }, + "present_mode": { + "type": { + "$ref": "#/$defs/bevy_window::window::PresentMode" + } + }, + "prevent_default_event_handling": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "resizable": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "resize_constraints": { + "type": { + "$ref": "#/$defs/bevy_window::window::WindowResizeConstraints" + } + }, + "resolution": { + "type": { + "$ref": "#/$defs/bevy_window::window::WindowResolution" + } + }, + "title": { + "type": { + "$ref": "#/$defs/alloc::string::String" + } + }, + "transparent": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "visible": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "window_level": { + "type": { + "$ref": "#/$defs/bevy_window::window::WindowLevel" + } + }, + "window_theme": { + "type": { + "$ref": "#/$defs/core::option::Option" + } + } + }, + "required": [ + "cursor", + "present_mode", + "mode", + "position", + "resolution", + "title", + "composite_alpha_mode", + "resize_constraints", + "resizable", + "enabled_buttons", + "decorations", + "transparent", + "focused", + "window_level", + "fit_canvas_to_parent", + "prevent_default_event_handling", + "internal", + "ime_enabled", + "ime_position", + "visible" + ], + "short_name": "Window", + "title": "bevy_window::window::Window", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_window::window::WindowLevel": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "AlwaysOnBottom", + "Normal", + "AlwaysOnTop" + ], + "short_name": "WindowLevel", + "title": "bevy_window::window::WindowLevel", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_window::window::WindowMode": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "Windowed", + "BorderlessFullscreen", + "SizedFullscreen", + "Fullscreen" + ], + "short_name": "WindowMode", + "title": "bevy_window::window::WindowMode", + "type": "string", + "typeInfo": "Enum" + }, + "bevy_window::window::WindowPosition": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "title": "Automatic" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_window::window::MonitorSelection" + } + } + ], + "short_name": "Centered", + "title": "Centered", + "type": "array", + "typeInfo": "Tuple" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/glam::IVec2" + } + } + ], + "short_name": "At", + "title": "At", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "WindowPosition", + "title": "bevy_window::window::WindowPosition", + "type": "object", + "typeInfo": "Enum" + }, + "bevy_window::window::WindowResizeConstraints": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "max_height": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "max_width": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "min_height": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "min_width": { + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "min_width", + "min_height", + "max_width", + "max_height" + ], + "short_name": "WindowResizeConstraints", + "title": "bevy_window::window::WindowResizeConstraints", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_window::window::WindowResolution": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "physical_height": { + "type": { + "$ref": "#/$defs/u32" + } + }, + "physical_width": { + "type": { + "$ref": "#/$defs/u32" + } + }, + "scale_factor": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "scale_factor_override": { + "type": { + "$ref": "#/$defs/core::option::Option" + } + } + }, + "required": [ + "physical_width", + "physical_height", + "scale_factor" + ], + "short_name": "WindowResolution", + "title": "bevy_window::window::WindowResolution", + "type": "object", + "typeInfo": "Struct" + }, + "bevy_window::window::WindowTheme": { + "isComponent": false, + "isResource": false, + "oneOf": [ + "Light", + "Dark" + ], + "short_name": "WindowTheme", + "title": "bevy_window::window::WindowTheme", + "type": "string", + "typeInfo": "Enum" + }, + "bool": { + "isComponent": false, + "isResource": false, + "short_name": "bool", + "title": "bool", + "type": "boolean", + "typeInfo": "Value" + }, + "char": { + "isComponent": false, + "isResource": false, + "short_name": "char", + "title": "char", + "type": "string", + "typeInfo": "Value" + }, + "core::ops::Range": { + "isComponent": false, + "isResource": false, + "short_name": "Range", + "title": "core::ops::Range", + "type": "object", + "typeInfo": "Value" + }, + "core::option::Option": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "title": "None" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/alloc::string::String" + } + } + ], + "short_name": "Some", + "title": "Some", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Option", + "title": "core::option::Option", + "type": "object", + "typeInfo": "Enum" + }, + "core::option::Option>": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "title": "None" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/alloc::vec::Vec" + } + } + ], + "short_name": "Some", + "title": "Some", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Option>", + "title": "core::option::Option>", + "type": "object", + "typeInfo": "Enum" + }, + "core::option::Option>": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "title": "None" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_asset::handle::Handle" + } + } + ], + "short_name": "Some", + "title": "Some", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Option>", + "title": "core::option::Option>", + "type": "object", + "typeInfo": "Enum" + }, + "core::option::Option": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "title": "None" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_render::camera::camera::Viewport" + } + } + ], + "short_name": "Some", + "title": "Some", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Option", + "title": "core::option::Option", + "type": "object", + "typeInfo": "Enum" + }, + "core::option::Option": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "title": "None" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bevy_render::mesh::mesh::Indices" + } + } + ], + "short_name": "Some", + "title": "Some", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Option", + "title": "core::option::Option", + "type": "object", + "typeInfo": "Enum" + }, + "core::option::Option": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "title": "None" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/bool" + } + } + ], + "short_name": "Some", + "title": "Some", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Option", + "title": "core::option::Option", + "type": "object", + "typeInfo": "Enum" + }, + "core::option::Option": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "title": "None" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f32" + } + } + ], + "short_name": "Some", + "title": "Some", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Option", + "title": "core::option::Option", + "type": "object", + "typeInfo": "Enum" + }, + "core::option::Option": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "title": "None" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/f64" + } + } + ], + "short_name": "Some", + "title": "Some", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Option", + "title": "core::option::Option", + "type": "object", + "typeInfo": "Enum" + }, + "core::option::Option": { + "isComponent": false, + "isResource": false, + "oneOf": [ + { + "title": "None" + }, + { + "items": false, + "prefixItems": [ + { + "type": { + "$ref": "#/$defs/glam::DVec2" + } + } + ], + "short_name": "Some", + "title": "Some", + "type": "array", + "typeInfo": "Tuple" + } + ], + "short_name": "Option", + "title": "core::option::Option", + "type": "object", + "typeInfo": "Enum" + }, + "f32": { + "isComponent": false, + "isResource": false, + "short_name": "f32", + "title": "f32", + "type": "float", + "typeInfo": "Value" + }, + "f64": { + "isComponent": false, + "isResource": false, + "short_name": "f64", + "title": "f64", + "type": "float", + "typeInfo": "Value" + }, + "glam::Affine2": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "matrix2": { + "type": { + "$ref": "#/$defs/glam::Mat2" + } + }, + "translation": { + "type": { + "$ref": "#/$defs/glam::Vec2" + } + } + }, + "required": [ + "matrix2", + "translation" + ], + "short_name": "Affine2", + "title": "glam::Affine2", + "type": "object", + "typeInfo": "Struct" + }, + "glam::Affine3A": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "matrix3": { + "type": { + "$ref": "#/$defs/glam::Mat3A" + } + }, + "translation": { + "type": { + "$ref": "#/$defs/glam::Vec3A" + } + } + }, + "required": [ + "matrix3", + "translation" + ], + "short_name": "Affine3A", + "title": "glam::Affine3A", + "type": "object", + "typeInfo": "Struct" + }, + "glam::BVec2": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "x": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "y": { + "type": { + "$ref": "#/$defs/bool" + } + } + }, + "required": [ + "x", + "y" + ], + "short_name": "BVec2", + "title": "glam::BVec2", + "type": "object", + "typeInfo": "Struct" + }, + "glam::BVec3": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "x": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "y": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "z": { + "type": { + "$ref": "#/$defs/bool" + } + } + }, + "required": [ + "x", + "y", + "z" + ], + "short_name": "BVec3", + "title": "glam::BVec3", + "type": "object", + "typeInfo": "Struct" + }, + "glam::BVec3A": { + "isComponent": false, + "isResource": false, + "short_name": "BVec3A", + "title": "glam::BVec3A", + "type": "object", + "typeInfo": "Value" + }, + "glam::BVec4": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "w": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "x": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "y": { + "type": { + "$ref": "#/$defs/bool" + } + }, + "z": { + "type": { + "$ref": "#/$defs/bool" + } + } + }, + "required": [ + "x", + "y", + "z", + "w" + ], + "short_name": "BVec4", + "title": "glam::BVec4", + "type": "object", + "typeInfo": "Struct" + }, + "glam::BVec4A": { + "isComponent": false, + "isResource": false, + "short_name": "BVec4A", + "title": "glam::BVec4A", + "type": "object", + "typeInfo": "Value" + }, + "glam::DAffine2": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "matrix2": { + "type": { + "$ref": "#/$defs/glam::DMat2" + } + }, + "translation": { + "type": { + "$ref": "#/$defs/glam::DVec2" + } + } + }, + "required": [ + "matrix2", + "translation" + ], + "short_name": "DAffine2", + "title": "glam::DAffine2", + "type": "object", + "typeInfo": "Struct" + }, + "glam::DAffine3": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "matrix3": { + "type": { + "$ref": "#/$defs/glam::DMat3" + } + }, + "translation": { + "type": { + "$ref": "#/$defs/glam::DVec3" + } + } + }, + "required": [ + "matrix3", + "translation" + ], + "short_name": "DAffine3", + "title": "glam::DAffine3", + "type": "object", + "typeInfo": "Struct" + }, + "glam::DMat2": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "x_axis": { + "type": { + "$ref": "#/$defs/glam::DVec2" + } + }, + "y_axis": { + "type": { + "$ref": "#/$defs/glam::DVec2" + } + } + }, + "required": [ + "x_axis", + "y_axis" + ], + "short_name": "DMat2", + "title": "glam::DMat2", + "type": "object", + "typeInfo": "Struct" + }, + "glam::DMat3": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "x_axis": { + "type": { + "$ref": "#/$defs/glam::DVec3" + } + }, + "y_axis": { + "type": { + "$ref": "#/$defs/glam::DVec3" + } + }, + "z_axis": { + "type": { + "$ref": "#/$defs/glam::DVec3" + } + } + }, + "required": [ + "x_axis", + "y_axis", + "z_axis" + ], + "short_name": "DMat3", + "title": "glam::DMat3", + "type": "object", + "typeInfo": "Struct" + }, + "glam::DMat4": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "w_axis": { + "type": { + "$ref": "#/$defs/glam::DVec4" + } + }, + "x_axis": { + "type": { + "$ref": "#/$defs/glam::DVec4" + } + }, + "y_axis": { + "type": { + "$ref": "#/$defs/glam::DVec4" + } + }, + "z_axis": { + "type": { + "$ref": "#/$defs/glam::DVec4" + } + } + }, + "required": [ + "x_axis", + "y_axis", + "z_axis", + "w_axis" + ], + "short_name": "DMat4", + "title": "glam::DMat4", + "type": "object", + "typeInfo": "Struct" + }, + "glam::DQuat": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "w": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "x": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "y": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "z": { + "type": { + "$ref": "#/$defs/f64" + } + } + }, + "required": [ + "x", + "y", + "z", + "w" + ], + "short_name": "DQuat", + "title": "glam::DQuat", + "type": "object", + "typeInfo": "Struct" + }, + "glam::DVec2": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "x": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "y": { + "type": { + "$ref": "#/$defs/f64" + } + } + }, + "required": [ + "x", + "y" + ], + "short_name": "DVec2", + "title": "glam::DVec2", + "type": "object", + "typeInfo": "Struct" + }, + "glam::DVec3": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "x": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "y": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "z": { + "type": { + "$ref": "#/$defs/f64" + } + } + }, + "required": [ + "x", + "y", + "z" + ], + "short_name": "DVec3", + "title": "glam::DVec3", + "type": "object", + "typeInfo": "Struct" + }, + "glam::DVec4": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "w": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "x": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "y": { + "type": { + "$ref": "#/$defs/f64" + } + }, + "z": { + "type": { + "$ref": "#/$defs/f64" + } + } + }, + "required": [ + "x", + "y", + "z", + "w" + ], + "short_name": "DVec4", + "title": "glam::DVec4", + "type": "object", + "typeInfo": "Struct" + }, + "glam::IVec2": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "x": { + "type": { + "$ref": "#/$defs/i32" + } + }, + "y": { + "type": { + "$ref": "#/$defs/i32" + } + } + }, + "required": [ + "x", + "y" + ], + "short_name": "IVec2", + "title": "glam::IVec2", + "type": "object", + "typeInfo": "Struct" + }, + "glam::IVec3": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "x": { + "type": { + "$ref": "#/$defs/i32" + } + }, + "y": { + "type": { + "$ref": "#/$defs/i32" + } + }, + "z": { + "type": { + "$ref": "#/$defs/i32" + } + } + }, + "required": [ + "x", + "y", + "z" + ], + "short_name": "IVec3", + "title": "glam::IVec3", + "type": "object", + "typeInfo": "Struct" + }, + "glam::IVec4": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "w": { + "type": { + "$ref": "#/$defs/i32" + } + }, + "x": { + "type": { + "$ref": "#/$defs/i32" + } + }, + "y": { + "type": { + "$ref": "#/$defs/i32" + } + }, + "z": { + "type": { + "$ref": "#/$defs/i32" + } + } + }, + "required": [ + "x", + "y", + "z", + "w" + ], + "short_name": "IVec4", + "title": "glam::IVec4", + "type": "object", + "typeInfo": "Struct" + }, + "glam::Mat2": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "x_axis": { + "type": { + "$ref": "#/$defs/glam::Vec2" + } + }, + "y_axis": { + "type": { + "$ref": "#/$defs/glam::Vec2" + } + } + }, + "required": [ + "x_axis", + "y_axis" + ], + "short_name": "Mat2", + "title": "glam::Mat2", + "type": "object", + "typeInfo": "Struct" + }, + "glam::Mat3": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "x_axis": { + "type": { + "$ref": "#/$defs/glam::Vec3" + } + }, + "y_axis": { + "type": { + "$ref": "#/$defs/glam::Vec3" + } + }, + "z_axis": { + "type": { + "$ref": "#/$defs/glam::Vec3" + } + } + }, + "required": [ + "x_axis", + "y_axis", + "z_axis" + ], + "short_name": "Mat3", + "title": "glam::Mat3", + "type": "object", + "typeInfo": "Struct" + }, + "glam::Mat3A": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "x_axis": { + "type": { + "$ref": "#/$defs/glam::Vec3A" + } + }, + "y_axis": { + "type": { + "$ref": "#/$defs/glam::Vec3A" + } + }, + "z_axis": { + "type": { + "$ref": "#/$defs/glam::Vec3A" + } + } + }, + "required": [ + "x_axis", + "y_axis", + "z_axis" + ], + "short_name": "Mat3A", + "title": "glam::Mat3A", + "type": "object", + "typeInfo": "Struct" + }, + "glam::Mat4": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "w_axis": { + "type": { + "$ref": "#/$defs/glam::Vec4" + } + }, + "x_axis": { + "type": { + "$ref": "#/$defs/glam::Vec4" + } + }, + "y_axis": { + "type": { + "$ref": "#/$defs/glam::Vec4" + } + }, + "z_axis": { + "type": { + "$ref": "#/$defs/glam::Vec4" + } + } + }, + "required": [ + "x_axis", + "y_axis", + "z_axis", + "w_axis" + ], + "short_name": "Mat4", + "title": "glam::Mat4", + "type": "object", + "typeInfo": "Struct" + }, + "glam::Quat": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "w": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "x": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "y": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "z": { + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "x", + "y", + "z", + "w" + ], + "short_name": "Quat", + "title": "glam::Quat", + "type": "object", + "typeInfo": "Struct" + }, + "glam::UVec2": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "x": { + "type": { + "$ref": "#/$defs/u32" + } + }, + "y": { + "type": { + "$ref": "#/$defs/u32" + } + } + }, + "required": [ + "x", + "y" + ], + "short_name": "UVec2", + "title": "glam::UVec2", + "type": "object", + "typeInfo": "Struct" + }, + "glam::UVec3": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "x": { + "type": { + "$ref": "#/$defs/u32" + } + }, + "y": { + "type": { + "$ref": "#/$defs/u32" + } + }, + "z": { + "type": { + "$ref": "#/$defs/u32" + } + } + }, + "required": [ + "x", + "y", + "z" + ], + "short_name": "UVec3", + "title": "glam::UVec3", + "type": "object", + "typeInfo": "Struct" + }, + "glam::UVec4": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "w": { + "type": { + "$ref": "#/$defs/u32" + } + }, + "x": { + "type": { + "$ref": "#/$defs/u32" + } + }, + "y": { + "type": { + "$ref": "#/$defs/u32" + } + }, + "z": { + "type": { + "$ref": "#/$defs/u32" + } + } + }, + "required": [ + "x", + "y", + "z", + "w" + ], + "short_name": "UVec4", + "title": "glam::UVec4", + "type": "object", + "typeInfo": "Struct" + }, + "glam::Vec2": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "x": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "y": { + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "x", + "y" + ], + "short_name": "Vec2", + "title": "glam::Vec2", + "type": "object", + "typeInfo": "Struct" + }, + "glam::Vec3": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "x": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "y": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "z": { + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "x", + "y", + "z" + ], + "short_name": "Vec3", + "title": "glam::Vec3", + "type": "object", + "typeInfo": "Struct" + }, + "glam::Vec3A": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "x": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "y": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "z": { + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "x", + "y", + "z" + ], + "short_name": "Vec3A", + "title": "glam::Vec3A", + "type": "object", + "typeInfo": "Struct" + }, + "glam::Vec4": { + "additionalProperties": false, + "isComponent": false, + "isResource": false, + "properties": { + "w": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "x": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "y": { + "type": { + "$ref": "#/$defs/f32" + } + }, + "z": { + "type": { + "$ref": "#/$defs/f32" + } + } + }, + "required": [ + "x", + "y", + "z", + "w" + ], + "short_name": "Vec4", + "title": "glam::Vec4", + "type": "object", + "typeInfo": "Struct" + }, + "i128": { + "isComponent": false, + "isResource": false, + "short_name": "i128", + "title": "i128", + "type": "int", + "typeInfo": "Value" + }, + "i16": { + "isComponent": false, + "isResource": false, + "short_name": "i16", + "title": "i16", + "type": "int", + "typeInfo": "Value" + }, + "i32": { + "isComponent": false, + "isResource": false, + "short_name": "i32", + "title": "i32", + "type": "int", + "typeInfo": "Value" + }, + "i64": { + "isComponent": false, + "isResource": false, + "short_name": "i64", + "title": "i64", + "type": "int", + "typeInfo": "Value" + }, + "i8": { + "isComponent": false, + "isResource": false, + "short_name": "i8", + "title": "i8", + "type": "int", + "typeInfo": "Value" + }, + "isize": { + "isComponent": false, + "isResource": false, + "short_name": "isize", + "title": "isize", + "type": "int", + "typeInfo": "Value" + }, + "smallvec::SmallVec<[bevy_ecs::Entity; 8]>": { + "isComponent": false, + "isResource": false, + "items": { + "type": { + "$ref": "#/$defs/bevy_ecs::Entity" + } + }, + "short_name": "SmallVec<[Entity; 8]>", + "title": "smallvec::SmallVec<[bevy_ecs::Entity; 8]>", + "type": "array", + "typeInfo": "List" + }, + "std::ffi::OsString": { + "isComponent": false, + "isResource": false, + "short_name": "OsString", + "title": "std::ffi::OsString", + "type": "object", + "typeInfo": "Value" + }, + "std::path::PathBuf": { + "isComponent": false, + "isResource": false, + "short_name": "PathBuf", + "title": "std::path::PathBuf", + "type": "object", + "typeInfo": "Value" + }, + "u128": { + "isComponent": false, + "isResource": false, + "short_name": "u128", + "title": "u128", + "type": "uint", + "typeInfo": "Value" + }, + "u16": { + "isComponent": false, + "isResource": false, + "short_name": "u16", + "title": "u16", + "type": "uint", + "typeInfo": "Value" + }, + "u32": { + "isComponent": false, + "isResource": false, + "short_name": "u32", + "title": "u32", + "type": "uint", + "typeInfo": "Value" + }, + "u64": { + "isComponent": false, + "isResource": false, + "short_name": "u64", + "title": "u64", + "type": "uint", + "typeInfo": "Value" + }, + "u8": { + "isComponent": false, + "isResource": false, + "short_name": "u8", + "title": "u8", + "type": "uint", + "typeInfo": "Value" + }, + "usize": { + "isComponent": false, + "isResource": false, + "short_name": "usize", + "title": "usize", + "type": "uint", + "typeInfo": "Value" + } + }, + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "bevy component registry schema" +} \ No newline at end of file diff --git a/examples/bevy_registry_export/basic/src/assets/assets_core.rs b/examples/bevy_registry_export/basic/src/assets/assets_core.rs new file mode 100644 index 0000000..29b577a --- /dev/null +++ b/examples/bevy_registry_export/basic/src/assets/assets_core.rs @@ -0,0 +1,5 @@ +use bevy::prelude::*; +use bevy_asset_loader::prelude::*; + +#[derive(AssetCollection, Resource)] +pub struct CoreAssets {} diff --git a/examples/bevy_registry_export/basic/src/assets/assets_game.rs b/examples/bevy_registry_export/basic/src/assets/assets_game.rs new file mode 100644 index 0000000..b8e0665 --- /dev/null +++ b/examples/bevy_registry_export/basic/src/assets/assets_game.rs @@ -0,0 +1,13 @@ +use bevy::gltf::Gltf; +use bevy::prelude::*; +use bevy::utils::HashMap; +use bevy_asset_loader::prelude::*; + +#[derive(AssetCollection, Resource)] +pub struct GameAssets { + #[asset(key = "world")] + pub world: Handle, + + #[asset(key = "models", collection(typed, mapped))] + pub models: HashMap>, +} diff --git a/examples/bevy_registry_export/basic/src/assets/mod.rs b/examples/bevy_registry_export/basic/src/assets/mod.rs new file mode 100644 index 0000000..a2c8b22 --- /dev/null +++ b/examples/bevy_registry_export/basic/src/assets/mod.rs @@ -0,0 +1,35 @@ +pub mod assets_core; +pub use assets_core::*; + +pub mod assets_game; +pub use assets_game::*; + +use bevy::prelude::*; +use bevy_asset_loader::prelude::*; + +use crate::state::AppState; + +pub struct AssetsPlugin; +impl Plugin for AssetsPlugin { + fn build(&self, app: &mut App) { + app + // load core assets (ie assets needed in the main menu, and everywhere else before loading more assets in game) + .add_loading_state( + LoadingState::new(AppState::CoreLoading).continue_to_state(AppState::MenuRunning), + ) + .add_dynamic_collection_to_loading_state::<_, StandardDynamicAssetCollection>( + AppState::CoreLoading, + "assets_core.assets.ron", + ) + .add_collection_to_loading_state::<_, CoreAssets>(AppState::CoreLoading) + // load game assets + .add_loading_state( + LoadingState::new(AppState::AppLoading).continue_to_state(AppState::AppRunning), + ) + .add_dynamic_collection_to_loading_state::<_, StandardDynamicAssetCollection>( + AppState::AppLoading, + "assets_game.assets.ron", + ) + .add_collection_to_loading_state::<_, GameAssets>(AppState::AppLoading); + } +} diff --git a/examples/bevy_registry_export/basic/src/core/camera/camera_replace_proxies.rs b/examples/bevy_registry_export/basic/src/core/camera/camera_replace_proxies.rs new file mode 100644 index 0000000..9055c95 --- /dev/null +++ b/examples/bevy_registry_export/basic/src/core/camera/camera_replace_proxies.rs @@ -0,0 +1,24 @@ +use bevy::core_pipeline::bloom::{BloomCompositeMode, BloomSettings}; +use bevy::core_pipeline::tonemapping::{DebandDither, Tonemapping}; +use bevy::prelude::*; + +use super::CameraTrackingOffset; + +pub fn camera_replace_proxies( + mut commands: Commands, + mut added_cameras: Query<(Entity, &mut Camera), (Added, With)>, +) { + for (entity, mut camera) in added_cameras.iter_mut() { + info!("detected added camera, updating proxy"); + camera.hdr = true; + commands + .entity(entity) + .insert(DebandDither::Enabled) + .insert(Tonemapping::BlenderFilmic) + .insert(BloomSettings { + intensity: 0.01, + composite_mode: BloomCompositeMode::Additive, + ..default() + }); + } +} diff --git a/examples/bevy_registry_export/basic/src/core/camera/camera_tracking.rs b/examples/bevy_registry_export/basic/src/core/camera/camera_tracking.rs new file mode 100644 index 0000000..c498617 --- /dev/null +++ b/examples/bevy_registry_export/basic/src/core/camera/camera_tracking.rs @@ -0,0 +1,52 @@ +use bevy::prelude::*; + +#[derive(Component, Reflect, Debug)] +#[reflect(Component)] +/// Component for cameras, with an offset from the Trackable target +/// +pub struct CameraTracking { + pub offset: Vec3, +} +impl Default for CameraTracking { + fn default() -> Self { + CameraTracking { + offset: Vec3::new(0.0, 6.0, 8.0), + } + } +} + +#[derive(Component, Reflect, Debug, Deref, DerefMut)] +#[reflect(Component)] +/// Component for cameras, with an offset from the Trackable target +pub struct CameraTrackingOffset(Vec3); +impl Default for CameraTrackingOffset { + fn default() -> Self { + CameraTrackingOffset(Vec3::new(0.0, 6.0, 8.0)) + } +} + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +/// Add this component to an entity if you want it to be tracked by a Camera +pub struct CameraTrackable; + +pub fn camera_track( + mut tracking_cameras: Query< + (&mut Transform, &CameraTrackingOffset), + ( + With, + With, + Without, + ), + >, + camera_tracked: Query<&Transform, With>, +) { + for (mut camera_transform, tracking_offset) in tracking_cameras.iter_mut() { + for tracked_transform in camera_tracked.iter() { + let target_position = tracked_transform.translation + tracking_offset.0; + let eased_position = camera_transform.translation.lerp(target_position, 0.1); + camera_transform.translation = eased_position; // + tracking.offset;// tracked_transform.translation + tracking.offset; + *camera_transform = camera_transform.looking_at(tracked_transform.translation, Vec3::Y); + } + } +} diff --git a/examples/bevy_registry_export/basic/src/core/camera/mod.rs b/examples/bevy_registry_export/basic/src/core/camera/mod.rs new file mode 100644 index 0000000..a6bbb65 --- /dev/null +++ b/examples/bevy_registry_export/basic/src/core/camera/mod.rs @@ -0,0 +1,24 @@ +pub mod camera_tracking; +pub use camera_tracking::*; + +pub mod camera_replace_proxies; +pub use camera_replace_proxies::*; + +use bevy::prelude::*; +use bevy_gltf_blueprints::GltfBlueprintsSet; + +pub struct CameraPlugin; +impl Plugin for CameraPlugin { + fn build(&self, app: &mut App) { + app.register_type::() + .register_type::() + .register_type::() + .add_systems( + Update, + ( + camera_replace_proxies.after(GltfBlueprintsSet::AfterSpawn), + camera_track, + ), + ); + } +} diff --git a/examples/bevy_registry_export/basic/src/core/lighting/lighting_replace_proxies.rs b/examples/bevy_registry_export/basic/src/core/lighting/lighting_replace_proxies.rs new file mode 100644 index 0000000..48c0908 --- /dev/null +++ b/examples/bevy_registry_export/basic/src/core/lighting/lighting_replace_proxies.rs @@ -0,0 +1,25 @@ +use bevy::prelude::*; + +use bevy::pbr::{CascadeShadowConfig, CascadeShadowConfigBuilder}; + +// fixme might be too specific to might needs, should it be moved out ? also these are all for lights, not models +pub fn lighting_replace_proxies( + mut added_dirights: Query<(Entity, &mut DirectionalLight), Added>, + mut added_spotlights: Query<&mut SpotLight, Added>, + mut commands: Commands, +) { + for (entity, mut light) in added_dirights.iter_mut() { + light.illuminance *= 5.0; + light.shadows_enabled = true; + let shadow_config: CascadeShadowConfig = CascadeShadowConfigBuilder { + first_cascade_far_bound: 15.0, + maximum_distance: 135.0, + ..default() + } + .into(); + commands.entity(entity).insert(shadow_config); + } + for mut light in added_spotlights.iter_mut() { + light.shadows_enabled = true; + } +} diff --git a/examples/bevy_registry_export/basic/src/core/lighting/mod.rs b/examples/bevy_registry_export/basic/src/core/lighting/mod.rs new file mode 100644 index 0000000..c9688cd --- /dev/null +++ b/examples/bevy_registry_export/basic/src/core/lighting/mod.rs @@ -0,0 +1,18 @@ +mod lighting_replace_proxies; +use lighting_replace_proxies::*; + +use bevy::pbr::{DirectionalLightShadowMap, NotShadowCaster}; +use bevy::prelude::*; + +pub struct LightingPlugin; +impl Plugin for LightingPlugin { + fn build(&self, app: &mut App) { + app + .insert_resource(DirectionalLightShadowMap { size: 4096 }) + // FIXME: adding these since they are missing + .register_type::() + + .add_systems(PreUpdate, lighting_replace_proxies) // FIXME: you should actually run this in a specific state most likely + ; + } +} diff --git a/examples/bevy_registry_export/basic/src/core/mod.rs b/examples/bevy_registry_export/basic/src/core/mod.rs new file mode 100644 index 0000000..7404994 --- /dev/null +++ b/examples/bevy_registry_export/basic/src/core/mod.rs @@ -0,0 +1,38 @@ +pub mod camera; +pub use camera::*; + +pub mod lighting; +pub use lighting::*; + +pub mod relationships; +pub use relationships::*; + +pub mod physics; +pub use physics::*; + +use bevy::prelude::*; +use bevy_gltf_blueprints::*; + +use bevy_registry_export::*; + +pub struct CorePlugin; +impl Plugin for CorePlugin { + fn build(&self, app: &mut App) { + app.add_plugins(( + ExportRegistryPlugin { + save_path: "assets/registry.json".into(), + ..Default::default() + }, + LightingPlugin, + CameraPlugin, + PhysicsPlugin, + BlueprintsPlugin { + legacy_mode: false, + library_folder: "models/library".into(), + format: GltfFormat::GLB, + aabbs: true, + ..Default::default() + }, + )); + } +} diff --git a/examples/bevy_registry_export/basic/src/core/physics/controls.rs b/examples/bevy_registry_export/basic/src/core/physics/controls.rs new file mode 100644 index 0000000..b478d12 --- /dev/null +++ b/examples/bevy_registry_export/basic/src/core/physics/controls.rs @@ -0,0 +1,12 @@ +use bevy::{log::info, prelude::ResMut}; +use bevy_rapier3d::prelude::RapierConfiguration; + +pub fn pause_physics(mut physics_config: ResMut) { + info!("pausing physics"); + physics_config.physics_pipeline_active = false; +} + +pub fn resume_physics(mut physics_config: ResMut) { + info!("unpausing physics"); + physics_config.physics_pipeline_active = true; +} diff --git a/examples/bevy_registry_export/basic/src/core/physics/mod.rs b/examples/bevy_registry_export/basic/src/core/physics/mod.rs new file mode 100644 index 0000000..cd7d523 --- /dev/null +++ b/examples/bevy_registry_export/basic/src/core/physics/mod.rs @@ -0,0 +1,37 @@ +pub mod physics_replace_proxies; +use bevy_rapier3d::{ + prelude::{NoUserData, RapierPhysicsPlugin}, + render::RapierDebugRenderPlugin, +}; +pub use physics_replace_proxies::*; + +pub mod utils; + +pub mod controls; +pub use controls::*; + +use crate::state::GameState; +use bevy::prelude::*; +// use super::blueprints::GltfBlueprintsSet; +use bevy_gltf_blueprints::GltfBlueprintsSet; +// use crate::Collider; +pub struct PhysicsPlugin; +impl Plugin for PhysicsPlugin { + fn build(&self, app: &mut App) { + app.add_plugins(( + RapierPhysicsPlugin::::default(), + RapierDebugRenderPlugin::default(), + )) + .register_type::() + .register_type::() + // find a way to make serde's stuff serializable + // .register_type::() + //bevy_rapier3d::dynamics::CoefficientCombineRule + .add_systems( + Update, + physics_replace_proxies.after(GltfBlueprintsSet::AfterSpawn), + ) + .add_systems(OnEnter(GameState::InGame), resume_physics) + .add_systems(OnExit(GameState::InGame), pause_physics); + } +} diff --git a/examples/bevy_registry_export/basic/src/core/physics/physics_replace_proxies.rs b/examples/bevy_registry_export/basic/src/core/physics/physics_replace_proxies.rs new file mode 100644 index 0000000..b91462c --- /dev/null +++ b/examples/bevy_registry_export/basic/src/core/physics/physics_replace_proxies.rs @@ -0,0 +1,101 @@ +use bevy::prelude::*; +// use bevy::render::primitives::Aabb; +use bevy_rapier3d::geometry::Collider as RapierCollider; +use bevy_rapier3d::prelude::{ActiveCollisionTypes, ActiveEvents, ComputedColliderShape}; + +use super::utils::*; + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +pub enum Collider { + Ball(f32), + Cuboid(Vec3), + Capsule(Vec3, Vec3, f32), + #[default] + Mesh, +} + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +pub enum AutoAABBCollider { + #[default] + Cuboid, + Ball, + Capsule, +} + +// replaces all physics stand-ins with the actual rapier types +pub fn physics_replace_proxies( + meshes: Res>, + mesh_handles: Query<&Handle>, + mut proxy_colliders: Query< + (Entity, &Collider, &Name, &mut Visibility), + (Without, Added), + >, + // needed for tri meshes + children: Query<&Children>, + + mut commands: Commands, +) { + for proxy_colider in proxy_colliders.iter_mut() { + let (entity, collider_proxy, name, mut visibility) = proxy_colider; + // we hide the collider meshes: perhaps they should be removed altogether once processed ? + if name.ends_with("_collider") || name.ends_with("_sensor") { + *visibility = Visibility::Hidden; + } + + let mut rapier_collider: RapierCollider; + match collider_proxy { + Collider::Ball(radius) => { + info!("generating collider from proxy: ball"); + rapier_collider = RapierCollider::ball(*radius); + commands.entity(entity) + .insert(rapier_collider) + .insert(ActiveEvents::COLLISION_EVENTS) // FIXME: this is just for demo purposes !!! + ; + } + Collider::Cuboid(size) => { + info!("generating collider from proxy: cuboid"); + rapier_collider = RapierCollider::cuboid(size.x, size.y, size.z); + commands.entity(entity) + .insert(rapier_collider) + .insert(ActiveEvents::COLLISION_EVENTS) // FIXME: this is just for demo purposes !!! + ; + } + Collider::Capsule(a, b, radius) => { + info!("generating collider from proxy: capsule"); + rapier_collider = RapierCollider::capsule(*a, *b, *radius); + commands.entity(entity) + .insert(rapier_collider) + .insert(ActiveEvents::COLLISION_EVENTS) // FIXME: this is just for demo purposes !!! + ; + } + Collider::Mesh => { + info!("generating collider from proxy: mesh"); + for (_, collider_mesh) in + Mesh::search_in_children(entity, &children, &meshes, &mesh_handles) + { + rapier_collider = RapierCollider::from_bevy_mesh( + collider_mesh, + &ComputedColliderShape::TriMesh, + ) + .unwrap(); + commands + .entity(entity) + .insert(rapier_collider) + // FIXME: this is just for demo purposes !!! + .insert( + ActiveCollisionTypes::default() + | ActiveCollisionTypes::KINEMATIC_STATIC + | ActiveCollisionTypes::STATIC_STATIC + | ActiveCollisionTypes::DYNAMIC_STATIC, + ) + .insert(ActiveEvents::COLLISION_EVENTS); + // .insert(ActiveEvents::COLLISION_EVENTS) + // break; + // RapierCollider::convex_hull(points) + } + } + } + } +} diff --git a/examples/bevy_registry_export/basic/src/core/physics/utils.rs b/examples/bevy_registry_export/basic/src/core/physics/utils.rs new file mode 100644 index 0000000..7886710 --- /dev/null +++ b/examples/bevy_registry_export/basic/src/core/physics/utils.rs @@ -0,0 +1,175 @@ +use bevy::prelude::*; +use bevy::render::mesh::{MeshVertexAttributeId, PrimitiveTopology, VertexAttributeValues}; +// TAKEN VERBATIB FROM https://github.com/janhohenheim/foxtrot/blob/src/util/trait_extension.rs + +pub(crate) trait Vec3Ext: Copy { + fn is_approx_zero(self) -> bool; + fn split(self, up: Vec3) -> SplitVec3; +} +impl Vec3Ext for Vec3 { + #[inline] + fn is_approx_zero(self) -> bool { + self.length_squared() < 1e-5 + } + + #[inline] + fn split(self, up: Vec3) -> SplitVec3 { + let vertical = up * self.dot(up); + let horizontal = self - vertical; + SplitVec3 { + vertical, + horizontal, + } + } +} + +#[derive(Debug, Clone, Copy, PartialEq)] +pub(crate) struct SplitVec3 { + pub(crate) vertical: Vec3, + pub(crate) horizontal: Vec3, +} + +pub(crate) trait Vec2Ext: Copy { + fn is_approx_zero(self) -> bool; + fn x0y(self) -> Vec3; +} +impl Vec2Ext for Vec2 { + #[inline] + fn is_approx_zero(self) -> bool { + self.length_squared() < 1e-5 + } + + #[inline] + fn x0y(self) -> Vec3 { + Vec3::new(self.x, 0., self.y) + } +} + +pub(crate) trait MeshExt { + fn transform(&mut self, transform: Transform); + fn transformed(&self, transform: Transform) -> Mesh; + fn read_coords_mut(&mut self, id: impl Into) -> &mut Vec<[f32; 3]>; + fn search_in_children<'a>( + parent: Entity, + children: &'a Query<&Children>, + meshes: &'a Assets, + mesh_handles: &'a Query<&Handle>, + ) -> Vec<(Entity, &'a Mesh)>; +} + +impl MeshExt for Mesh { + fn transform(&mut self, transform: Transform) { + for coords in self.read_coords_mut(Mesh::ATTRIBUTE_POSITION.clone()) { + let vec3 = (*coords).into(); + let transformed = transform.transform_point(vec3); + *coords = transformed.into(); + } + for normal in self.read_coords_mut(Mesh::ATTRIBUTE_NORMAL.clone()) { + let vec3 = (*normal).into(); + let transformed = transform.rotation.mul_vec3(vec3); + *normal = transformed.into(); + } + } + + fn transformed(&self, transform: Transform) -> Mesh { + let mut mesh = self.clone(); + mesh.transform(transform); + mesh + } + + fn read_coords_mut(&mut self, id: impl Into) -> &mut Vec<[f32; 3]> { + // Guaranteed by Bevy for the current usage + match self + .attribute_mut(id) + .expect("Failed to read unknown mesh attribute") + { + VertexAttributeValues::Float32x3(values) => values, + // Guaranteed by Bevy for the current usage + _ => unreachable!(), + } + } + + fn search_in_children<'a>( + parent: Entity, + children_query: &'a Query<&Children>, + meshes: &'a Assets, + mesh_handles: &'a Query<&Handle>, + ) -> Vec<(Entity, &'a Mesh)> { + if let Ok(children) = children_query.get(parent) { + let mut result: Vec<_> = children + .iter() + .filter_map(|entity| mesh_handles.get(*entity).ok().map(|mesh| (*entity, mesh))) + .map(|(entity, mesh_handle)| { + ( + entity, + meshes + .get(mesh_handle) + .expect("Failed to get mesh from handle"), + ) + }) + .map(|(entity, mesh)| { + assert_eq!(mesh.primitive_topology(), PrimitiveTopology::TriangleList); + (entity, mesh) + }) + .collect(); + let mut inner_result = children + .iter() + .flat_map(|entity| { + Self::search_in_children(*entity, children_query, meshes, mesh_handles) + }) + .collect(); + result.append(&mut inner_result); + result + } else { + Vec::new() + } + } +} + +pub(crate) trait F32Ext: Copy { + fn is_approx_zero(self) -> bool; + fn squared(self) -> f32; + fn lerp(self, other: f32, ratio: f32) -> f32; +} + +impl F32Ext for f32 { + #[inline] + fn is_approx_zero(self) -> bool { + self.abs() < 1e-5 + } + + #[inline] + fn squared(self) -> f32 { + self * self + } + + #[inline] + fn lerp(self, other: f32, ratio: f32) -> f32 { + self.mul_add(1. - ratio, other * ratio) + } +} + +pub(crate) trait TransformExt: Copy { + fn horizontally_looking_at(self, target: Vec3, up: Vec3) -> Transform; + fn lerp(self, other: Transform, ratio: f32) -> Transform; +} + +impl TransformExt for Transform { + fn horizontally_looking_at(self, target: Vec3, up: Vec3) -> Transform { + let direction = target - self.translation; + let horizontal_direction = direction - up * direction.dot(up); + let look_target = self.translation + horizontal_direction; + self.looking_at(look_target, up) + } + + fn lerp(self, other: Transform, ratio: f32) -> Transform { + let translation = self.translation.lerp(other.translation, ratio); + let rotation = self.rotation.slerp(other.rotation, ratio); + let scale = self.scale.lerp(other.scale, ratio); + Transform { + translation, + rotation, + scale, + } + } +} diff --git a/examples/bevy_registry_export/basic/src/core/physics/utils_old.rs b/examples/bevy_registry_export/basic/src/core/physics/utils_old.rs new file mode 100644 index 0000000..c210dd3 --- /dev/null +++ b/examples/bevy_registry_export/basic/src/core/physics/utils_old.rs @@ -0,0 +1,75 @@ +use bevy::prelude::*; +use bevy::render::mesh::{MeshVertexAttributeId, PrimitiveTopology, VertexAttributeValues}; +// TAKEN VERBATIB FROM https://github.com/janhohenheim/foxtrot/blob/6e31fc02652fc9d085a4adde0a73ab007dbbb0dc/src/util/trait_extension.rs + +pub trait Vec3Ext { + #[allow(clippy::wrong_self_convention)] // Because [`Vec3`] is [`Copy`] + fn is_approx_zero(self) -> bool; + fn x0z(self) -> Vec3; +} +impl Vec3Ext for Vec3 { + fn is_approx_zero(self) -> bool { + [self.x, self.y, self.z].iter().all(|&x| x.abs() < 1e-5) + } + fn x0z(self) -> Vec3 { + Vec3::new(self.x, 0., self.z) + } +} + +pub trait MeshExt { + fn transform(&mut self, transform: Transform); + fn transformed(&self, transform: Transform) -> Mesh; + fn read_coords_mut(&mut self, id: impl Into) -> &mut Vec<[f32; 3]>; + fn search_in_children<'a>( + children: &'a Children, + meshes: &'a Assets, + mesh_handles: &'a Query<&Handle>, + ) -> (Entity, &'a Mesh); +} + +impl MeshExt for Mesh { + fn transform(&mut self, transform: Transform) { + for attribute in [Mesh::ATTRIBUTE_POSITION, Mesh::ATTRIBUTE_NORMAL] { + for coords in self.read_coords_mut(attribute.clone()) { + let vec3 = (*coords).into(); + let transformed = transform.transform_point(vec3); + *coords = transformed.into(); + } + } + } + + fn transformed(&self, transform: Transform) -> Mesh { + let mut mesh = self.clone(); + mesh.transform(transform); + mesh + } + + fn read_coords_mut(&mut self, id: impl Into) -> &mut Vec<[f32; 3]> { + match self.attribute_mut(id).unwrap() { + VertexAttributeValues::Float32x3(values) => values, + // Guaranteed by Bevy + _ => unreachable!(), + } + } + + fn search_in_children<'a>( + children: &'a Children, + meshes: &'a Assets, + mesh_handles: &'a Query<&Handle>, + ) -> (Entity, &'a Mesh) { + let entity_handles: Vec<_> = children + .iter() + .filter_map(|entity| mesh_handles.get(*entity).ok().map(|mesh| (*entity, mesh))) + .collect(); + assert_eq!( + entity_handles.len(), + 1, + "Collider must contain exactly one mesh, but found {}", + entity_handles.len() + ); + let (entity, mesh_handle) = entity_handles.first().unwrap(); + let mesh = meshes.get(mesh_handle).unwrap(); + assert_eq!(mesh.primitive_topology(), PrimitiveTopology::TriangleList); + (*entity, mesh) + } +} diff --git a/examples/bevy_registry_export/basic/src/core/relationships/mod.rs b/examples/bevy_registry_export/basic/src/core/relationships/mod.rs new file mode 100644 index 0000000..4128453 --- /dev/null +++ b/examples/bevy_registry_export/basic/src/core/relationships/mod.rs @@ -0,0 +1,11 @@ +pub mod relationships_insert_dependant_components; +pub use relationships_insert_dependant_components::*; + +use bevy::prelude::*; + +pub struct EcsRelationshipsPlugin; +impl Plugin for EcsRelationshipsPlugin { + fn build(&self, app: &mut App) { + app; + } +} diff --git a/examples/bevy_registry_export/basic/src/core/relationships/relationships_insert_dependant_components.rs b/examples/bevy_registry_export/basic/src/core/relationships/relationships_insert_dependant_components.rs new file mode 100644 index 0000000..4e9ad17 --- /dev/null +++ b/examples/bevy_registry_export/basic/src/core/relationships/relationships_insert_dependant_components.rs @@ -0,0 +1,15 @@ +use bevy::prelude::*; + +pub fn insert_dependant_component< + Dependant: Component, + Dependency: Component + std::default::Default, +>( + mut commands: Commands, + entities_without_depency: Query<(Entity, &Name), (With, Without)>, +) { + for (entity, name) in entities_without_depency.iter() { + let name = name.clone().to_string(); + commands.entity(entity).insert(Dependency::default()); + warn!("found an entity called {} with a {} component but without an {}, please check your assets", name.clone(), std::any::type_name::(), std::any::type_name::()); + } +} diff --git a/examples/bevy_registry_export/basic/src/game/in_game.rs b/examples/bevy_registry_export/basic/src/game/in_game.rs new file mode 100644 index 0000000..2a077f7 --- /dev/null +++ b/examples/bevy_registry_export/basic/src/game/in_game.rs @@ -0,0 +1,132 @@ +use bevy::prelude::*; + +use crate::{ + assets::GameAssets, + state::{GameState, InAppRunning}, +}; +use bevy_gltf_blueprints::{BluePrintBundle, BlueprintName, GameWorldTag}; + +use bevy_rapier3d::prelude::Velocity; +use rand::Rng; + +pub fn setup_game( + mut commands: Commands, + game_assets: Res, + models: Res>, + mut next_game_state: ResMut>, +) { + println!("setting up all stuff"); + commands.insert_resource(AmbientLight { + color: Color::WHITE, + brightness: 0.2, + }); + // here we actually spawn our game world/level + + commands.spawn(( + SceneBundle { + // note: because of this issue https://github.com/bevyengine/bevy/issues/10436, "world" is now a gltf file instead of a scene + scene: models + .get(game_assets.world.id()) + .expect("main level should have been loaded") + .scenes[0] + .clone(), + ..default() + }, + bevy::prelude::Name::from("world"), + GameWorldTag, + InAppRunning, + )); + + next_game_state.set(GameState::InGame) +} + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +struct UnregisteredComponent; + +pub fn spawn_test( + keycode: Res>, + mut commands: Commands, + + mut game_world: Query<(Entity, &Children), With>, +) { + if keycode.just_pressed(KeyCode::T) { + let world = game_world.single_mut(); + let world = world.1[0]; + + let mut rng = rand::thread_rng(); + let range = 5.5; + let x: f32 = rng.gen_range(-range..range); + let y: f32 = rng.gen_range(-range..range); + + let mut rng = rand::thread_rng(); + let range = 0.8; + let vel_x: f32 = rng.gen_range(-range..range); + let vel_y: f32 = rng.gen_range(2.0..2.5); + let vel_z: f32 = rng.gen_range(-range..range); + + let name_index: u64 = rng.gen(); + + let new_entity = commands + .spawn(( + BluePrintBundle { + blueprint: BlueprintName("Health_Pickup".to_string()), + ..Default::default() + }, + bevy::prelude::Name::from(format!("test{}", name_index)), + // BlueprintName("Health_Pickup".to_string()), + // SpawnHere, + TransformBundle::from_transform(Transform::from_xyz(x, 2.0, y)), + Velocity { + linvel: Vec3::new(vel_x, vel_y, vel_z), + angvel: Vec3::new(0.0, 0.0, 0.0), + }, + )) + .id(); + commands.entity(world).add_child(new_entity); + } +} + +pub fn spawn_test_unregisted_components( + keycode: Res>, + mut commands: Commands, + + mut game_world: Query<(Entity, &Children), With>, +) { + if keycode.just_pressed(KeyCode::U) { + let world = game_world.single_mut(); + let world = world.1[0]; + + let mut rng = rand::thread_rng(); + let range = 5.5; + let x: f32 = rng.gen_range(-range..range); + let y: f32 = rng.gen_range(-range..range); + + let mut rng = rand::thread_rng(); + let range = 0.8; + let vel_x: f32 = rng.gen_range(-range..range); + let vel_y: f32 = rng.gen_range(2.0..2.5); + let vel_z: f32 = rng.gen_range(-range..range); + + let name_index: u64 = rng.gen(); + + let new_entity = commands + .spawn(( + BluePrintBundle { + blueprint: BlueprintName("Health_Pickup".to_string()), + ..Default::default() + }, + bevy::prelude::Name::from(format!("test{}", name_index)), + // BlueprintName("Health_Pickup".to_string()), + // SpawnHere, + TransformBundle::from_transform(Transform::from_xyz(x, 2.0, y)), + Velocity { + linvel: Vec3::new(vel_x, vel_y, vel_z), + angvel: Vec3::new(0.0, 0.0, 0.0), + }, + UnregisteredComponent, + )) + .id(); + commands.entity(world).add_child(new_entity); + } +} diff --git a/examples/bevy_registry_export/basic/src/game/in_main_menu.rs b/examples/bevy_registry_export/basic/src/game/in_main_menu.rs new file mode 100644 index 0000000..586063a --- /dev/null +++ b/examples/bevy_registry_export/basic/src/game/in_main_menu.rs @@ -0,0 +1,113 @@ +use bevy::prelude::*; + +use crate::state::{AppState, InMainMenu}; + +pub fn setup_main_menu(mut commands: Commands) { + commands.spawn((Camera2dBundle::default(), InMainMenu)); + + commands.spawn(( + TextBundle::from_section( + "SOME GAME TITLE !!", + TextStyle { + //font: asset_server.load("fonts/FiraMono-Medium.ttf"), + font_size: 18.0, + color: Color::WHITE, + ..Default::default() + }, + ) + .with_style(Style { + position_type: PositionType::Absolute, + top: Val::Px(100.0), + left: Val::Px(200.0), + ..default() + }), + InMainMenu, + )); + + commands.spawn(( + TextBundle::from_section( + "New Game (press Enter to start, press T once the game is started for demo spawning)", + TextStyle { + //font: asset_server.load("fonts/FiraMono-Medium.ttf"), + font_size: 18.0, + color: Color::WHITE, + ..Default::default() + }, + ) + .with_style(Style { + position_type: PositionType::Absolute, + top: Val::Px(200.0), + left: Val::Px(200.0), + ..default() + }), + InMainMenu, + )); + + /* + commands.spawn(( + TextBundle::from_section( + "Load Game", + TextStyle { + //font: asset_server.load("fonts/FiraMono-Medium.ttf"), + font_size: 18.0, + color: Color::WHITE, + ..Default::default() + }, + ) + .with_style(Style { + position_type: PositionType::Absolute, + top: Val::Px(250.0), + left: Val::Px(200.0), + ..default() + }), + InMainMenu + )); + + commands.spawn(( + TextBundle::from_section( + "Exit Game", + TextStyle { + //font: asset_server.load("fonts/FiraMono-Medium.ttf"), + font_size: 18.0, + color: Color::WHITE, + ..Default::default() + }, + ) + .with_style(Style { + position_type: PositionType::Absolute, + top: Val::Px(300.0), + left: Val::Px(200.0), + ..default() + }), + InMainMenu + ));*/ +} + +pub fn teardown_main_menu(bla: Query>, mut commands: Commands) { + for bli in bla.iter() { + commands.entity(bli).despawn_recursive(); + } +} + +pub fn main_menu( + keycode: Res>, + + mut next_app_state: ResMut>, + // mut next_game_state: ResMut>, + // mut save_requested_events: EventWriter, + // mut load_requested_events: EventWriter, +) { + if keycode.just_pressed(KeyCode::Return) { + next_app_state.set(AppState::AppLoading); + // next_game_state.set(GameState::None); + } + + if keycode.just_pressed(KeyCode::L) { + next_app_state.set(AppState::AppLoading); + // load_requested_events.send(LoadRequest { path: "toto".into() }) + } + + if keycode.just_pressed(KeyCode::S) { + // save_requested_events.send(SaveRequest { path: "toto".into() }) + } +} diff --git a/examples/bevy_registry_export/basic/src/game/mod.rs b/examples/bevy_registry_export/basic/src/game/mod.rs new file mode 100644 index 0000000..1318ee1 --- /dev/null +++ b/examples/bevy_registry_export/basic/src/game/mod.rs @@ -0,0 +1,90 @@ +pub mod in_game; +pub use in_game::*; + +pub mod in_main_menu; +pub use in_main_menu::*; + +pub mod picking; +pub use picking::*; + +use crate::state::{AppState, GameState}; +use bevy::prelude::*; + +// this file is just for demo purposes, contains various types of components, systems etc + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +pub enum SoundMaterial { + Metal, + Wood, + Rock, + Cloth, + Squishy, + #[default] + None, +} + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +/// Demo marker component +pub struct Player; + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +/// Demo component showing auto injection of components +pub struct ShouldBeWithPlayer; + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +/// Demo marker component +pub struct Interactible; + +fn player_move_demo( + keycode: Res>, + mut players: Query<&mut Transform, With>, +) { + let speed = 0.2; + if let Ok(mut player) = players.get_single_mut() { + if keycode.pressed(KeyCode::Left) { + player.translation.x += speed; + } + if keycode.pressed(KeyCode::Right) { + player.translation.x -= speed; + } + + if keycode.pressed(KeyCode::Up) { + player.translation.z += speed; + } + if keycode.pressed(KeyCode::Down) { + player.translation.z -= speed; + } + } +} + +pub struct GamePlugin; +impl Plugin for GamePlugin { + fn build(&self, app: &mut App) { + app.add_plugins(PickingPlugin) + .register_type::() + .register_type::() + .register_type::() + // little helper utility, to automatically inject components that are dependant on an other component + // ie, here an Entity with a Player component should also always have a ShouldBeWithPlayer component + // you get a warning if you use this, as I consider this to be stop-gap solution (usually you should have either a bundle, or directly define all needed components) + .add_systems( + Update, + ( + // insert_dependant_component::, + player_move_demo, //.run_if(in_state(AppState::Running)), + // test_collision_events + spawn_test, + spawn_test_unregisted_components, + ) + .run_if(in_state(GameState::InGame)), + ) + .add_systems(OnEnter(AppState::MenuRunning), setup_main_menu) + .add_systems(OnExit(AppState::MenuRunning), teardown_main_menu) + .add_systems(Update, main_menu.run_if(in_state(AppState::MenuRunning))) + .add_systems(OnEnter(AppState::AppRunning), setup_game); + } +} diff --git a/examples/bevy_registry_export/basic/src/game/picking.rs b/examples/bevy_registry_export/basic/src/game/picking.rs new file mode 100644 index 0000000..6731bbb --- /dev/null +++ b/examples/bevy_registry_export/basic/src/game/picking.rs @@ -0,0 +1,34 @@ +use super::Player; +use bevy::prelude::*; +use bevy_gltf_blueprints::GltfBlueprintsSet; + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +pub struct Pickable; + +// very simple, crude picking (as in picking up objects) implementation + +pub fn picking( + players: Query<&GlobalTransform, With>, + pickables: Query<(Entity, &GlobalTransform), With>, + mut commands: Commands, +) { + for player_transforms in players.iter() { + for (pickable, pickable_transforms) in pickables.iter() { + let distance = player_transforms + .translation() + .distance(pickable_transforms.translation()); + if distance < 2.5 { + commands.entity(pickable).despawn_recursive(); + } + } + } +} + +pub struct PickingPlugin; +impl Plugin for PickingPlugin { + fn build(&self, app: &mut App) { + app.register_type::() + .add_systems(Update, (picking.after(GltfBlueprintsSet::AfterSpawn),)); + } +} diff --git a/examples/bevy_registry_export/basic/src/main.rs b/examples/bevy_registry_export/basic/src/main.rs new file mode 100644 index 0000000..6edba33 --- /dev/null +++ b/examples/bevy_registry_export/basic/src/main.rs @@ -0,0 +1,33 @@ +use bevy::prelude::*; +use bevy_editor_pls::prelude::*; + +mod core; +use crate::core::*; + +pub mod assets; +use assets::*; + +pub mod state; +use state::*; + +mod game; +use game::*; + +mod test_components; +use test_components::*; + +fn main() { + App::new() + .add_plugins(( + DefaultPlugins.set(AssetPlugin::default()), + // editor + EditorPlugin::default(), + // our custom plugins + StatePlugin, + AssetsPlugin, + CorePlugin, // reusable plugins + GamePlugin, // specific to our game + ComponentsTestPlugin, // Showcases different type of components /structs + )) + .run(); +} diff --git a/examples/bevy_registry_export/basic/src/state.rs b/examples/bevy_registry_export/basic/src/state.rs new file mode 100644 index 0000000..8e983d9 --- /dev/null +++ b/examples/bevy_registry_export/basic/src/state.rs @@ -0,0 +1,54 @@ +use bevy::app::AppExit; +use bevy::prelude::*; + +#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, Default, States)] +pub enum AppState { + #[default] + CoreLoading, + MenuRunning, + AppLoading, + AppRunning, + AppEnding, + + // FIXME: not sure + LoadingGame, +} + +#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, Default, States)] +pub enum GameState { + #[default] + None, + + InMenu, + InGame, + + InGameOver, + + InSaving, + InLoading, +} + +// tag components for all entities within a certain state (for despawning them if needed) , FIXME: seems kinda hack-ish +#[derive(Component)] +pub struct InCoreLoading; +#[derive(Component, Default)] +pub struct InMenuRunning; +#[derive(Component)] +pub struct InAppLoading; +#[derive(Component)] +pub struct InAppRunning; + +// components for tagging in game vs in game menu stuff +#[derive(Component, Default)] +pub struct InMainMenu; +#[derive(Component, Default)] +pub struct InMenu; +#[derive(Component, Default)] +pub struct InGame; + +pub struct StatePlugin; +impl Plugin for StatePlugin { + fn build(&self, app: &mut App) { + app.add_state::().add_state::(); + } +} diff --git a/examples/bevy_registry_export/basic/src/test_components.rs b/examples/bevy_registry_export/basic/src/test_components.rs new file mode 100644 index 0000000..39cd711 --- /dev/null +++ b/examples/bevy_registry_export/basic/src/test_components.rs @@ -0,0 +1,136 @@ +use bevy::prelude::*; + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +struct UnitTest; + +#[derive(Component, Reflect, Default, Debug, Deref, DerefMut)] +#[reflect(Component)] +struct TuppleTestF32(f32); + +#[derive(Component, Reflect, Default, Debug, Deref, DerefMut)] +#[reflect(Component)] +struct TuppleTestU64(u64); + +#[derive(Component, Reflect, Default, Debug, Deref, DerefMut)] +#[reflect(Component)] +pub struct TuppleTestStr(String); + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +struct TuppleTest2(f32, u64, String); + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +struct TuppleTestBool(bool); + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +struct TuppleVec2(Vec2); + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +struct TuppleVec3(Vec3); + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +struct TuppleVec(Vec); + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +struct TuppleVecF32F32(Vec<(f32, f32)>); + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +struct TuppleTestColor(Color); + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +pub struct BasicTest { + a: f32, + b: u64, + c: String, +} + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +pub enum EnumTest { + Metal, + Wood, + Rock, + Cloth, + Squishy, + #[default] + None, +} + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +pub struct NestingTestLevel2 { + text: String, + enable: bool, + enum_inner: EnumTest, + color: TuppleTestColor, + toggle: TuppleTestBool, + basic: BasicTest, + pub nested: NestingTestLevel3, + colors_list: VecOfColors, +} + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +pub struct NestingTestLevel3 { + vec: TuppleVec3, +} + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +pub struct NestedTuppleStuff(f32, u64, NestingTestLevel2); + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +pub enum EnumComplex { + Float(f32), + Wood(String), + Vec(BasicTest), + SomeThing, + #[default] + None, +} + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +pub struct VecOfVec3s2(Vec); + +#[derive(Component, Reflect, Default, Debug)] +#[reflect(Component)] +pub struct VecOfColors(Vec); +pub struct ComponentsTestPlugin; +impl Plugin for ComponentsTestPlugin { + fn build(&self, app: &mut App) { + app.register_type::() + .register_type::() + .register_type::() + .register_type::() + .register_type::() + .register_type::() + .register_type::() + .register_type::() + .register_type::() + .register_type::() + .register_type::() + .register_type::() + .register_type::>() + .register_type::() + .register_type::() + .register_type::() + .register_type::() + .register_type::() + .register_type::() + .register_type::<(f32, f32)>() + .register_type::>() + .register_type::>() + .register_type::>() + .register_type::(); + } +} diff --git a/tools/bevy_components/README.md b/tools/bevy_components/README.md new file mode 100644 index 0000000..426e127 --- /dev/null +++ b/tools/bevy_components/README.md @@ -0,0 +1,199 @@ +# Bevy components + +This [Blender addon](https://github.com/kaosat-dev/Blender_bevy_components_workflow/tree/main/tools/bevy_components) gives you an easy to use UI to add and configure your [Bevy](https://bevyengine.org/) components inside Blender ! + +- **automatically generates a simple UI** to add/configure components based on a **registry schema** file (an export of all your Bevy components's information, generated) +by the [bevy_registry_export](https://crates.io/crates/bevy_registry_export) crate/plugin +- no more need to specify components manually using custom_properties, with error prone naming etc +- adds **metadata** to objects containing information about what components it uses + some extra information +- uses Blender's **PropertyGroups** to generate custom UIs & connects those groups with the custom properties so that no matter the complexity +of your Bevy components you get a nicely packed custom_property to use with ... +- the ideal companion to the [gltf_auto_export](https://github.com/kaosat-dev/Blender_bevy_components_workflow/tree/main/tools/gltf_auto_export) to embed your Bevy components inside your gltf files + + + +> Important: + the tooling is still in the early stages, even if it is feature complete : use with caution!. + +## Installation: + +* grab the latest release zip file from the releases tab (choose the bevy_components releases !) + + + +* in Blender go to edit => preferences => install + +![blender addon install](./docs/blender_addon_install.png) + +* choose the path where ```bevy_components.zip``` is stored + +![blender addon install](./docs/blender_addon_install2.png) + + +## Configuration & overview + +Before you can use the add-on you need to configure it + +### Bevy side + + - setup [bevy_registry_export](https://crates.io/crates/bevy_registry_export) for your project (see the crate's documentation for that), and compile/run it to get the ```registry.json``` file + +### Blender side + +- Go to the new Bevy Components tab in the 3D view + +![configuration](./docs/configuration.png) + +- click on the button to select your registry.json file (in the "configuration" panel) + +![configuration 2](./docs/configuration2.png) + +- the list of available components will appear + +![configuration 3](./docs/configuration3.png) + + + +## Use + + +### Existing components & custom properties + +* If you already have components defined manualy in Blender inside **custom properties** you will need to define them again using the UI! +* avoid mixing & matching: if you change the values of **custom properties** that also have a component, the custom property will be **overriden** every time +you change the component's value +* you can of course still use non component custom properties as always, this add-on will only impact those that have corresponding Bevy components + +### adding components + +- to add a component, select an object and then select the component from the components list: (the full type information will be displayed as tooltip) + +![components list](./docs/components_list.png) + +- click on the dropdown to get the full list of available components + +![components list](./docs/components_list2.png) + +- you can also filter components by name for convenience + +![filter components](./docs/filter_components.png) + + +- add a component by clicking on the "add component" button once you have selected your desired component + + it will appear in the component list for that object + +![add component](./docs/add_component.png) + +### edit components + +- to edit a component's value just use the UI: + +![edit component](./docs/edit_component.png) + +it will automatically update the value of the corresponding custom property + +![edit component](./docs/edit_component2.png) + +### copy & pasting + +- you can also copy & paste components between objects + +- click on the "copy component button" of the component you want to copy + +![copy component](./docs/copy_component.png) + +- then select the object you want to copy the component (& its value) to, and click on the paste button. + +It will add the component to the select object + +![paste component](./docs/paste_component.png) + +> if the target object already has the same component, its values will be overwritten + + +## Additional components UI features + +- for large/ complex components you can toggle the details of that component: + +![toggle details](./docs/toggle_details.png) + + +## Supported components + +- normally (minus any bugs, please report those!) all components using **registered** types should be useable and editable +- this includes (non exhaustive list): + * enums (even complex ones !) + + ![enums](./docs/enums.png) + + ![enums](./docs/enums2.png) + + + * complex structs, with various types of fields (including nested ones) + + ![complex](./docs/complex_components2.png) + + * lists/ vecs (here a vec of tuples) + + ![lists](./docs/vecs_lists.png) + + * etc ! + +## Unregistered types & error handling + +- non registered types can be viewed in this panel : (can be practical to see if you have any missing registrations too!) + + ![unregistered types](./docs/unregistered_types.png) + +- if you have a component made up of unregistered structs/enums etc, you will get visual feedback & the component will be deactivated + + ![invalid component](./docs/invalid_components.png) + + > important ! ```gltf_auto_export``` currently has no way of filtering out components, so you need to delete invalid components like these before exporting + this will be adress in the future + +- if you are encountering this type of view: don't panic your component data is not gone ! It just means you need to reload the registry data by clicking on the relevant button + + ![missing registry data](./docs/missing_registry_data.png) + + + +## advanced configuration + + - there are also additional QOL features, that you should not need most of the time + + - "update custom properties of current object" : will go over **all components** that you have defined for the **currently selected object**, and re-generate the + + corresponding custom property values + + ![update custom properties](./docs/other_options.png) + + + - "update custom properties of ALL objects" : same as above but it will do so for the **ALL objects in your blend file** (so can be slow!), and re-generate the + + corresponding custom property values + + ![update custom properties for all](./docs/other_options2.png) + + +## Additional important information + + +- for the components to work correctly with [```bevy_gltf_components```](https://crates.io/crates/bevy_gltf_components) or [```bevy_gltf_blueprints```](https://crates.io/crates/bevy_gltf_blueprints) you will need to set the ```legacy_mode``` for those plugins to **FALSE** +as the component data generated by this add on is a complete, clean **ron** data that is incompatible with the previous (legacy versions). +Please see the documentation of those crates for more information. + +> Note: the legacy mode support will be dropped in future versions, and the default behaviour will be NO legacy mode + + +## Examples + +you can find an example [here](https://github.com/kaosat-dev/Blender_bevy_components_workflow/tree/main/examples/bevy_registry_export/) + +## License + +This tool, all its code, contents & assets is Dual-licensed under either of + +- Apache License, Version 2.0, ([LICENSE-APACHE](../LICENSE_APACHE.md) or https://www.apache.org/licenses/LICENSE-2.0) +- MIT license ([LICENSE-MIT](../LICENSE_MIT.md) or https://opensource.org/licenses/MIT) \ No newline at end of file diff --git a/tools/bevy_components/TODO.md b/tools/bevy_components/TODO.md new file mode 100644 index 0000000..994e6f0 --- /dev/null +++ b/tools/bevy_components/TODO.md @@ -0,0 +1,139 @@ +Basics +- [x] add panel +- [x] add a "create blueprint" button + - [x] when clicked: + - [x] create collection + - [x] add an empty inside collection and name it _components + - [x] add a **AutoExport** Boolean property to collection + - [x] add name imput(popup for name input ?) + +- [x] add a list of existing components/custom properties +- [x] add an "edit blueprint" section + - [x] only filled when there is ONE selection, and that selection is a collection + - [x] add a dropdown of possible components + - [x] add a checkbox for enabling disabling a component (enabled by default) + - [x] add a button for copying a component + - [x] add a button for pasting a component + + +UI: + - [x] filterable list of components to DISPLAY for selection : ComponentDefinitionsList + +- Filter out invalid objects for components that have no _components suffix ? (that is too limiting I think) +- -[x] How to deal with pre-existing custom properties that have NO metadata + * if there is one without metadata: find if there is an available component with the same name & type ? + * if there is , insert metadata + * otherwise, mark it in some way visually ? + +- [x] for OBJECT enums: add two ui pieces + - [x] one for selecting the TYPE to choose (ie normal enum) + - [x] one for setting the VALUE inside that + + +- [x] vecs => (not vec2, vec3 etc) more complex UI to add items in a list + - [x] generate contained CollectionGroup + - [x] CollectionProperty => type = the above +- [x] find ways to "collapse" the different levels of nested data of structs/tupples into a single custom property (ideally on the fly, but we can do without) + +- [x] for single tupple components that represent a single unit type, re_use the base type's UIPropertyGroup instead of creating specific ones (ie TuppleTestF32_ui...) => will not work, would cause overriden "update callback" +- [x] pre_generate default values/values for each main type + +- [x] fix issues with vec2 etc not having the correct number of items +- [x] fix bad defaults in ui group +- [x] fix object enums handling on updates (??) +- [x] fix issues with lambads in loops + +- [x] object enum should be (params) + ie *Collider: + * Cuboid(Vec3) + * Sphere(radius) +- [x] deal with enums variants that do not have any data: ex { + "title": "Mesh" + } + +- [x] remove / change use of ComponentDefinitionsList + - when filling the list, use the long_name as index ie items.append((str(index), item.name, item.long_name)) => items.append((item.long_name, item.name, item.long_name)) +- [x] when removing a component, reset the value of the attribute in the property group (or not ? could be a feature) +- [x] deal correctly with fields of types that are NOT in the schema.json (for ex PlayingAnimation in AnimationPlayer) +- [ ] deal correctly with complex types + CascadeShadowConfig: has an array/list + ClusterConfig: one of the enum variants is an object +- [ ] possibly allow Color to be an enum as it should be ? +- [x] for sub items , the update functions "Name" should be the one of the root object +- [x] fix copy & pasting + - it actually works, but the value of the custom property are not copied back to the UI, need to implement property_group_value_from_custom_property_value +- [ ] we need a notion of "root propertyGroup" =? +- [x] notify user of missing entries in schema (ie , unregistered data types) +- [x] clarify propgroup_ui vs named nested fields +- [x] fix basic enums handling +- [x] add a list of not found components to the registry, add to them on the fly +- [x] add configuration panel (open the first time, closed on further user once configured) + +- [x] add limits to ixxx types vs utypes +- [x] only display the "generate components xx" when relevant ie: + - go through list of custom properties in current object + - if one does not have metadata and / or propgroup: + break + +- [x] remove custom property of disabled component ? => NOpe, as we need custom properties to iterate over +- [x] what to do with components with n/a fields ? perhaps disable the component ? add a "invalid" field to meta ? +- [x] format output as correct RON + - [x] fix issue with empty strings +- [x] change custom property => propGroup to convert RON => Json first => obsolete +- [x] cleanup process_lists + +- [x] fix issues with enum variants with only a title + +- [x] display single item enums inline, others in a seperate row + +- [x] add button to "apply all" (in configuration), to apply/update all custom properties to ALL objects where relevant +- [x] add button to "apply to current" to do the same with current +- [x] add warning sign to the above + +- [x] what about metadata ? +- [x] only upgrade custom properties to metadata when asked/relevant +- [x] implement move list up/down +- [ ] change property_group_value_from_custom_property_value => just disregard it for now, its point is very limited (helping people with old custom properties by attempting to generate real values) + and give the change to a real ron format, it is too limiting +- [x] fix reload registry clearing list of missing types +- [x] clean up metadata module, a lot of repeated code +- [x] some fields when original is 0 or 0.0 are not copyable ? (seems like a bad boolean check ) +- [x] fix issues with object variants in enums (see clusterconfig) + + +- perhaps directly export default values within the schema.json ? + - for most types , it is straighforward, but others, not so much: like the default color in Bevy , etc + +- [x] change default schema.json to registry.json +- [x] pasted components do not get updated value in custom_property +- [x] finish documentation +- [x] add storage of registry path + - [x] save after setting the data (browse for) + - [x] load after each reload ? + +# Additional + - [x] check if output "string" in custom properties are correct + + - gltf_auto_export + - [ ] add support for "enabled" flag + - [ ] add special components + - "AutoExport" => Needed + - "Dynamic" ? naah wait that should be exported by the Bevy side + - [ ] filter out Components_meta ?? + - [x] add legacy mode to the persisted parameters + + - bevy_gltf_components: + - [x] first release patch for current issues + - [x] make configurable + - [x] add "compatibility mode" and deprecation warnings for the current hack-ish conversion of fake ron + - [x] update docs to show we need to use ComponentsFromGltfPlugin::default + + - bevy_gltf_blueprints + - [x] update dependency + - [x] update version + - [x] add ability to set legacy mode for bevy_gltf_components ? + + - [ ] release all versions + - [ ] update main documentation, add compatibility version grid + + \ No newline at end of file diff --git a/tools/bevy_components/__init__.py b/tools/bevy_components/__init__.py new file mode 100644 index 0000000..b63f3eb --- /dev/null +++ b/tools/bevy_components/__init__.py @@ -0,0 +1,143 @@ +bl_info = { + "name": "bevy_components", + "author": "kaosigh", + "version": (0, 1, 0), + "blender": (3, 4, 0), + "location": "VIEW_3D", + "description": "UI to help create Bevy blueprints and components", + "warning": "", + "wiki_url": "https://github.com/kaosat-dev/Blender_bevy_components_workflow", + "tracker_url": "https://github.com/kaosat-dev/Blender_bevy_components_workflow/issues/new", + "category": "User Interface" +} + +import bpy +from bpy.props import (StringProperty) + +from .helpers import load_settings +from .blueprints import CreateBlueprintOperator +from .components.operators import CopyComponentOperator, DeleteComponentOperator, GenerateComponent_From_custom_property_Operator, PasteComponentOperator, AddComponentOperator, Toggle_ComponentVisibility + +from .registry.registry import ComponentsRegistry,MissingBevyType +from .registry.operators import (COMPONENTS_OT_REFRESH_CUSTOM_PROPERTIES_ALL, COMPONENTS_OT_REFRESH_CUSTOM_PROPERTIES_CURRENT, ReloadRegistryOperator, OT_OpenFilebrowser) +from .registry.ui import (BEVY_COMPONENTS_PT_Configuration, BEVY_COMPONENTS_PT_MissingTypesPanel, MISSING_TYPES_UL_List) + +from .components.metadata import (ComponentInfos, ComponentsMeta, ensure_metadata_for_all_objects) +from .propGroups.prop_groups import (generate_propertyGroups_for_components) +from .components.lists import GENERIC_LIST_OT_actions, Generic_LIST_OT_AddItem, Generic_LIST_OT_RemoveItem, Generic_LIST_OT_SelectItem +from .components.definitions_list import (ComponentDefinitionsList, ClearComponentDefinitionsList) +from .components.ui import (BEVY_COMPONENTS_PT_ComponentsPanel) + + +# just a test, remove +def scan_item(item, nesting=0): + try: + for sub in dict(item).keys(): + print("--", sub, getattr(item[sub], "type_name", None), item[sub], nesting) + try: + scan_item(item[sub], nesting+1) + except: + pass + except: + pass + +class BEVY_COMPONENTS_PT_MainPanel(bpy.types.Panel): + bl_idname = "BEVY_COMPONENTS_PT_MainPanel" + bl_label = "" + bl_space_type = 'VIEW_3D' + bl_region_type = 'UI' + bl_category = "Bevy Components" + bl_context = "objectmode" + + + def draw_header(self, context): + layout = self.layout + name = context.object.name if context.object != None else '' + layout.label(text="Components For "+ name) + + def draw(self, context): + layout = self.layout + object = context.object + collection = context.collection + + + """row.prop(bpy.context.window_manager, "blueprint_name") + op = row.operator(CreateBlueprintOperator.bl_idname, text="Create blueprint", icon="CONSOLE") + op.blueprint_name = bpy.context.window_manager.blueprint_name + layout.separator() + + current_components_container = None + has_components = False + for child in collection.objects: + if child.name.endswith("_components"): + has_components = True + current_components_container= child + + if collection is not None and has_components: + layout.label(text="Edit blueprint: "+ collection.name) + + """ + + + +#_register, _unregister = bpy.utils.register_classes_factory(classes) +classes = [ + CreateBlueprintOperator, + AddComponentOperator, + CopyComponentOperator, + PasteComponentOperator, + DeleteComponentOperator, + GenerateComponent_From_custom_property_Operator, + Toggle_ComponentVisibility, + + ComponentDefinitionsList, + ClearComponentDefinitionsList, + + ComponentInfos, + ComponentsMeta, + MissingBevyType, + ComponentsRegistry, + + OT_OpenFilebrowser, + ReloadRegistryOperator, + COMPONENTS_OT_REFRESH_CUSTOM_PROPERTIES_ALL, + COMPONENTS_OT_REFRESH_CUSTOM_PROPERTIES_CURRENT, + + BEVY_COMPONENTS_PT_MainPanel, + BEVY_COMPONENTS_PT_ComponentsPanel, + BEVY_COMPONENTS_PT_Configuration, + MISSING_TYPES_UL_List, + BEVY_COMPONENTS_PT_MissingTypesPanel, + + Generic_LIST_OT_SelectItem, + Generic_LIST_OT_AddItem, + Generic_LIST_OT_RemoveItem, + GENERIC_LIST_OT_actions +] + +from bpy.app.handlers import persistent + +@persistent +def post_load(file_name): + print("post load", file_name) + registry = bpy.context.window_manager.components_registry + registry.schemaPath = load_settings(registry.settings_save_path)["schemaPath"] + registry.load_schema() + generate_propertyGroups_for_components() + ensure_metadata_for_all_objects() + + +def register(): + for cls in classes: + bpy.utils.register_class(cls) + bpy.types.WindowManager.blueprint_name = StringProperty() + + bpy.app.handlers.load_post.append(post_load) + +def unregister(): + for cls in classes: + bpy.utils.unregister_class(cls) + del bpy.types.WindowManager.blueprint_name + + bpy.app.handlers.load_post.remove(post_load) + diff --git a/tools/bevy_components/blueprints.py b/tools/bevy_components/blueprints.py new file mode 100644 index 0000000..c4deec4 --- /dev/null +++ b/tools/bevy_components/blueprints.py @@ -0,0 +1,41 @@ + +import json +import bpy +from bpy_types import Operator +from bpy.props import (StringProperty) + +from .helpers import make_empty + +class CreateBlueprintOperator(Operator): + """Creates blueprint""" + bl_idname = "object.simple_operator" + bl_label = "Simple Object Operator" + + blueprint_name: StringProperty( + name="blueprint name", + description="blueprint name to add", + default="NewBlueprint" + ) + + + def execute(self, context): + blueprint_name = self.blueprint_name + if blueprint_name == '': + blueprint_name = "NewBlueprint" + collection = bpy.data.collections.new(blueprint_name) + bpy.context.scene.collection.children.link(collection) + collection['AutoExport'] = True + + # this is in order to deal with automatic naming + blueprint_name = collection.name + + components_empty = make_empty(blueprint_name + "_components", [0,0,0], [0,0,0], [0,0,0], bpy.context.scene.collection) + bpy.ops.collection.objects_remove_all() + + collection.objects.link(components_empty) + + components_empty.select_set(True) + bpy.context.view_layer.objects.active = components_empty + + return {'FINISHED'} + diff --git a/tools/gltf_auto_export/ui/__init__.py b/tools/bevy_components/components/__init__.py similarity index 100% rename from tools/gltf_auto_export/ui/__init__.py rename to tools/bevy_components/components/__init__.py diff --git a/tools/bevy_components/components/definitions_list.py b/tools/bevy_components/components/definitions_list.py new file mode 100644 index 0000000..4ad8137 --- /dev/null +++ b/tools/bevy_components/components/definitions_list.py @@ -0,0 +1,56 @@ +import bpy +from bpy.props import (StringProperty) + +# this one is for UI only, and its inner list contains a useable list of shortnames of components +class ComponentDefinitionsList(bpy.types.PropertyGroup): + + # FIXME: not sure, hard coded exclude list, feels wrong + exclude = ['Parent', 'Children'] + + def add_component_to_ui_list(self, context): + #print("add components to ui_list") + items = [] + type_infos = context.window_manager.components_registry.type_infos + short_names = context.window_manager.components_registry.short_names_to_long_names + for short_name in sorted(short_names.keys()): + long_name = short_names[short_name] + definition = type_infos[long_name] + is_component = definition['isComponent'] if "isComponent" in definition else False + + if self.filter in short_name and is_component: + if not 'Handle' in short_name and not "Cow" in short_name and not "AssetId" in short_name and short_name not in self.exclude: # FIXME: hard coded, seems wrong + items.append((long_name, short_name, long_name)) + return items + + @classmethod + def register(cls): + bpy.types.WindowManager.components_list = bpy.props.PointerProperty(type=ComponentDefinitionsList) + + @classmethod + def unregister(cls): + del bpy.types.WindowManager.components_list + + list : bpy.props.EnumProperty( + name="list", + description="list", + # items argument required to initialize, just filled with empty values + items = add_component_to_ui_list, + ) + filter: StringProperty( + name="component filter", + description="filter for the components list", + options={'TEXTEDIT_UPDATE'} + ) + + +class ClearComponentDefinitionsList(bpy.types.Operator): + ''' clear list of bpy.context.collection.component_definitions ''' + bl_label = "clear component definitions" + bl_idname = "components.clear_component_definitions" + + def execute(self, context): + # create a new item, assign its properties + bpy.context.collection.component_definitions.clear() + + return {'FINISHED'} + diff --git a/tools/bevy_components/components/lists.py b/tools/bevy_components/components/lists.py new file mode 100644 index 0000000..f16421d --- /dev/null +++ b/tools/bevy_components/components/lists.py @@ -0,0 +1,170 @@ +import json +from bpy_types import Operator, UIList +from bpy.props import (StringProperty, EnumProperty, PointerProperty, FloatVectorProperty, IntProperty) + +class Generic_LIST_OT_AddItem(Operator): + """Add a new item to the list.""" + bl_idname = "generic_list.add_item" + bl_label = "Add a new item" + + property_group_path: StringProperty( + name="property group path", + description="", + ) + + component_name: StringProperty( + name="component name", + description="", + ) + + def execute(self, context): + print("") + object = context.object + # information is stored in component meta + components_in_object = object.components_meta.components + component_meta = next(filter(lambda component: component["name"] == self.component_name, components_in_object), None) + + propertyGroup = component_meta + for path_item in json.loads(self.property_group_path): + propertyGroup = getattr(propertyGroup, path_item) + + print("list container", propertyGroup, dict(propertyGroup)) + target_list = getattr(propertyGroup, "list") + index = getattr(propertyGroup, "list_index") + item = target_list.add() + propertyGroup.list_index = index + 1 # we use this to force the change detection + + print("added item", item, item.field_names, getattr(item, "field_names")) + print("") + return{'FINISHED'} + + +class Generic_LIST_OT_RemoveItem(Operator): + """Remove an item to the list.""" + bl_idname = "generic_list.remove_item" + bl_label = "Remove selected item" + + property_group_path: StringProperty( + name="property group path", + description="", + ) + + component_name: StringProperty( + name="component name", + description="", + ) + def execute(self, context): + print("remove from list", context.object) + + object = context.object + # information is stored in component meta + components_in_object = object.components_meta.components + component_meta = next(filter(lambda component: component["name"] == self.component_name, components_in_object), None) + + propertyGroup = component_meta + for path_item in json.loads(self.property_group_path): + propertyGroup = getattr(propertyGroup, path_item) + + target_list = getattr(propertyGroup, "list") + index = getattr(propertyGroup, "list_index") + target_list.remove(index) + propertyGroup.list_index = min(max(0, index - 1), len(target_list) - 1) + return{'FINISHED'} + + +class Generic_LIST_OT_SelectItem(Operator): + """Remove an item to the list.""" + bl_idname = "generic_list.select_item" + bl_label = "select an item" + + + property_group_path: StringProperty( + name="property group path", + description="", + ) + + component_name: StringProperty( + name="component name", + description="", + ) + + selection_index: IntProperty() + + def execute(self, context): + print("select in list", context.object) + + object = context.object + # information is stored in component meta + components_in_object = object.components_meta.components + component_meta = next(filter(lambda component: component["name"] == self.component_name, components_in_object), None) + + propertyGroup = component_meta + for path_item in json.loads(self.property_group_path): + propertyGroup = getattr(propertyGroup, path_item) + + target_list = getattr(propertyGroup, "list") + index = getattr(propertyGroup, "list_index") + + propertyGroup.list_index = self.selection_index + return{'FINISHED'} + + +class GENERIC_LIST_OT_actions(Operator): + """Move items up and down, add and remove""" + bl_idname = "generic_list.list_action" + bl_label = "List Actions" + bl_description = "Move items up and down, add and remove" + bl_options = {'REGISTER', 'UNDO'} + + action: EnumProperty( + items=( + ('UP', "Up", ""), + ('DOWN', "Down", ""), + ('REMOVE', "Remove", ""), + ('ADD', "Add", ""))) + + property_group_path: StringProperty( + name="property group path", + description="", + ) + + component_name: StringProperty( + name="component name", + description="", + ) + + def invoke(self, context, event): + object = context.object + # information is stored in component meta + components_in_object = object.components_meta.components + component_meta = next(filter(lambda component: component["name"] == self.component_name, components_in_object), None) + + propertyGroup = component_meta + for path_item in json.loads(self.property_group_path): + propertyGroup = getattr(propertyGroup, path_item) + + target_list = getattr(propertyGroup, "list") + index = getattr(propertyGroup, "list_index") + + + if self.action == 'DOWN' and index < len(target_list) - 1: + #item_next = scn.rule_list[index + 1].name + target_list.move(index, index + 1) + propertyGroup.list_index += 1 + + elif self.action == 'UP' and index >= 1: + #item_prev = scn.rule_list[index - 1].name + target_list.move(index, index - 1) + propertyGroup.list_index -= 1 + + elif self.action == 'REMOVE': + target_list.remove(index) + propertyGroup.list_index = min(max(0, index - 1), len(target_list) - 1) + + if self.action == 'ADD': + item = target_list.add() + propertyGroup.list_index = index + 1 # we use this to force the change detection + #info = '"%s" added to list' % (item.name) + #self.report({'INFO'}, info) + + return {"FINISHED"} \ No newline at end of file diff --git a/tools/bevy_components/components/metadata.py b/tools/bevy_components/components/metadata.py new file mode 100644 index 0000000..666a343 --- /dev/null +++ b/tools/bevy_components/components/metadata.py @@ -0,0 +1,236 @@ +import bpy +from bpy.props import (StringProperty, BoolProperty, PointerProperty) +from bpy_types import (PropertyGroup) +from ..propGroups.conversions import property_group_value_from_custom_property_value, property_group_value_to_custom_property_value + +class ComponentInfos(bpy.types.PropertyGroup): + name : bpy.props.StringProperty( + name = "name", + default = "" + ) + + long_name : bpy.props.StringProperty( + name = "long name", + default = "" + ) + + type_name : bpy.props.StringProperty( + name = "Type", + default = "" + ) + + values: bpy.props.StringProperty( + name = "Value", + default = "" + ) + + enabled: BoolProperty( + name="enabled", + description="component enabled", + default=True + ) + + invalid: BoolProperty( + name="invalid", + description="component is invalid, because of missing registration/ other issues", + default=False + ) + + invalid_details: StringProperty( + name="invalid details", + description="detailed information about why the component is invalid", + default="" + ) + + visible: BoolProperty( # REALLY dislike doing this for UI control, but ok hack for now + default=True + ) + +class ComponentsMeta(PropertyGroup): + infos_per_component: StringProperty( + name="infos per component", + description="component" + ) + components: bpy.props.CollectionProperty(type = ComponentInfos) + + @classmethod + def register(cls): + bpy.types.Object.components_meta = PointerProperty(type=ComponentsMeta) + + @classmethod + def unregister(cls): + del bpy.types.Object.components_meta + +# We need a collection property of components PER object +def get_component_metadata_by_short_name(object, short_name): + if not "components_meta" in object: + return None + return next(filter(lambda component: component["name"] == short_name, object.components_meta.components), None) + +# remove no longer valid metadata from object +def cleanup_invalid_metadata(object): + components_metadata = object.components_meta.components + to_remove = [] + for index, component_meta in enumerate(components_metadata): + short_name = component_meta.name + if short_name not in object.keys(): + print("component:", short_name, "present in metadata, but not in object") + to_remove.append(index) + for index in to_remove: + components_metadata.remove(index) + + +# returns a component definition ( an entry in registry's type_infos) with matching short name or None if nothing has been found +def find_component_definition_from_short_name(short_name): + registry = bpy.context.window_manager.components_registry + long_name = registry.short_names_to_long_names.get(short_name, None) + if long_name != None: + return registry.type_infos.get(long_name, None) + return None + +# FIXME: feels a bit heavy duty, should only be done +# if the components panel is active ? +def ensure_metadata_for_all_objects(): + for object in bpy.data.objects: + add_metadata_to_components_without_metadata(object) + +# returns whether an object has custom properties without matching metadata +def do_object_custom_properties_have_missing_metadata(object): + components_metadata = getattr(object, "components_meta", None) + if components_metadata == None: + return True + + components_metadata = components_metadata.components + + missing_metadata = False + for component_name in dict(object) : + if component_name == "components_meta": + continue + component_meta = next(filter(lambda component: component["name"] == component_name, components_metadata), None) + if component_meta == None: + # current component has no metadata but is there even a compatible type in the registry ? + # if not ignore it + component_definition = find_component_definition_from_short_name(component_name) + if component_definition != None: + missing_metadata = True + break + + return missing_metadata + + +# adds metadata to object only if it is missing +def add_metadata_to_components_without_metadata(object): + registry = bpy.context.window_manager.components_registry + + for component_name in dict(object) : + if component_name == "components_meta": + continue + upsert_component_in_object(object, component_name, registry) + +# adds a component to an object (including metadata) using the provided component definition & optional value +def add_component_to_object(object, component_definition, value=None): + cleanup_invalid_metadata(object) + if object is not None: + print("add_component_to_object", component_definition) + long_name = component_definition["title"] + short_name = component_definition["short_name"] + registry = bpy.context.window_manager.components_registry + if registry.type_infos == None: + raise Exception('registry type infos have not been loaded yet or ar missing !') + definition = registry.type_infos[long_name] + # now we use our pre_generated property groups to set the initial value of our custom property + (_, propertyGroup) = upsert_component_in_object(object, component_name=short_name, registry=registry) + if value == None: + value = property_group_value_to_custom_property_value(propertyGroup, definition, registry, None) + else: # we have provided a value, that is a raw , custom property value, to set the value of the propertyGroup + object["__disable__update"] = True # disable update callback while we set the values of the propertyGroup "tree" (as a propertyGroup can contain other propertyGroups) + property_group_value_from_custom_property_value(propertyGroup, definition, registry, value) + del object["__disable__update"] + + object[short_name] = value + +def upsert_component_in_object(object, component_name, registry): + # print("upsert_component_in_object", object, "component name", component_name) + # TODO: upsert this part too ? + target_components_metadata = object.components_meta.components + component_definition = find_component_definition_from_short_name(component_name) + if component_definition != None: + short_name = component_definition["short_name"] + long_name = component_definition["title"] + property_group_name = short_name+"_ui" + propertyGroup = None + + component_meta = next(filter(lambda component: component["name"] == short_name, target_components_metadata), None) + if not component_meta: + component_meta = target_components_metadata.add() + component_meta.name = short_name + component_meta.long_name = long_name + propertyGroup = getattr(component_meta, property_group_name, None) + else: # this one has metadata but we check that the relevant property group is present + propertyGroup = getattr(component_meta, property_group_name, None) + + # try to inject propertyGroup if not present + if propertyGroup == None: + #print("propertygroup not found in metadata attempting to inject") + if property_group_name in registry.component_propertyGroups: + # we have found a matching property_group, so try to inject it + # now inject property group + setattr(ComponentInfos, property_group_name, registry.component_propertyGroups[property_group_name]) # FIXME: not ideal as all ComponentInfos get the propGroup, but have not found a way to assign it per instance + propertyGroup = getattr(component_meta, property_group_name, None) + + # now deal with property groups details + if propertyGroup != None: + if short_name in registry.invalid_components: + component_meta.enabled = False + component_meta.invalid = True + component_meta.invalid_details = "component contains fields that are not in the schema, disabling" + else: + # if we still have not found the property group, mark it as invalid + component_meta.enabled = False + component_meta.invalid = True + component_meta.invalid_details = "component not present in the schema, possibly renamed? Disabling for now" + # property_group_value_from_custom_property_value(propertyGroup, component_definition, registry, object[component_name]) + + return (component_meta, propertyGroup) + else: + return(None, None) + + +def copy_propertyGroup_values_to_another_object(source_object, target_object, component_name): + if source_object == None or target_object == None or component_name == None: + raise Exception('missing input data, cannot copy component propertryGroup') + + component_definition = find_component_definition_from_short_name(component_name) + short_name = component_definition["short_name"] + property_group_name = short_name+"_ui" + registry = bpy.context.window_manager.components_registry + + source_components_metadata = source_object.components_meta.components + source_componentMeta = next(filter(lambda component: component["name"] == short_name, source_components_metadata), None) + # matching component means we already have this type of component + source_propertyGroup = getattr(source_componentMeta, property_group_name) + + # now deal with the target object + (_, target_propertyGroup) = upsert_component_in_object(target_object, component_name, registry) + # add to object + value = property_group_value_to_custom_property_value(target_propertyGroup, component_definition, registry, None) + target_object[short_name] = value + + # copy the values over + for field_name in source_propertyGroup.field_names: + if field_name in source_propertyGroup: + target_propertyGroup[field_name] = source_propertyGroup[field_name] + apply_propertyGroup_values_to_object_customProperties(target_object) + +# TODO: move to propgroups ? +def apply_propertyGroup_values_to_object_customProperties(object): + cleanup_invalid_metadata(object) + registry = bpy.context.window_manager.components_registry + for component_name in dict(object) : + if component_name == "components_meta": + continue + (_, propertyGroup) = upsert_component_in_object(object, component_name, registry) + component_definition = find_component_definition_from_short_name(component_name) + if component_definition != None: + value = property_group_value_to_custom_property_value(propertyGroup, component_definition, registry, None) + object[component_name] = value diff --git a/tools/bevy_components/components/operators.py b/tools/bevy_components/components/operators.py new file mode 100644 index 0000000..8c2c3df --- /dev/null +++ b/tools/bevy_components/components/operators.py @@ -0,0 +1,153 @@ +import ast +import json +import bpy +from bpy_types import Operator +from bpy.props import (StringProperty) +from .metadata import add_component_to_object, add_metadata_to_components_without_metadata, copy_propertyGroup_values_to_another_object, find_component_definition_from_short_name + +class AddComponentOperator(Operator): + """Add component to blueprint""" + bl_idname = "object.addblueprint_to_component" + bl_label = "Add component to blueprint Operator" + bl_options = {"UNDO"} + + component_type: StringProperty( + name="component_type", + description="component type to add", + ) + + def execute(self, context): + print("adding component to blueprint", self.component_type) + object = context.object + + has_component_type = self.component_type != "" + if has_component_type and object != None: + type_infos = context.window_manager.components_registry.type_infos + component_definition = type_infos[self.component_type] + add_component_to_object(object, component_definition) + + return {'FINISHED'} + +class CopyComponentOperator(Operator): + """Copy component from blueprint""" + bl_idname = "object.copy_component" + bl_label = "Copy component Operator" + bl_options = {"UNDO"} + + source_component_name: StringProperty( + name="source component_name", + description="name of the component to copy", + ) + + source_object_name: StringProperty( + name="source object name", + description="name of the object to copy the component from", + ) + + @classmethod + def register(cls): + bpy.types.WindowManager.copied_source_component_name = StringProperty() + bpy.types.WindowManager.copied_source_object = StringProperty() + + @classmethod + def unregister(cls): + del bpy.types.WindowManager.copied_source_component_name + del bpy.types.WindowManager.copied_source_object + + + def execute(self, context): + if self.source_component_name != '' and self.source_object_name != "": + context.window_manager.copied_source_component_name = self.source_component_name + context.window_manager.copied_source_object = self.source_object_name + else: + self.report({"ERROR"}, "The source object name / component name to copy a component from have not been specified") + + return {'FINISHED'} + + +class PasteComponentOperator(Operator): + """Paste component to blueprint""" + bl_idname = "object.paste_component" + bl_label = "Paste component to blueprint Operator" + bl_options = {"UNDO"} + + def execute(self, context): + source_object_name = context.window_manager.copied_source_object + source_object = bpy.data.objects.get(source_object_name, None) + print("source object", source_object) + if source_object == None: + self.report({"ERROR"}, "The source object to copy a component from does not exist") + else: + component_name = context.window_manager.copied_source_component_name + if not component_name in source_object: + self.report({"ERROR"}, "The source component to copy a component from does not exist") + else: + component_value = source_object[component_name] + print("pasting component to object: component name:", str(component_name), "component value:" + str(component_value)) + print (context.object) + copy_propertyGroup_values_to_another_object(source_object, context.object, component_name) + + return {'FINISHED'} + + + +class DeleteComponentOperator(Operator): + """Delete component from blueprint""" + bl_idname = "object.delete_component" + bl_label = "Delete component from blueprint Operator" + bl_options = {"UNDO"} + + component_name: StringProperty( + name="component name", + description="component to delete", + ) + + def execute(self, context): + object = context.object + if object is not None and self.component_name in object: + del object[self.component_name] + else: + self.report({"ERROR"}, "The object/ component to remove does not exist") + + return {'FINISHED'} + + +class GenerateComponent_From_custom_property_Operator(Operator): + """generate components from custom property""" + bl_idname = "object.generate_component" + bl_label = "Generate component from custom_property Operator" + bl_options = {"UNDO"} + + component_name: StringProperty( + name="component name", + description="component to generate custom properties for", + ) + + def execute(self, context): + object = context.object + add_metadata_to_components_without_metadata(object) + + return {'FINISHED'} + + + +class Toggle_ComponentVisibility(Operator): + """toggles components visibility""" + bl_idname = "object.toggle_component_visibility" + bl_label = "Toggle component visibility" + bl_options = {"UNDO"} + + component_name: StringProperty( + name="component name", + description="component to toggle", + ) + + def execute(self, context): + object = context.object + components_in_object = object.components_meta.components + component_meta = next(filter(lambda component: component["name"] == self.component_name, components_in_object), None) + if component_meta != None: + component_meta.visible = not component_meta.visible + + return {'FINISHED'} + diff --git a/tools/bevy_components/components/ui.py b/tools/bevy_components/components/ui.py new file mode 100644 index 0000000..a169210 --- /dev/null +++ b/tools/bevy_components/components/ui.py @@ -0,0 +1,212 @@ +import json +import bpy +from .metadata import do_object_custom_properties_have_missing_metadata +from .operators import AddComponentOperator, CopyComponentOperator, DeleteComponentOperator, GenerateComponent_From_custom_property_Operator, PasteComponentOperator, Toggle_ComponentVisibility + +def draw_propertyGroup( propertyGroup, layout, nesting =[], rootName=None): + is_enum = getattr(propertyGroup, "with_enum") + is_list = getattr(propertyGroup, "with_list") + #current_short_name = getattr(propertyGroup, "short_name", "") + "_ui" + #nesting = nesting + [current_short_name] # we need this convoluted "nested path strings " workaround so that operators working on a given + # item in our components hierarchy can get the correct propertyGroup by STRINGS because of course, we cannot pass objects to operators...sigh + + # if it is an enum, the first field name is always the list of enum variants, the others are the variants + field_names = propertyGroup.field_names + #print("") + #print("drawing", propertyGroup, nesting, "component_name", rootName) + #type_name = getattr(propertyGroup, "type_name", None)#propertyGroup.type_name if "type_name" in propertyGroup else "" + #print("type name", type_name) + #print("name", propertyGroup.name, "name2", getattr(propertyGroup, "name"), "short_name", getattr(propertyGroup, "short_name", None), "nesting", nesting) + if is_enum: + subrow = layout.row() + display_name = field_names[0] if propertyGroup.tupple_or_struct == "struct" else "" + subrow.prop(propertyGroup, field_names[0], text=display_name) + subrow.separator() + selection = getattr(propertyGroup, field_names[0]) + + for fname in field_names[1:]: + if fname == "variant_" + selection: + subrow = layout.row() + display_name = fname if propertyGroup.tupple_or_struct == "struct" else "" + + nestedPropertyGroup = getattr(propertyGroup, fname) + nested = getattr(nestedPropertyGroup, "nested", False) + #print("nestedPropertyGroup", nestedPropertyGroup, fname, nested) + if nested: + draw_propertyGroup(nestedPropertyGroup, subrow.column(), nesting + [fname], rootName ) + # if an enum variant is not a propertyGroup + break + elif is_list: + #print("show list", propertyGroup, dict(propertyGroup), propertyGroup.type_name) + item_list = getattr(propertyGroup, "list") + item_type = getattr(propertyGroup, "type_name_short") + list_index = getattr(propertyGroup, "list_index") + box = layout.box() + split = box.split(factor=0.9) + list_column, buttons_column = (split.column(),split.column()) + + list_column = list_column.box() + for index, item in enumerate(item_list): + row = list_column.row() + draw_propertyGroup(item, row, nesting, rootName) + icon = 'CHECKBOX_HLT' if list_index == index else 'CHECKBOX_DEHLT' + op = row.operator('generic_list.select_item', icon=icon, text="") + op.component_name = rootName + op.property_group_path = json.dumps(nesting) + op.selection_index = index + + #various control buttons + buttons_column.separator() + row = buttons_column.row() + op = row.operator('generic_list.list_action', icon='ADD', text="") + op.action = 'ADD' + op.component_name = rootName + op.property_group_path = json.dumps(nesting) + + row = buttons_column.row() + op = row.operator('generic_list.list_action', icon='REMOVE', text="") + op.action = 'REMOVE' + op.component_name = rootName + op.property_group_path = json.dumps(nesting) + + buttons_column.separator() + row = buttons_column.row() + op = row.operator('generic_list.list_action', icon='TRIA_UP', text="") + op.action = 'UP' + op.component_name = rootName + op.property_group_path = json.dumps(nesting) + + row = buttons_column.row() + op = row.operator('generic_list.list_action', icon='TRIA_DOWN', text="") + op.action = 'DOWN' + op.component_name = rootName + op.property_group_path = json.dumps(nesting) + + else: + for fname in field_names: + subrow = layout.row() + nestedPropertyGroup = getattr(propertyGroup, fname) + nested = getattr(nestedPropertyGroup, "nested", False) + display_name = fname if propertyGroup.tupple_or_struct == "struct" else "" + + if nested: + layout.separator() + layout.label(text=display_name) # this is the name of the field/sub field + layout.separator() + draw_propertyGroup(nestedPropertyGroup, subrow.column(), nesting + [fname], rootName ) + else: + subrow.prop(propertyGroup, fname, text=display_name) + subrow.separator() + + +class BEVY_COMPONENTS_PT_ComponentsPanel(bpy.types.Panel): + bl_idname = "BEVY_COMPONENTS_PT_ComponentsPanel" + bl_label = "Components" + bl_space_type = 'VIEW_3D' + bl_region_type = 'UI' + bl_category = "Bevy Components" + bl_context = "objectmode" + bl_parent_id = "BEVY_COMPONENTS_PT_MainPanel" + + @classmethod + def poll(cls, context): + return (context.object is not None) + + def draw(self, context): + object = context.object + layout = self.layout + + # we get & load our component registry + registry = bpy.context.window_manager.components_registry + available_components = bpy.context.window_manager.components_list + + + if object is not None: + row = layout.row(align=True) + row.prop(available_components, "list", text="Component") + row.prop(available_components, "filter",text="Filter") + + # add components + row = layout.row(align=True) + op = row.operator(AddComponentOperator.bl_idname, text="Add", icon="ADD") + op.component_type = available_components.list + row.enabled = available_components.list != '' + + layout.separator() + + # paste components + row = layout.row(align=True) + row.operator(PasteComponentOperator.bl_idname, text="Paste component ("+bpy.context.window_manager.copied_source_component_name+")", icon="PASTEDOWN") + row.enabled = registry.type_infos != None and context.window_manager.copied_source_object != '' + + layout.separator() + + # upgrate custom props to components + upgradeable_customProperties = registry.type_infos != None and do_object_custom_properties_have_missing_metadata(context.object) + if upgradeable_customProperties: + row = layout.row(align=True) + op = row.operator(GenerateComponent_From_custom_property_Operator.bl_idname, text="generate components from custom properties" , icon="LOOP_FORWARDS") + layout.separator() + + + components_in_object = object.components_meta.components + for component_name in sorted(dict(object)) : # sorted by component name, practical + if component_name == "components_meta": + continue + # anything withouth metadata gets skipped, we only want to see real components, not all custom props + component_meta = next(filter(lambda component: component["name"] == component_name, components_in_object), None) + if component_meta == None: + continue + + component_invalid = getattr(component_meta, "invalid") + invalid_details = getattr(component_meta, "invalid_details") + component_visible = getattr(component_meta, "visible") + single_field = False + + # our whole row + box = layout.box() + row = box.row(align=True) + # "header" + row.alert = component_invalid + row.prop(component_meta, "enabled", text="") + row.label(text=component_name) + + # we fetch the matching ui property group + root_propertyGroup_name = component_name+"_ui" + propertyGroup = getattr(component_meta, root_propertyGroup_name, None) + if propertyGroup: + # if the component has only 0 or 1 field names, display inline, otherwise change layout + single_field = len(propertyGroup.field_names) < 2 + prop_group_location = box.row(align=True).column() + if single_field: + prop_group_location = row.column(align=True)#.split(factor=0.9)#layout.row(align=False) + + if component_visible: + if component_invalid: + error_message = invalid_details if component_invalid else "Missing component UI data, please reload registry !" + prop_group_location.label(text=error_message) + draw_propertyGroup(propertyGroup, prop_group_location, [root_propertyGroup_name], component_name) + else : + row.label(text="details hidden, click on toggle to display") + else: + error_message = invalid_details if component_invalid else "Missing component UI data, please reload registry !" + row.label(text=error_message) + + # "footer" with additional controls + op = row.operator(DeleteComponentOperator.bl_idname, text="", icon="X") + op.component_name = component_name + row.separator() + + op = row.operator(CopyComponentOperator.bl_idname, text="", icon="COPYDOWN") + op.source_component_name = component_name + op.source_object_name = object.name + row.separator() + + #if not single_field: + toggle_icon = "TRIA_DOWN" if component_visible else "TRIA_RIGHT" + op = row.operator(Toggle_ComponentVisibility.bl_idname, text="", icon=toggle_icon) + op.component_name = component_name + #row.separator() + + else: + layout.label(text ="Select an object to edit its components") diff --git a/tools/bevy_components/docs/add_component.png b/tools/bevy_components/docs/add_component.png new file mode 100644 index 0000000..3e0e3af Binary files /dev/null and b/tools/bevy_components/docs/add_component.png differ diff --git a/tools/bevy_components/docs/blender_addon_install.png b/tools/bevy_components/docs/blender_addon_install.png new file mode 100644 index 0000000..b694eb9 Binary files /dev/null and b/tools/bevy_components/docs/blender_addon_install.png differ diff --git a/tools/bevy_components/docs/blender_addon_install2.png b/tools/bevy_components/docs/blender_addon_install2.png new file mode 100644 index 0000000..e3c2a42 Binary files /dev/null and b/tools/bevy_components/docs/blender_addon_install2.png differ diff --git a/tools/bevy_components/docs/blender_addon_install_zip.png b/tools/bevy_components/docs/blender_addon_install_zip.png new file mode 100644 index 0000000..2c4ce38 Binary files /dev/null and b/tools/bevy_components/docs/blender_addon_install_zip.png differ diff --git a/tools/bevy_components/docs/complex_components2.png b/tools/bevy_components/docs/complex_components2.png new file mode 100644 index 0000000..ca53e24 Binary files /dev/null and b/tools/bevy_components/docs/complex_components2.png differ diff --git a/tools/bevy_components/docs/components_list.png b/tools/bevy_components/docs/components_list.png new file mode 100644 index 0000000..24aac01 Binary files /dev/null and b/tools/bevy_components/docs/components_list.png differ diff --git a/tools/bevy_components/docs/components_list2.png b/tools/bevy_components/docs/components_list2.png new file mode 100644 index 0000000..3d0a1dd Binary files /dev/null and b/tools/bevy_components/docs/components_list2.png differ diff --git a/tools/bevy_components/docs/configuration.png b/tools/bevy_components/docs/configuration.png new file mode 100644 index 0000000..0e2ec8a Binary files /dev/null and b/tools/bevy_components/docs/configuration.png differ diff --git a/tools/bevy_components/docs/configuration2.png b/tools/bevy_components/docs/configuration2.png new file mode 100644 index 0000000..41e3c54 Binary files /dev/null and b/tools/bevy_components/docs/configuration2.png differ diff --git a/tools/bevy_components/docs/configuration3.png b/tools/bevy_components/docs/configuration3.png new file mode 100644 index 0000000..5fae812 Binary files /dev/null and b/tools/bevy_components/docs/configuration3.png differ diff --git a/tools/bevy_components/docs/copy_component.png b/tools/bevy_components/docs/copy_component.png new file mode 100644 index 0000000..9e7efed Binary files /dev/null and b/tools/bevy_components/docs/copy_component.png differ diff --git a/tools/bevy_components/docs/edit_component.png b/tools/bevy_components/docs/edit_component.png new file mode 100644 index 0000000..f0b64d9 Binary files /dev/null and b/tools/bevy_components/docs/edit_component.png differ diff --git a/tools/bevy_components/docs/edit_component2.png b/tools/bevy_components/docs/edit_component2.png new file mode 100644 index 0000000..76f5697 Binary files /dev/null and b/tools/bevy_components/docs/edit_component2.png differ diff --git a/tools/bevy_components/docs/enums.png b/tools/bevy_components/docs/enums.png new file mode 100644 index 0000000..8de77cc Binary files /dev/null and b/tools/bevy_components/docs/enums.png differ diff --git a/tools/bevy_components/docs/enums2.png b/tools/bevy_components/docs/enums2.png new file mode 100644 index 0000000..c3f29f4 Binary files /dev/null and b/tools/bevy_components/docs/enums2.png differ diff --git a/tools/bevy_components/docs/filter_components.png b/tools/bevy_components/docs/filter_components.png new file mode 100644 index 0000000..adb2c32 Binary files /dev/null and b/tools/bevy_components/docs/filter_components.png differ diff --git a/tools/bevy_components/docs/invalid_components.png b/tools/bevy_components/docs/invalid_components.png new file mode 100644 index 0000000..e6bdae6 Binary files /dev/null and b/tools/bevy_components/docs/invalid_components.png differ diff --git a/tools/bevy_components/docs/missing_registry_data.png b/tools/bevy_components/docs/missing_registry_data.png new file mode 100644 index 0000000..59e91aa Binary files /dev/null and b/tools/bevy_components/docs/missing_registry_data.png differ diff --git a/tools/bevy_components/docs/other_options.png b/tools/bevy_components/docs/other_options.png new file mode 100644 index 0000000..9eba317 Binary files /dev/null and b/tools/bevy_components/docs/other_options.png differ diff --git a/tools/bevy_components/docs/other_options2.png b/tools/bevy_components/docs/other_options2.png new file mode 100644 index 0000000..d08a5ce Binary files /dev/null and b/tools/bevy_components/docs/other_options2.png differ diff --git a/tools/bevy_components/docs/paste_component.png b/tools/bevy_components/docs/paste_component.png new file mode 100644 index 0000000..ee58fad Binary files /dev/null and b/tools/bevy_components/docs/paste_component.png differ diff --git a/tools/bevy_components/docs/toggle_details.png b/tools/bevy_components/docs/toggle_details.png new file mode 100644 index 0000000..4fe3116 Binary files /dev/null and b/tools/bevy_components/docs/toggle_details.png differ diff --git a/tools/bevy_components/docs/unregistered_types.png b/tools/bevy_components/docs/unregistered_types.png new file mode 100644 index 0000000..ad8e69b Binary files /dev/null and b/tools/bevy_components/docs/unregistered_types.png differ diff --git a/tools/bevy_components/docs/vecs_lists.png b/tools/bevy_components/docs/vecs_lists.png new file mode 100644 index 0000000..8c99755 Binary files /dev/null and b/tools/bevy_components/docs/vecs_lists.png differ diff --git a/tools/bevy_components/helpers.py b/tools/bevy_components/helpers.py new file mode 100644 index 0000000..ad4d662 --- /dev/null +++ b/tools/bevy_components/helpers.py @@ -0,0 +1,31 @@ +import bpy +import json + +# Makes an empty, at the specified location, rotation, scale stores it in existing collection, from https://blender.stackexchange.com/questions/51290/how-to-add-empty-object-not-using-bpy-ops +def make_empty(name, location, rotation, scale, collection): + object_data = None + empty_obj = bpy.data.objects.new( name, object_data ) + + empty_obj.empty_display_size = 2 + empty_obj.empty_display_type = 'PLAIN_AXES' + + empty_obj.name = name + empty_obj.location = location + empty_obj.scale = scale + empty_obj.rotation_euler = rotation + + collection.objects.link( empty_obj ) + #bpy.context.view_layer.update() + return empty_obj + +#".gltf_auto_export_settings" +def upsert_settings(name, data): + stored_settings = bpy.data.texts[name] if name in bpy.data.texts else bpy.data.texts.new(name) + stored_settings.clear() + stored_settings.write(json.dumps(data)) + +def load_settings(name): + stored_settings = bpy.data.texts[name] if name in bpy.data.texts else None + if stored_settings != None: + return json.loads(stored_settings.as_string()) + return None diff --git a/tools/bevy_components/propGroups/__init__.py b/tools/bevy_components/propGroups/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tools/bevy_components/propGroups/conversions.py b/tools/bevy_components/propGroups/conversions.py new file mode 100644 index 0000000..57e3697 --- /dev/null +++ b/tools/bevy_components/propGroups/conversions.py @@ -0,0 +1,221 @@ +import json +from bpy_types import PropertyGroup + + +conversion_tables = { + "bool": lambda value: value, + + "char": lambda value: '"'+value+'"', + "str": lambda value: '"'+value+'"', + "alloc::string::String": lambda value: '"'+value+'"', + + "glam::Vec2": lambda value: "Vec2(x:"+str(value[0])+ ", y:"+str(value[1])+")", + "glam::DVec2": lambda value: "DVec2(x:"+str(value[0])+ ", y:"+str(value[1])+")", + "glam::UVec2": lambda value: "UVec2(x:"+str(value[0])+ ", y:"+str(value[1])+")", + + "glam::Vec3": lambda value: "Vec3(x:"+str(value[0])+ ", y:"+str(value[1])+ ", z:"+str(value[2])+")", + "glam::Vec3A": lambda value: "Vec3A(x:"+str(value[0])+ ", y:"+str(value[1])+ ", z:"+str(value[2])+")", + "glam::UVec3": lambda value: "UVec3(x:"+str(value[0])+ ", y:"+str(value[1])+ ", z:"+str(value[2])+")", + + "glam::Vec4": lambda value: "Vec4(x:"+str(value[0])+ ", y:"+str(value[1])+ ", z:"+str(value[2])+ ", w:"+str(value[3])+")", + "glam::DVec4": lambda value: "DVec4(x:"+str(value[0])+ ", y:"+str(value[1])+ ", z:"+str(value[2])+ ", w:"+str(value[3])+")", + "glam::UVec4": lambda value: "UVec4(x:"+str(value[0])+ ", y:"+str(value[1])+ ", z:"+str(value[2])+ ", w:"+str(value[3])+")", + + "glam::Quat": lambda value: "Quat(x:"+str(value[0])+ ", y:"+str(value[1])+ ", z:"+str(value[2])+ ", w:"+str(value[3])+")", + + "bevy_render::color::Color": lambda value: "Rgba(red:"+str(value[0])+ ", green:"+str(value[1])+ ", blue:"+str(value[2])+ ", alpha:"+str(value[3])+ ")", +} + +#converts the value of a property group(no matter its complexity) into a single custom property value +# this is more or less a glorified "to_ron()" method (not quite but close to) +def property_group_value_to_custom_property_value(property_group, definition, registry, parent=None, value=None): + component_name = definition["short_name"] + type_info = definition["typeInfo"] if "typeInfo" in definition else None + type_def = definition["type"] if "type" in definition else None + type_name = definition["title"] + is_value_type = type_name in conversion_tables + #print("computing custom property", component_name, type_info, type_def, type_name) + + if is_value_type: + value = conversion_tables[type_name](value) + elif type_info == "Struct": + values = {} + if len(property_group.field_names) ==0: + value = '' + else: + for index, field_name in enumerate(property_group.field_names): + item_type_name = definition["properties"][field_name]["type"]["$ref"].replace("#/$defs/", "") + item_definition = registry.type_infos[item_type_name] if item_type_name in registry.type_infos else None + + value = getattr(property_group, field_name) + is_property_group = isinstance(value, PropertyGroup) + child_property_group = value if is_property_group else None + if item_definition != None: + value = property_group_value_to_custom_property_value(child_property_group, item_definition, registry, parent=component_name, value=value) + else: + value = '""' + values[field_name] = value + value = values + elif type_info == "Tuple": + values = {} + for index, field_name in enumerate(property_group.field_names): + item_type_name = definition["prefixItems"][index]["type"]["$ref"].replace("#/$defs/", "") + item_definition = registry.type_infos[item_type_name] if item_type_name in registry.type_infos else None + + value = getattr(property_group, field_name) + is_property_group = isinstance(value, PropertyGroup) + child_property_group = value if is_property_group else None + if item_definition != None: + value = property_group_value_to_custom_property_value(child_property_group, item_definition, registry, parent=component_name, value=value) + else: + value = '""' + values[field_name] = value + value = tuple(e for e in list(values.values())) + + elif type_info == "TupleStruct": + values = {} + for index, field_name in enumerate(property_group.field_names): + item_type_name = definition["prefixItems"][index]["type"]["$ref"].replace("#/$defs/", "") + item_definition = registry.type_infos[item_type_name] if item_type_name in registry.type_infos else None + + value = getattr(property_group, field_name) + is_property_group = isinstance(value, PropertyGroup) + child_property_group = value if is_property_group else None + if item_definition != None: + value = property_group_value_to_custom_property_value(child_property_group, item_definition, registry, parent=component_name, value=value) + else: + value = '""' + values[field_name] = value + + value = tuple(e for e in list(values.values())) + elif type_info == "Enum": + selected = getattr(property_group, component_name) + + if type_def == "object": + selection_index = property_group.field_names.index("variant_"+selected) + variant_name = property_group.field_names[selection_index] + variant_definition = definition["oneOf"][selection_index-1] + if "prefixItems" in variant_definition: + value = getattr(property_group, variant_name) + is_property_group = isinstance(value, PropertyGroup) + child_property_group = value if is_property_group else None + + value = property_group_value_to_custom_property_value(child_property_group, variant_definition, registry, parent=component_name, value=value) + value = selected + str(value,) + elif "properties" in variant_definition: + value = getattr(property_group, variant_name) + is_property_group = isinstance(value, PropertyGroup) + child_property_group = value if is_property_group else None + + value = property_group_value_to_custom_property_value(child_property_group, variant_definition, registry, parent=component_name, value=value) + value = selected + str(value,) + else: + print("basic enum stuff") + value = selected # here the value of the enum is just the name of the variant + else: + value = selected + + elif type_info == "List": + item_list = getattr(property_group, "list") + #item_type = getattr(property_group, "type_name_short") + value = [] + for item in item_list: + item_type_name = getattr(item, "type_name") + definition = registry.type_infos[item_type_name] if item_type_name in registry.type_infos else None + if definition != None: + item_value = property_group_value_to_custom_property_value(item, definition, registry, component_name, None) + if item_type_name.startswith("wrapper_"): #if we have a "fake" tupple for aka for value types, we need to remove one nested level + item_value = item_value[0] + else: + item_value = '""' + value.append(item_value) + else: + value = conversion_tables[type_name](value) if is_value_type else value + + #print("VALUE", value, type(value)) + #print("generating custom property value", value, type(value)) + if parent == None: + value = str(value).replace("'", "") + value = value.replace(",)",")") + value = value.replace("{", "(").replace("}", ")") + value = value.replace("True", "true").replace("False", "false") + return value + +import re +#converts the value of a single custom property into a value (values) of a property group +def property_group_value_from_custom_property_value(property_group, definition, registry, custom_property_value): + #print(" ") + #print("setting property group value", property_group, definition, custom_property_value) + type_infos = registry.type_infos + value_types_defaults = registry.value_types_defaults + print("custom_property_value", custom_property_value) + + def parse_field(item, property_group, definition, field_name): + type_info = definition["typeInfo"] if "typeInfo" in definition else None + type_def = definition["type"] if "type" in definition else None + properties = definition["properties"] if "properties" in definition else {} + prefixItems = definition["prefixItems"] if "prefixItems" in definition else [] + has_properties = len(properties.keys()) > 0 + has_prefixItems = len(prefixItems) > 0 + is_enum = type_info == "Enum" + is_list = type_info == "List" + is_value_type = type_def in value_types_defaults + + print("parsing field", item, "type infos", type_info, "type_def", type_def) + if type_info == "Struct": + print("is object") + for field_name in property_group.field_names: + print("field name", field_name) + # sub field + if isinstance(getattr(property_group, field_name), PropertyGroup): + sub_prop_group = getattr(property_group, field_name) + ref_name = properties[field_name]["type"]["$ref"].replace("#/$defs/", "") + sub_definition = type_infos[ref_name] + parse_field(item[field_name], sub_prop_group, sub_definition, field_name) + else: + setattr(property_group, field_name, item[field_name]) + + if has_prefixItems: + if len(property_group.field_names) == 1: + setattr(property_group, "0", item) # FIXME: not ideal + else: + for field_name in property_group.field_names: + setattr(property_group, field_name, item) + if is_enum: + if type_def == "object": + regexp = re.search('(^[^\(]+)(\((.*)\))', item) + chosen_variant = regexp.group(1) + chosen_variant_value = regexp.group(3).replace("'", '"').replace("(", "[").replace(")","]") + chosen_variant_value = json.loads(chosen_variant_value) + + # first set chosen selection + field_name = property_group.field_names[0] + setattr(property_group, field_name, chosen_variant) + + # thenlook for the information about the matching variant + sub_definition= None + for variant in definition["oneOf"]: + if variant["title"] == chosen_variant: + ref_name = variant["prefixItems"][0]["type"]["$ref"].replace("#/$defs/", "") + sub_definition = type_infos[ref_name] + break + variant_name = "variant_"+chosen_variant + if isinstance(getattr(property_group, variant_name), PropertyGroup): + sub_prop_group = getattr(property_group, variant_name) + parse_field(chosen_variant_value, sub_prop_group, sub_definition, variant_name) + else: + setattr(property_group, variant_name, chosen_variant_value) + else: + field_name = property_group.field_names[0] + setattr(property_group, field_name, item) + + if is_list: + print("is list") + + if is_value_type: + print("is value type") + + try: + parse_field(custom_property_value, property_group, definition, None) + except Exception as error: + print("failed to parse raw custom property data", error) diff --git a/tools/bevy_components/propGroups/operators.py b/tools/bevy_components/propGroups/operators.py new file mode 100644 index 0000000..e69de29 diff --git a/tools/bevy_components/propGroups/process_component.py b/tools/bevy_components/propGroups/process_component.py new file mode 100644 index 0000000..c10d8ef --- /dev/null +++ b/tools/bevy_components/propGroups/process_component.py @@ -0,0 +1,95 @@ +import bpy +from bpy_types import PropertyGroup +from bpy.props import (PointerProperty) +from . import process_structs +from . import process_tupples +from . import process_enum +from . import process_list + +def process_component(registry, definition, update, extras=None, nesting = []): + component_name = definition['title'] + short_name = definition["short_name"] + type_info = definition["typeInfo"] if "typeInfo" in definition else None + type_def = definition["type"] if "type" in definition else None + properties = definition["properties"] if "properties" in definition else {} + prefixItems = definition["prefixItems"] if "prefixItems" in definition else [] + + has_properties = len(properties.keys()) > 0 + has_prefixItems = len(prefixItems) > 0 + is_enum = type_info == "Enum" + is_list = type_info == "List" + + # print("processing", short_name, component_name, type_def, type_info) + + __annotations__ = {} + tupple_or_struct = None + + with_properties = False + with_items = False + with_enum = False + with_list = False + + + if has_properties: + __annotations__ = __annotations__ | process_structs.process_structs(registry, definition, properties, update, nesting) + with_properties = True + tupple_or_struct = "struct" + + if has_prefixItems: + __annotations__ = __annotations__ | process_tupples.process_tupples(registry, definition, prefixItems, update, nesting) + with_items = True + tupple_or_struct = "tupple" + + if is_enum: + __annotations__ = __annotations__ | process_enum.process_enum(registry, definition, update, nesting) + with_enum = True + + if is_list: + __annotations__ = __annotations__ | process_list.process_list(registry, definition, update, nesting) + with_list= True + + field_names = [] + for a in __annotations__: + field_names.append(a) + + + extras = extras if extras is not None else { + "type_name": component_name + } + root_component = nesting[0] if len(nesting) > 0 else component_name + # print("DONE:",short_name,"__annotations__", __annotations__) + # print("") + # property_group_name = short_name+"_ui" + property_group_params = { + **extras, + '__annotations__': __annotations__, + 'tupple_or_struct': tupple_or_struct, + 'field_names': field_names, + **dict(with_properties = with_properties, with_items= with_items, with_enum= with_enum, with_list= with_list, short_name= short_name), + 'root_component': root_component + } + #FIXME: YIKES, but have not found another way: + """ Withouth this ; the following does not work + -BasicTest + - NestingTestLevel2 + -BasicTest => the registration & update callback of this one overwrites the first "basicTest" + have not found a cleaner workaround so far + """ + property_group_name = str(hash(str(nesting))) + short_name+"_ui" if len(nesting) > 0 else short_name+"_ui" + + (property_group_pointer, property_group_class) = property_group_from_infos(property_group_name, property_group_params) + # add our component propertyGroup to the registry + registry.register_component_propertyGroup(property_group_name, property_group_pointer) + # for practicality, we add an entry for a reverse lookup (short => long name, since we already have long_name => short_name with the keys of the raw registry) + registry.add_shortName_to_longName(short_name, component_name) + + return (property_group_pointer, property_group_class) + +def property_group_from_infos(property_group_name, property_group_parameters): + # print("creating property group", property_group_name) + property_group_class = type(property_group_name, (PropertyGroup,), property_group_parameters) + + bpy.utils.register_class(property_group_class) + property_group_pointer = PointerProperty(type=property_group_class) + + return (property_group_pointer, property_group_class) \ No newline at end of file diff --git a/tools/bevy_components/propGroups/process_enum.py b/tools/bevy_components/propGroups/process_enum.py new file mode 100644 index 0000000..efd316a --- /dev/null +++ b/tools/bevy_components/propGroups/process_enum.py @@ -0,0 +1,69 @@ +from bpy.props import (StringProperty) +from . import process_component + +def process_enum(registry, definition, update, nesting): + blender_property_mapping = registry.blender_property_mapping + short_name = definition["short_name"] + type_def = definition["type"] if "type" in definition else None + values = definition["oneOf"] + + nesting = nesting+ [short_name] + __annotations__ = {} + original_type_name = "enum" + + #print("processing enum", short_name, definition) + + if type_def == "object": + labels = [] + additional_annotations = {} + for item in values: + item_name = item["title"] + item_short_name = item["short_name"] if "short_name" in item else item_name + variant_name = "variant_"+item_short_name + labels.append(item_name) + + if "prefixItems" in item: + #print("tupple variant in enum", short_name, item) + registry.add_custom_type(item_short_name, item) + (sub_component_group, _) = process_component.process_component(registry, item, update, {"nested": True}, nesting) + additional_annotations[variant_name] = sub_component_group + elif "properties" in item: + #print("struct variant in enum", short_name, item) + registry.add_custom_type(item_short_name, item) + (sub_component_group, _) = process_component.process_component(registry, item, update, {"nested": True}, nesting) + additional_annotations[variant_name] = sub_component_group + else: # for the cases where it's neither a tupple nor a structs: FIXME: not 100% sure of this + #print("other variant in enum", short_name) + annotations = {"variant_"+item_name: StringProperty(default="--------")} + additional_annotations = additional_annotations | annotations + + items = tuple((e, e, e) for e in labels) + property_name = short_name + + blender_property_def = blender_property_mapping[original_type_name] + blender_property = blender_property_def["type"]( + **blender_property_def["presets"],# we inject presets first + name = property_name, + items=items, + update= update +) + __annotations__[property_name] = blender_property + + for a in additional_annotations: + __annotations__[a] = additional_annotations[a] + # enum_value => what field to display + # a second field + property for the "content" of the enum + else: + items = tuple((e, e, "") for e in values) + property_name = short_name + + blender_property_def = blender_property_mapping[original_type_name] + blender_property = blender_property_def["type"]( + **blender_property_def["presets"],# we inject presets first + name = property_name, + items=items, + update= update + ) + __annotations__[property_name] = blender_property + + return __annotations__ diff --git a/tools/bevy_components/propGroups/process_list.py b/tools/bevy_components/propGroups/process_list.py new file mode 100644 index 0000000..ed332ff --- /dev/null +++ b/tools/bevy_components/propGroups/process_list.py @@ -0,0 +1,33 @@ +from bpy.props import (StringProperty, IntProperty, CollectionProperty) +from .utils import generate_wrapper_propertyGroup +from . import process_component + +def process_list(registry, definition, update, nesting=[]): + value_types_defaults = registry.value_types_defaults + type_infos = registry.type_infos + + short_name = definition["short_name"] + ref_name = definition["items"]["type"]["$ref"].replace("#/$defs/", "") + + item_definition = type_infos[ref_name] + item_long_name = item_definition["title"] + is_item_value_type = item_long_name in value_types_defaults + + property_group_class = None + #if the content of the list is a unit type, we need to generate a fake wrapper, otherwise we cannot use layout.prop(group, "propertyName") as there is no propertyName ! + if is_item_value_type: + property_group_class = generate_wrapper_propertyGroup(short_name, item_long_name, definition["items"]["type"]["$ref"],registry, update) + else: + (_, list_content_group_class) = process_component.process_component(registry, item_definition, update, {"nested": True, "type_name": item_long_name}, nesting) + property_group_class = list_content_group_class + + nesting = nesting+[short_name] + item_collection = CollectionProperty(type=property_group_class) + + __annotations__ = { + "list": item_collection, + "list_index": IntProperty(name = "Index for list", default = 0, update=update), + "type_name_short": StringProperty(default=short_name) + } + + return __annotations__ \ No newline at end of file diff --git a/tools/bevy_components/propGroups/process_structs.py b/tools/bevy_components/propGroups/process_structs.py new file mode 100644 index 0000000..89ac7e7 --- /dev/null +++ b/tools/bevy_components/propGroups/process_structs.py @@ -0,0 +1,46 @@ +from bpy.props import (StringProperty) +from . import process_component + +def process_structs(registry, definition, properties, update, nesting): + value_types_defaults = registry.value_types_defaults + blender_property_mapping = registry.blender_property_mapping + type_infos = registry.type_infos + short_name = definition["short_name"] + + __annotations__ = {} + default_values = {} + nesting = nesting + [short_name] + + for property_name in properties.keys(): + ref_name = properties[property_name]["type"]["$ref"].replace("#/$defs/", "") + + if ref_name in type_infos: + original = type_infos[ref_name] + original_type_name = original["title"] + is_value_type = original_type_name in value_types_defaults + value = value_types_defaults[original_type_name] if is_value_type else None + default_values[property_name] = value + + if is_value_type: + if original_type_name in blender_property_mapping: + blender_property_def = blender_property_mapping[original_type_name] + blender_property = blender_property_def["type"]( + **blender_property_def["presets"],# we inject presets first + name = property_name, + default = value, + update = update + ) + __annotations__[property_name] = blender_property + else: + original_long_name = original["title"] + (sub_component_group, _) = process_component.process_component(registry, original, update, {"nested": True, "type_name": original_long_name}, nesting) + __annotations__[property_name] = sub_component_group + # if there are sub fields, add an attribute "sub_fields" possibly a pointer property ? or add a standard field to the type , that is stored under "attributes" and not __annotations (better) + else: + # component not found in type_infos, generating placeholder + __annotations__[property_name] = StringProperty(default="N/A") + registry.add_missing_typeInfo(ref_name) + # the root component also becomes invalid (in practice it is not always a component, but good enough) + registry.add_invalid_component(nesting[0]) + + return __annotations__ diff --git a/tools/bevy_components/propGroups/process_tupples.py b/tools/bevy_components/propGroups/process_tupples.py new file mode 100644 index 0000000..feafcc2 --- /dev/null +++ b/tools/bevy_components/propGroups/process_tupples.py @@ -0,0 +1,53 @@ +from bpy.props import (StringProperty) +from . import process_component + +def process_tupples(registry, definition, prefixItems, update, nesting=[]): + value_types_defaults = registry.value_types_defaults + blender_property_mapping = registry.blender_property_mapping + type_infos = registry.type_infos + short_name = definition["short_name"] + + nesting = nesting+[short_name] + __annotations__ = {} + + default_values = [] + prefix_infos = [] + for index, item in enumerate(prefixItems): + ref_name = item["type"]["$ref"].replace("#/$defs/", "") + + property_name = str(index)# we cheat a bit, property names are numbers here, as we do not have a real property name + + if ref_name in type_infos: + original = type_infos[ref_name] + original_type_name = original["title"] + is_value_type = original_type_name in value_types_defaults + + value = value_types_defaults[original_type_name] if is_value_type else None + default_values.append(value) + prefix_infos.append(original) + + if is_value_type: + if original_type_name in blender_property_mapping: + blender_property_def = blender_property_mapping[original_type_name] + blender_property = blender_property_def["type"]( + **blender_property_def["presets"],# we inject presets first + name = property_name, + default=value, + update= update + ) + + __annotations__[property_name] = blender_property + else: + original_long_name = original["title"] + (sub_component_group, _) = process_component.process_component(registry, original, update, {"nested": True, "type_name": original_long_name}, nesting) + __annotations__[property_name] = sub_component_group + else: + # component not found in type_infos, generating placeholder + __annotations__[property_name] = StringProperty(default="N/A") + registry.add_missing_typeInfo(ref_name) + # the root component also becomes invalid (in practice it is not always a component, but good enough) + registry.add_invalid_component(nesting[0]) + + + return __annotations__ + diff --git a/tools/bevy_components/propGroups/prop_groups.py b/tools/bevy_components/propGroups/prop_groups.py new file mode 100644 index 0000000..35c0302 --- /dev/null +++ b/tools/bevy_components/propGroups/prop_groups.py @@ -0,0 +1,38 @@ +import bpy +from .conversions import property_group_value_to_custom_property_value +from .process_component import process_component +from .utils import update_calback_helper + +## main callback function, fired whenever any property changes, no matter the nesting level +def update_component(self, context, definition, component_name): + registry = bpy.context.window_manager.components_registry + current_object = bpy.context.object + update_disabled = current_object["__disable__update"] if "__disable__update" in current_object else False + if update_disabled: + return + print("") + print("update in component", component_name, self) + components_in_object = current_object.components_meta.components + component_meta = next(filter(lambda component: component["name"] == component_name, components_in_object), None) + if component_meta != None: + self = getattr(component_meta, component_name+"_ui") + # we use our helper to set the values + context.object[component_name] = property_group_value_to_custom_property_value(self, definition, registry, None) + + +def generate_propertyGroups_for_components(): + registry = bpy.context.window_manager.components_registry + if registry.type_infos == None: + registry.load_type_infos() + + type_infos = registry.type_infos + + for component_name in type_infos: + definition = type_infos[component_name] + short_name = definition["short_name"] + is_component = definition['isComponent'] if "isComponent" in definition else False + root_property_name = short_name if is_component else None + process_component(registry, definition, update_calback_helper(definition, update_component, root_property_name), None, []) + + # if we had to add any wrapper types on the fly, process them now + registry.process_custom_types() \ No newline at end of file diff --git a/tools/bevy_components/propGroups/utils.py b/tools/bevy_components/propGroups/utils.py new file mode 100644 index 0000000..b784962 --- /dev/null +++ b/tools/bevy_components/propGroups/utils.py @@ -0,0 +1,60 @@ +# helper function that returns a lambda, used for the PropertyGroups update function +def update_calback_helper(definition, update, component_name_override): + return lambda self, context: update(self, context, definition, component_name_override) + +import bpy +from bpy.props import (StringProperty) +from bpy_types import PropertyGroup + +# this helper creates a "fake"/wrapper property group that is NOT a real type in the registry +# usefull for things like value types in list items etc +def generate_wrapper_propertyGroup(short_name, item_long_name, definition, registry, update): + value_types_defaults = registry.value_types_defaults + blender_property_mapping = registry.blender_property_mapping + is_item_value_type = item_long_name in value_types_defaults + + wrapper_name = "wrapper_" + short_name + + wrapper_definition = { + "isComponent": False, + "isResource": False, + "items": False, + "prefixItems": [ + { + "type": { + "$ref": definition + } + } + ], + "short_name": wrapper_name, + "title": wrapper_name, + "type": "array", + "typeInfo": "TupleStruct" + } + registry.add_custom_type(wrapper_name, wrapper_definition) + + blender_property = StringProperty(default="", update=update) + if item_long_name in blender_property_mapping: + value = value_types_defaults[item_long_name] if is_item_value_type else None + blender_property_def = blender_property_mapping[item_long_name] + blender_property = blender_property_def["type"]( + **blender_property_def["presets"],# we inject presets first + name = "property_name", + default = value, + update = update + ) + + wrapper_annotations = { + '0' : blender_property + } + property_group_params = { + '__annotations__': wrapper_annotations, + 'tupple_or_struct': "tupple", + 'field_names': ['0'], + **dict(with_properties = False, with_items= True, with_enum= False, with_list= False, short_name= wrapper_name, type_name=wrapper_name), + #'root_component': root_component + } + property_group_class = type(wrapper_name, (PropertyGroup,), property_group_params) + bpy.utils.register_class(property_group_class) + + return property_group_class \ No newline at end of file diff --git a/tools/bevy_components/registry/__init__.py b/tools/bevy_components/registry/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tools/bevy_components/registry/operators.py b/tools/bevy_components/registry/operators.py new file mode 100644 index 0000000..58d124d --- /dev/null +++ b/tools/bevy_components/registry/operators.py @@ -0,0 +1,84 @@ +import os +import bpy +from bpy_types import (Operator) +from bpy.props import (StringProperty) +from bpy_extras.io_utils import ImportHelper + +from ..helpers import upsert_settings +from ..components.metadata import apply_propertyGroup_values_to_object_customProperties, ensure_metadata_for_all_objects +from ..components.operators import GenerateComponent_From_custom_property_Operator +from ..propGroups.prop_groups import generate_propertyGroups_for_components + +class ReloadRegistryOperator(Operator): + """Reloads registry (schema file) from disk, generates propertyGroups for components & ensures all objects have metadata """ + bl_idname = "object.reload_registry" + bl_label = "Reload Registry" + bl_options = {"UNDO"} + + component_type: StringProperty( + name="component_type", + description="component type to add", + ) + + def execute(self, context): + print("reload registry") + context.window_manager.components_registry.load_schema() + generate_propertyGroups_for_components() + print("") + print("") + print("") + ensure_metadata_for_all_objects() + #add_metadata_to_components_without_metadata(context.object) + + return {'FINISHED'} + +class COMPONENTS_OT_REFRESH_CUSTOM_PROPERTIES_ALL(Operator): + """Apply registry to ALL objects: update the custom property values of all objects based on their definition, if any""" + bl_idname = "object.refresh_custom_properties_all" + bl_label = "Apply Registry to all objects" + bl_options = {"UNDO"} + + def execute(self, context): + print("apply registry to all") + #context.window_manager.components_registry.load_schema() + for object in bpy.data.objects: + apply_propertyGroup_values_to_object_customProperties(object) + + return {'FINISHED'} + +class COMPONENTS_OT_REFRESH_CUSTOM_PROPERTIES_CURRENT(Operator): + """Apply registry to CURRENT object: update the custom property values of all objects based on their definition, if any""" + bl_idname = "object.refresh_custom_properties_current" + bl_label = "Apply Registry to current object" + bl_options = {"UNDO"} + + def execute(self, context): + print("apply registry to current object") + object = context.object + apply_propertyGroup_values_to_object_customProperties(object) + return {'FINISHED'} + +class OT_OpenFilebrowser(Operator, ImportHelper): + """Browse for registry json file""" + bl_idname = "generic.open_filebrowser" + bl_label = "Open the file browser" + + filter_glob: StringProperty( + default='*.json', + options={'HIDDEN'} + ) + def execute(self, context): + """Do something with the selected file(s).""" + #filename, extension = os.path.splitext(self.filepath) + file_path = bpy.data.filepath + # Get the folder + folder_path = os.path.dirname(file_path) + relative_path = os.path.relpath(self.filepath, folder_path) + + registry = context.window_manager.components_registry + registry.schemaPath = relative_path + + upsert_settings(registry.settings_save_path, {"schemaPath": relative_path}) + + return {'FINISHED'} + diff --git a/tools/bevy_components/registry/registry.py b/tools/bevy_components/registry/registry.py new file mode 100644 index 0000000..063b65d --- /dev/null +++ b/tools/bevy_components/registry/registry.py @@ -0,0 +1,216 @@ +import bpy +import json +import os +from pathlib import Path +from bpy_types import (PropertyGroup) +from bpy.props import (StringProperty, BoolProperty, FloatProperty, FloatVectorProperty, IntProperty, IntVectorProperty, EnumProperty, PointerProperty, CollectionProperty) +from ..components.metadata import ComponentInfos + +# helper class to store missing bevy types information +class MissingBevyType(bpy.types.PropertyGroup): + type_name: bpy.props.StringProperty( + name="type", + ) + +# this is where we store the information for all available components +class ComponentsRegistry(PropertyGroup): + + settings_save_path = ".bevy_components_settings" # where to store data in bpy.texts + + schemaPath: bpy.props.StringProperty( + name="schema path", + description="path to the registry schema file", + default="registry.json" + ) + + registry: bpy.props. StringProperty( + name="registry", + description="component registry" + ) + + missing_type_infos: StringProperty( + name="missing type infos", + description="unregistered/missing type infos" + ) + + missing_types_list: CollectionProperty(name="missing types list", type=MissingBevyType) + missing_types_list_index: IntProperty(name = "Index for missing types list", default = 0) + + blender_property_mapping = { + "bool": dict(type=BoolProperty, presets=dict()), + + "u8": dict(type=IntProperty, presets=dict(min=0, max=255)), + "u16": dict(type=IntProperty, presets=dict(min=0, max=65535)), + "u32": dict(type=IntProperty, presets=dict(min=0)), + "u64": dict(type=IntProperty, presets=dict(min=0)), + "u128": dict(type=IntProperty, presets=dict(min=0)), + "u64": dict(type=IntProperty, presets=dict(min=0)), + "usize": dict(type=IntProperty, presets=dict(min=0)), + + "i8": dict(type=IntProperty, presets=dict()), + "i16":dict(type=IntProperty, presets=dict()), + "i32":dict(type=IntProperty, presets=dict()), + "i64":dict(type=IntProperty, presets=dict()), + "i128":dict(type=IntProperty, presets=dict()), + + "f32": dict(type=FloatProperty, presets=dict()), + "f64": dict(type=FloatProperty, presets=dict()), + + "glam::Vec2": {"type": FloatVectorProperty, "presets": dict(size = 2) }, + "glam::DVec2": {"type": FloatVectorProperty, "presets": dict(size = 2) }, + "glam::UVec2": {"type": FloatVectorProperty, "presets": dict(size = 2) }, + + "glam::Vec3": {"type": FloatVectorProperty, "presets": {"size":3} }, + "glam::Vec3A":{"type": FloatVectorProperty, "presets": {"size":3} }, + "glam::DVec3":{"type": FloatVectorProperty, "presets": {"size":3} }, + "glam::UVec3":{"type": FloatVectorProperty, "presets": {"size":3} }, + + "glam::Vec4": {"type": FloatVectorProperty, "presets": {"size":4} }, + "glam::Vec4A": {"type": FloatVectorProperty, "presets": {"size":4} }, + "glam::DVec4": {"type": FloatVectorProperty, "presets": {"size":4} }, + "glam::UVec4":{"type": FloatVectorProperty, "presets": {"size":4, "min":0.0} }, + + "glam::Quat": {"type": FloatVectorProperty, "presets": {"size":4} }, + + "bevy_render::color::Color": dict(type = FloatVectorProperty, presets=dict(subtype='COLOR', size=4)), + + "char": dict(type=StringProperty, presets=dict()), + "str": dict(type=StringProperty, presets=dict()), + "alloc::string::String": dict(type=StringProperty, presets=dict()), + "enum": dict(type=EnumProperty, presets=dict()), + + #"alloc::vec::Vec": dict(type=CollectionProperty, presets=dict(type=PointerProperty(StringProperty))), #FIXME: we need more generic stuff + } + + + value_types_defaults = { + "string":" ", + "boolean": True, + "float": 0.0, + "uint": 0, + "int":0, + + # todo : we are re-doing the work of the bevy /rust side here, but it seems more pratical to alway look for the same field name on the blender side for matches + "bool": True, + + "u8": 0, + "u16":0, + "u32":0, + "u64":0, + "u128":0, + + "i8": 0, + "i16":0, + "i32":0, + "i64":0, + "i128":0, + + "f32": 0.0, + "f64":0.0, + + "char": " ", + "str": " ", + "alloc::string::String": " ", + + "glam::Vec2": [0.0, 0.0], + "glam::DVec2": [0.0, 0.0], + "glam::UVec2": [0, 0], + + "glam::Vec3": [0.0, 0.0, 0.0], + "glam::Vec3A":[0.0, 0.0, 0.0], + "glam::UVec3": [0, 0, 0], + + "glam::Vec4": [0.0, 0.0, 0.0, 0.0], + "glam::DVec4": [0.0, 0.0, 0.0, 0.0], + "glam::UVec4": [0, 0, 0, 0], + + "glam::Quat": [0.0, 0.0, 0.0, 0.0], + + "bevy_render::color::Color": [1.0, 1.0, 0.0, 1.0], + } + + type_infos = None + type_infos_missing = [] + component_propertyGroups = {} + short_names_to_long_names = {} + + + @classmethod + def register(cls): + bpy.types.WindowManager.components_registry = PointerProperty(type=ComponentsRegistry) + + @classmethod + def unregister(cls): + for propgroup_name in cls.component_propertyGroups.keys(): + try: + delattr(ComponentInfos, propgroup_name) + print("unregistered propertyGroup", propgroup_name) + except Exception as error: + pass + #print("failed to remove", error, "ComponentInfos") + + del bpy.types.WindowManager.components_registry + + def load_schema(self): + # cleanup missing types list + self.missing_types_list.clear() + self.type_infos = None + self.type_infos_missing.clear() + file_path = bpy.data.filepath + + # Get the folder + folder_path = os.path.dirname(file_path) + path = os.path.join(folder_path, self.schemaPath) + + f = Path(bpy.path.abspath(path)) # make a path object of abs path + with open(path) as f: + data = json.load(f) + defs = data["$defs"] + self.registry = json.dumps(defs) # FIXME:meh ? + + # we load the json once, so we do not need to do it over & over again + def load_type_infos(self): + ComponentsRegistry.type_infos = json.loads(self.registry) + + # we keep a list of component propertyGroup around + def register_component_propertyGroup(self, name, propertyGroup): + self.component_propertyGroups[name] = propertyGroup + + #for practicality, we add an entry for a reverse lookup (short => long name, since we already have long_name => short_name with the keys of the raw registry) + def add_shortName_to_longName(self, short_name, long_name): + self.short_names_to_long_names[short_name] = long_name + + # to be able to give the user more feedback on any missin/unregistered types in their schema file + def add_missing_typeInfo(self, type_name): + if not type_name in self.type_infos_missing: + self.type_infos_missing.append(type_name) + setattr(self, "missing_type_infos", str(self.type_infos_missing)) + item = self.missing_types_list.add() + item.type_name = type_name + + custom_types_to_add = {} + def add_custom_type(self, type_name, type_definition): + self.custom_types_to_add[type_name] = type_definition + + def process_custom_types(self): + for type_name in self.custom_types_to_add: + self.type_infos[type_name] = self.custom_types_to_add[type_name] + self.custom_types_to_add.clear() + + invalid_components = [] + def add_invalid_component(self, component_name): + self.invalid_components.append(component_name) +""" + object[component_definition.name] = 0.5 + property_manager = object.id_properties_ui(component_definition.name) + property_manager.update(min=-10, max=10, soft_min=-5, soft_max=5) + + print("property_manager", property_manager) + + object[component_definition.name] = [0.8,0.2,1.0] + property_manager = object.id_properties_ui(component_definition.name) + property_manager.update(subtype='COLOR') + + #IDPropertyUIManager + #rna_ui = object[component_definition.name].get('_RNA_UI') +""" \ No newline at end of file diff --git a/tools/bevy_components/registry/ui.py b/tools/bevy_components/registry/ui.py new file mode 100644 index 0000000..5cced14 --- /dev/null +++ b/tools/bevy_components/registry/ui.py @@ -0,0 +1,116 @@ +import bpy +from bpy_types import (UIList) +from .operators import(OT_OpenFilebrowser, ReloadRegistryOperator, COMPONENTS_OT_REFRESH_CUSTOM_PROPERTIES_ALL, COMPONENTS_OT_REFRESH_CUSTOM_PROPERTIES_CURRENT) + +class BEVY_COMPONENTS_PT_Configuration(bpy.types.Panel): + bl_idname = "BEVY_COMPONENTS_PT_Configuration" + bl_label = "Configuration" + bl_space_type = 'VIEW_3D' + bl_region_type = 'UI' + bl_category = "Bevy Components" + bl_context = "objectmode" + bl_parent_id = "BEVY_COMPONENTS_PT_MainPanel" + bl_options = {'DEFAULT_CLOSED'} + bl_description = "list of missing/unregistered type from the bevy side" + + def draw(self, context): + layout = self.layout + registry = context.window_manager.components_registry + selected_object = context.selected_objects[0] if len(context.selected_objects) > 0 else None + + row = layout.row() + col = row.column() + col.enabled = False + col.prop(registry, "schemaPath", text="Registry Schema path") + col = row.column() + col.operator(OT_OpenFilebrowser.bl_idname, text="Browse for registry schema file (json)") + + layout.separator() + layout.operator(ReloadRegistryOperator.bl_idname, text="reload registry" , icon="FILE_REFRESH") + + layout.separator() + layout.separator() + + row = layout.row() + row.label(text="WARNING ! The following operations will overwrite your existing custom properties if they have matching types on the bevy side !") + row.alert = True + + row = layout.row() + row.operator(COMPONENTS_OT_REFRESH_CUSTOM_PROPERTIES_CURRENT.bl_idname, text="update custom properties of current object" , icon="FILE_REFRESH") + row.enabled = registry.type_infos != None and selected_object is not None + + layout.separator() + row = layout.row() + row.operator(COMPONENTS_OT_REFRESH_CUSTOM_PROPERTIES_ALL.bl_idname, text="update custom properties of ALL objects" , icon="FILE_REFRESH") + row.enabled = registry.type_infos != None + + +class BEVY_COMPONENTS_PT_MissingTypesPanel(bpy.types.Panel): + """panel listing all the missing bevy types in the schema""" + bl_idname = "BEVY_COMPONENTS_PT_MissingTypesPanel" + bl_label = "Bevy Missing/Unregistered Types" + bl_space_type = 'VIEW_3D' + bl_region_type = 'UI' + bl_category = "Bevy Components" + bl_context = "objectmode" + bl_parent_id = "BEVY_COMPONENTS_PT_MainPanel" + bl_options = {'DEFAULT_CLOSED'} + bl_description = "list of missing/unregistered type from the bevy side" + + def draw(self, context): + layout = self.layout + registry = bpy.context.window_manager.components_registry + + layout.label(text="Missing types ") + layout.template_list("MISSING_TYPES_UL_List", "Missing types list", registry, "missing_types_list", registry, "missing_types_list_index") + + +class MISSING_TYPES_UL_List(UIList): + """Missing components UIList.""" + + use_filter_name_reverse: bpy.props.BoolProperty( + name="Reverse Name", + default=False, + options=set(), + description="Reverse name filtering", + ) + + use_order_name = bpy.props.BoolProperty(name="Name", default=False, options=set(), + description="Sort groups by their name (case-insensitive)") + + def filter_items__(self, context, data, propname): + """Filter and order items in the list.""" + # We initialize filtered and ordered as empty lists. Notice that # if all sorting and filtering is disabled, we will return # these empty. + filtered = [] + ordered = [] + items = getattr(data, propname) + + helper_funcs = bpy.types.UI_UL_list + + + print("filter, order", items, self, dict(self)) + if self.filter_name: + print("ssdfs", self.filter_name) + filtered= helper_funcs.filter_items_by_name(self.filter_name, self.bitflag_filter_item, items, "type_name", reverse=self.use_filter_name_reverse) + + if not filtered: + filtered = [self.bitflag_filter_item] * len(items) + + if self.use_order_name: + ordered = helper_funcs.sort_items_by_name(items, "name") + + + return filtered, ordered + + + def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index): + if self.layout_type in {'DEFAULT', 'COMPACT'}: + row = layout.row() + #row.enabled = False + #row.alert = True + row.prop(item, "type_name", text="") + + elif self.layout_type in {'GRID'}: + layout.alignment = 'CENTER' + row = layout.row() + row.prop(item, "type_name", text="") diff --git a/tools/gltf_auto_export/README.md b/tools/gltf_auto_export/README.md index fb577bd..61076b5 100644 --- a/tools/gltf_auto_export/README.md +++ b/tools/gltf_auto_export/README.md @@ -120,6 +120,12 @@ This issue has been resolved in v0.9. - materials path: where to export materials to + - Legacy mode for bevy: the export of custom properties is slightly different + when using bevy_gltf_components or bevy_gltf_blueprints with ```legacy_mode``` turned on (the default currently), toggle this on to keep using the older variant + + > tldr: legacy mode in this add on should match your use of legacy mode on the Bevy side + > if you use the ```bevy_components``` add-on **legacy mode** should be turned **OFF** + * and your standard gltf export parameters in the **gltf** panel ![blender addon use2](./docs/blender_addon_use2.png) diff --git a/tools/gltf_auto_export/auto_export/export_blueprints.py b/tools/gltf_auto_export/auto_export/export_blueprints.py index 1ad7ba2..836a6f2 100644 --- a/tools/gltf_auto_export/auto_export/export_blueprints.py +++ b/tools/gltf_auto_export/auto_export/export_blueprints.py @@ -22,13 +22,12 @@ def export_collections(collections, folder_path, library_scene, addon_prefs, glt export_settings['export_materials'] = 'PLACEHOLDER' collection = bpy.data.collections[collection_name] - collection_instances_combine_mode = getattr(addon_prefs, "collection_instances_combine_mode") generate_and_export( addon_prefs, temp_scene_name="__temp_scene_"+collection.name, export_settings=export_settings, gltf_output_path=gltf_output_path, - tempScene_filler= lambda temp_collection: copy_hollowed_collection_into(collection, temp_collection, library_collections=library_collections, collection_instances_combine_mode= collection_instances_combine_mode), + tempScene_filler= lambda temp_collection: copy_hollowed_collection_into(collection, temp_collection, library_collections=library_collections, addon_prefs=addon_prefs), tempScene_cleaner= lambda temp_scene, params: clear_hollow_scene(original_root_collection=collection, temp_scene=temp_scene, **params) ) # reset active collection to the one we save before diff --git a/tools/gltf_auto_export/auto_export/export_main_scenes.py b/tools/gltf_auto_export/auto_export/export_main_scenes.py index 78a8271..8bdb018 100644 --- a/tools/gltf_auto_export/auto_export/export_main_scenes.py +++ b/tools/gltf_auto_export/auto_export/export_main_scenes.py @@ -17,7 +17,6 @@ def export_main_scene(scene, folder_path, addon_prefs, library_collections): export_output_folder = getattr(addon_prefs,"export_output_folder") export_blueprints = getattr(addon_prefs,"export_blueprints") export_separate_dynamic_and_static_objects = getattr(addon_prefs, "export_separate_dynamic_and_static_objects") - collection_instances_combine_mode = getattr(addon_prefs, "collection_instances_combine_mode") gltf_output_path = os.path.join(folder_path, export_output_folder, scene.name) export_settings = { **gltf_export_preferences, @@ -38,7 +37,7 @@ def export_main_scene(scene, folder_path, addon_prefs, library_collections): temp_scene_name="__temp_scene", export_settings=export_settings, gltf_output_path=gltf_output_path, - tempScene_filler= lambda temp_collection: copy_hollowed_collection_into(scene.collection, temp_collection, library_collections=library_collections, collection_instances_combine_mode= collection_instances_combine_mode, filter=is_object_static), + tempScene_filler= lambda temp_collection: copy_hollowed_collection_into(scene.collection, temp_collection, library_collections=library_collections, filter=is_object_static, addon_prefs=addon_prefs), tempScene_cleaner= lambda temp_scene, params: clear_hollow_scene(original_root_collection=scene.collection, temp_scene=temp_scene, **params) ) @@ -49,7 +48,7 @@ def export_main_scene(scene, folder_path, addon_prefs, library_collections): temp_scene_name="__temp_scene", export_settings=export_settings, gltf_output_path=gltf_output_path, - tempScene_filler= lambda temp_collection: copy_hollowed_collection_into(scene.collection, temp_collection, library_collections=library_collections, collection_instances_combine_mode= collection_instances_combine_mode, filter=is_object_dynamic), + tempScene_filler= lambda temp_collection: copy_hollowed_collection_into(scene.collection, temp_collection, library_collections=library_collections, filter=is_object_dynamic, addon_prefs=addon_prefs), tempScene_cleaner= lambda temp_scene, params: clear_hollow_scene(original_root_collection=scene.collection, temp_scene=temp_scene, **params) ) @@ -60,7 +59,7 @@ def export_main_scene(scene, folder_path, addon_prefs, library_collections): temp_scene_name="__temp_scene", export_settings=export_settings, gltf_output_path=gltf_output_path, - tempScene_filler= lambda temp_collection: copy_hollowed_collection_into(scene.collection, temp_collection, library_collections=library_collections, collection_instances_combine_mode= collection_instances_combine_mode), + tempScene_filler= lambda temp_collection: copy_hollowed_collection_into(scene.collection, temp_collection, library_collections=library_collections, addon_prefs=addon_prefs), tempScene_cleaner= lambda temp_scene, params: clear_hollow_scene(original_root_collection=scene.collection, temp_scene=temp_scene, **params) ) diff --git a/tools/gltf_auto_export/auto_export/operators.py b/tools/gltf_auto_export/auto_export/operators.py index bed7d28..2c6048d 100644 --- a/tools/gltf_auto_export/auto_export/operators.py +++ b/tools/gltf_auto_export/auto_export/operators.py @@ -32,7 +32,9 @@ class AutoExportGLTF(Operator, AutoExportGltfAddonPreferences, ExportHelper): 'export_materials_library', 'export_materials_path', - 'export_scene_settings'] + 'export_scene_settings' + 'export_legacy_mode' + ] @classmethod def register(cls): diff --git a/tools/gltf_auto_export/auto_export/preferences.py b/tools/gltf_auto_export/auto_export/preferences.py index 1b566f2..2172cf0 100644 --- a/tools/gltf_auto_export/auto_export/preferences.py +++ b/tools/gltf_auto_export/auto_export/preferences.py @@ -22,6 +22,7 @@ AutoExportGltfPreferenceNames = [ 'export_marked_assets', 'collection_instances_combine_mode', 'export_separate_dynamic_and_static_objects', + 'export_legacy_mode', 'export_materials_library', 'export_materials_path', @@ -148,6 +149,11 @@ class AutoExportGltfAddonPreferences(AddonPreferences): default=False ) + export_legacy_mode: BoolProperty( + name='Legacy mode for Bevy', + description='Toggle this if you want to be compatible with bevy_gltf_blueprints/components < 0.8', + default=True + ) main_scenes: CollectionProperty(name="main scenes", type=CUSTOM_PG_sceneName) main_scenes_index: IntProperty(name = "Index for main scenes list", default = 0) diff --git a/tools/gltf_auto_export/helpers/helpers_scenes.py b/tools/gltf_auto_export/helpers/helpers_scenes.py index fb0ad70..81bde54 100644 --- a/tools/gltf_auto_export/helpers/helpers_scenes.py +++ b/tools/gltf_auto_export/helpers/helpers_scenes.py @@ -3,11 +3,17 @@ from .helpers_collections import (set_active_collection) from .object_makers import (make_empty) # copies the contents of a collection into another one while replacing library instances with empties -def copy_hollowed_collection_into(source_collection, destination_collection, parent_empty=None, filter=None, collection_instances_combine_mode=None, library_collections=[]): +def copy_hollowed_collection_into(source_collection, destination_collection, parent_empty=None, filter=None, library_collections=[], addon_prefs={}): + collection_instances_combine_mode = getattr(addon_prefs, "collection_instances_combine_mode") + legacy_mode = getattr(addon_prefs, "export_legacy_mode") + root_objects = [] special_properties= { # to be able to reset any special property afterwards "combine": [], } + + collection_instances_combine_mode= collection_instances_combine_mode + for object in source_collection.objects: if filter is not None and filter(object) is False: continue @@ -22,7 +28,7 @@ def copy_hollowed_collection_into(source_collection, destination_collection, par object.name = original_name + "____bak" empty_obj = make_empty(original_name, object.location, object.rotation_euler, object.scale, destination_collection) """we inject the collection/blueprint name, as a component called 'BlueprintName', but we only do this in the empty, not the original object""" - empty_obj['BlueprintName'] = '"'+collection_name+'"' + empty_obj['BlueprintName'] = '"'+collection_name+'"' if legacy_mode else '("'+collection_name+'")' empty_obj['SpawnHere'] = '' for k, v in object.items(): diff --git a/tools/gltf_auto_export/ui/main.py b/tools/gltf_auto_export/ui/main.py index 925d004..828cf57 100644 --- a/tools/gltf_auto_export/ui/main.py +++ b/tools/gltf_auto_export/ui/main.py @@ -68,6 +68,7 @@ class GLTF_PT_auto_export_root(bpy.types.Panel): layout.prop(operator, 'will_save_settings') layout.prop(operator, "export_output_folder") layout.prop(operator, "export_scene_settings") + layout.prop(operator, "export_legacy_mode") # scene selectors row = layout.row()