Bevy Egui

https://docs.rs/bevy_egui/0.39.1/bevy_egui/
Admin
Bevy Egui is an integration library that brings the Egui immediate mode GUI framework to the Bevy...
Tokens:170,081
Snippets:1,523
Trust Score:9.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### Run Bevy Egui Examples

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/index.html

Command to run any of the provided examples for the bevy_egui crate. Replace 'ui' with the desired example name.

```bash
cargo run --example ui
```

--------------------------------

### Minimal Bevy Egui Setup (Multi-pass)

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/index.html

A basic setup for integrating Egui with Bevy using the multi-pass mode. This example requires Egui to run within the `EguiPrimaryContextPass` schedule.

```rust
use bevy::prelude::*
use bevy_egui::{egui, EguiContexts, EguiPlugin, EguiPrimaryContextPass};

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(EguiPlugin::default())
        .add_systems(Startup, setup_camera_system)
        .add_systems(EguiPrimaryContextPass, ui_example_system)
        .run();
}

fn setup_camera_system(mut commands: Commands) {
    commands.spawn(Camera2d);
}

fn ui_example_system(mut contexts: EguiContexts) -> Result {
    egui::Window::new("Hello").show(contexts.ctx_mut()?, |ui| {
        ui.label("world");
    });
    Ok(())
}
```

--------------------------------

### HashMap Length Example

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiManagedTextures.html

Shows how to get the number of elements currently in a HashMap.

```rust
let mut map = HashMap::new();

assert_eq!(map.len(), 0);

map.insert("foo", 0);

assert_eq!(map.len(), 1);
```

--------------------------------

### Install XCB Dependencies on Debian-based Systems

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/index.html

On Linux, this crate requires certain parts of XCB to be installed. Use this command on Debian-based systems.

```bash
sudo apt install libxcb-render0-dev libxcb-shape0-dev libxcb-xfixes0-dev
```

--------------------------------

### HashMap Keys Iteration Example

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiManagedTextures.html

Shows how to iterate over the keys of a HashMap. The order of iteration is not guaranteed.

```rust
let mut map = HashMap::new();

map.insert("foo", 0);
map.insert("bar", 1);
map.insert("baz", 2);

for key in map.keys() {
    // foo, bar, baz
    // Note that the above order is not guaranteed
}
```

--------------------------------

### begin_pass_system

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/fn.begin_pass_system.html

Marks a pass start for Egui. This system is responsible for initializing the Egui context for the current rendering pass.

```APIDOC
## Function begin_pass_system

### Description
Marks a pass start for Egui.

### Signature
```rust
pub fn begin_pass_system(
    contexts: Query<'_, '_, (&mut EguiContext, &EguiContextSettings, &mut EguiInput), Without<EguiMultipassSchedule>>,
)
```

### Parameters
#### `contexts` Query
- `&mut EguiContext`: Mutable reference to the Egui context.
- `&EguiContextSettings`: Reference to the Egui context settings.
- `&mut EguiInput`: Mutable reference to the Egui input state.
- `Without<EguiMultipassSchedule>`: Ensures this system does not run if `EguiMultipassSchedule` is present.
```

--------------------------------

### HashMap Capacity Example

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiManagedTextures.html

Demonstrates how to check the capacity of a HashMap. This is useful for pre-allocating memory when the approximate number of elements is known.

```rust
let map = HashMap::with_capacity(5);

assert!(map.capacity() >= 5);
```

--------------------------------

### f32::total_cmp Example

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiPickingOrder.html

Demonstrates how to use the total_cmp method for f32 to establish a total ordering, which is useful for sorting, especially when dealing with NaN and infinities.

```rust
struct GoodBoy {
    name: String,
    weight: f32,
}

let mut bois = vec![
    GoodBoy { name: "Pucci".to_owned(), weight: 0.1 },
    GoodBoy { name: "Woofer".to_owned(), weight: 99.0 },
    GoodBoy { name: "Yapper".to_owned(), weight: 10.0 },
    GoodBoy { name: "Chonk".to_owned(), weight: f32::INFINITY },
    GoodBoy { name: "Abs. Unit".to_owned(), weight: f32::NAN },
    GoodBoy { name: "Floaty".to_owned(), weight: -5.0 },
];

bois.sort_by(|a, b| a.weight.total_cmp(&b.weight));

// `f32::NAN` could be positive or negative, which will affect the sort order.
if f32::NAN.is_sign_negative() {
    assert!(bois.into_iter().map(|b| b.weight)
        .zip([f32::NAN, -5.0, 0.1, 10.0, 99.0, f32::INFINITY].iter())
        .all(|(a, b)| a.to_bits() == b.to_bits()))
} else {
    assert!(bois.into_iter().map(|b| b.weight)
        .zip([-5.0, 0.1, 10.0, 99.0, f32::INFINITY, f32::NAN].iter())
        .all(|(a, b)| a.to_bits() == b.to_bits()))
}
```

--------------------------------

### HashMap Key-Value Pair Iteration Example

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiManagedTextures.html

Shows how to iterate over both keys and values of a HashMap simultaneously. The order of iteration is not guaranteed.

```rust
let mut map = HashMap::new();

map.insert("foo", 0);
map.insert("bar", 1);
map.insert("baz", 2);

for (key, value) in map.iter() {
    // ("foo", 0), ("bar", 1), ("baz", 2)
    // Note that the above order is not guaranteed
}
```

--------------------------------

### HashMap Values Iteration Example

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiManagedTextures.html

Demonstrates iterating over the values of a HashMap. The order of iteration is not guaranteed.

```rust
let mut map = HashMap::new();

map.insert("foo", 0);
map.insert("bar", 1);
map.insert("baz", 2);

for key in map.values() {
    // 0, 1, 2
    // Note that the above order is not guaranteed
}
```

--------------------------------

### Getting HashMap Entry by Reference

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiManagedTextures.html

Illustrates using entry_ref to get or insert a value for a key using a reference.

```rust
let mut map = HashMap::new();

let value = map.entry_ref("foo").or_insert(0);
```

--------------------------------

### Hooking into EguiPreUpdateSet::ProcessInput

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/enum.EguiPreUpdateSet.html

Example of how to insert a custom system to run after input processing but before the egui pass begins. This is useful for modifying egui input.

```rust
system.after(EguiPreUpdateSet::ProcessInput).before(EguiSet::BeginPass)
```

--------------------------------

### Implementing Plugin Support for Bevy Egui

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiPlugin.html

This example demonstrates how a plugin can correctly integrate with EguiPlugin, ensuring support for both single-pass and multi-pass modes. It asserts that EguiPlugin is added by the user and adds UI systems to the EguiPrimaryContextPass schedule.

```rust
pub struct MyPlugin;

impl Plugin for MyPlugin {
    fn build(&self, app: &mut App) {
        // Don't add the plugin for users, let them chose the default mode themselves
        // and just make sure they initialize EguiPlugin before yours.
        assert!(app.is_plugin_added::<EguiPlugin>());

        app.add_systems(EguiPrimaryContextPass, ui_system);
    }
}

fn ui_system(contexts: EguiContexts) -> Result {
    // ...
    Ok(())
}
```

--------------------------------

### Get or insert entry by reference in HashMap

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiManagedTextures.html

Shows how to use `entry_ref` to get an entry by a borrowed key, inserting a default value if the key doesn't exist. This is useful when the key type is complex or expensive to clone.

```rust
use hashbrown::HashMap;

let mut words: HashMap<String, usize> = HashMap::new();
let source = ["poneyland", "horseyland", "poneyland", "poneyland"];
for (i, &s) in source.iter().enumerate() {
    let counter = words.entry_ref(s).or_insert(0);
    *counter += 1;
}

assert_eq!(words["poneyland"], 3);
assert_eq!(words["horseyland"], 1);
```

--------------------------------

### EguiContext Methods

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiContext.html

Provides methods to interact with the underlying Egui context. `get` allows for an immutable borrow, while `get_mut` allows for a mutable borrow.

```APIDOC
## EguiContext

### Description
A component for storing `bevy_egui` context.

### Methods

#### `get(&self) -> &Context`
Borrows the underlying Egui context immutably.

#### `get_mut(&mut self) -> &mut Context`
Borrows the underlying Egui context mutably.

```

--------------------------------

### HashMap Is Empty Check Example

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiManagedTextures.html

Demonstrates how to check if a HashMap is empty, returning true if it contains no elements.

```rust
let mut map = HashMap::new();

assert!(map.is_empty());

map.insert("foo", 0);

assert!(!map.is_empty());
```

--------------------------------

### HashMap Retain Example

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiManagedTextures.html

Shows how to retain only the elements in a HashMap that satisfy a given predicate. This operation keeps the allocated memory.

```rust
let mut map = HashMap::new();

map.insert("foo", 0);
map.insert("bar", 1);
map.insert("baz", 2);

map.retain(|key, value| *value == 2);

assert_eq!(map.len(), 1);
```

--------------------------------

### Function Signature: setup_primary_egui_context_system

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/fn.setup_primary_egui_context_system.html

This is the function signature for `setup_primary_egui_context_system`. It outlines the parameters it accepts: commands for world manipulation, a query for new cameras with optional EguiContext, and a local boolean to track context existence.

```rust
pub fn setup_primary_egui_context_system(
    commands: Commands<'_, '_>,
    new_cameras: Query<'_, '_, (Entity, Option<&EguiContext>), Added<Camera>>,
    egui_context_exists: Local<'_, bool>,
) -> Result
```

--------------------------------

### Egui Integration with Multiple Contexts and Custom Schedules

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiPlugin.html

Shows how to set up EguiPlugin for multiple contexts, including a second window, by defining custom schedules and manually assigning them.

```rust
#[derive(ScheduleLabel, Clone, Debug, PartialEq, Eq, Hash)]
pub struct SecondWindowContextPass;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(EguiPlugin::default())
        .add_systems(Startup, setup_system)
        .add_systems(EguiPrimaryContextPass, ui_example_system)
        .add_systems(SecondWindowContextPass, ui_example_system)
        .run();
}

fn setup_system(
    mut commands: Commands,
    mut egui_global_settings: ResMut<EguiGlobalSettings>,
) {
    // Disable the automatic creation of a primary context to set it up manually.
    egui_global_settings.auto_create_primary_context = false;
    // Spawn a camera for the primary window.
    commands.spawn((Camera3d::default(), PrimaryEguiContext));
    // Spawn the second window and its camera.
    let second_window_id = commands.spawn(Window::default()).id();
    commands.spawn(( 
        EguiMultipassSchedule::new(SecondWindowContextPass),
        Camera3d::default(),
        Camera::default(),
        RenderTarget::Window(WindowRef::Entity(second_window_id)),
    ));
}

fn ui_example_system(contexts: EguiContexts) -> Result {
    // ...
    Ok(())
}
```

--------------------------------

### Getting Disjoint Mutable References from HashMap

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiManagedTextures.html

Shows how to attempt to get mutable references to multiple values in a HashMap simultaneously.

```rust
let mut map = HashMap::new();

map.insert("foo", 0);

// Example usage for get_disjoint_mut would go here, but the source only provides the signature.
```

--------------------------------

### Getting HashMap Entry with Default Value

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiManagedTextures.html

Demonstrates using the entry API to get or insert a value for a given key.

```rust
let mut map = HashMap::new();

let value = map.entry("foo").or_insert(0);
```

--------------------------------

### setup_primary_egui_context_system

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/fn.setup_primary_egui_context_system.html

Sets up the primary Egui context for a camera. This function is automatically called by the bevy_egui plugin to initialize the Egui context on the primary camera. It can be configured via `EguiGlobalSettings::auto_create_primary_context` and `EguiPrimaryContextPass` component.

```APIDOC
## Function setup_primary_egui_context_system

### Description
Adds bevy_egui components to a first found camera assuming it’s a primary one.
To disable this behavior, set `EguiGlobalSettings::auto_create_primary_context` to `false` before you create your first camera. When spawning a camera to which you want to attach the primary Egui context, insert the `EguiPrimaryContextPass` component into the respective camera entity.

### Signature
```rust
pub fn setup_primary_egui_context_system(
    commands: Commands<'_, '_>,
    new_cameras: Query<'_, '_, (Entity, Option<&EguiContext>), Added<Camera>>,
    egui_context_exists: Local<'_, bool>,
) -> Result
```

### Parameters
* `commands`: Commands for managing Bevy entities and resources.
* `new_cameras`: A query for entities that are new cameras and may or may not have an EguiContext.
* `egui_context_exists`: A local variable to track if an Egui context has already been established.
```

--------------------------------

### Basic Egui Integration with Primary Context Pass

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiPlugin.html

Demonstrates setting up a Bevy application with EguiPlugin and using the EguiPrimaryContextPass schedule for UI elements.

```rust
fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(EguiPlugin::default())
        .add_systems(Startup, setup_camera_system)
        .add_systems(EguiPrimaryContextPass, ui_example_system)
        .run();
}
fn setup_camera_system(mut commands: Commands) {
    commands.spawn(Camera2d);
}
fn ui_example_system(contexts: EguiContexts) -> Result {
    // ...
    Ok(())
}
```

--------------------------------

### impl<S> GetField for S

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiContextSettings.html

Provides methods to get or mutably get fields of a struct by name, downcasting to a specific reflected type.

```APIDOC
## impl<S> GetField for S

### Description
Provides methods to get or mutably get fields of a struct by name, downcasting to a specific reflected type.

### Methods
#### fn get_field<T>(&self, name: &str) -> Option<&T>
where T: Reflect,
Returns a reference to the value of the field named `name`, downcast to `T`.

#### fn get_field_mut<T>(&mut self, name: &str) -> Option<&mut T>
where T: Reflect,
Returns a mutable reference to the value of the field named `name`, downcast to `T`.
```

--------------------------------

### Get Option<&[T]> with as_slice

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiFullOutput.html

Use `as_slice()` to get a slice of the contained value, or an empty slice if the Option is None. Useful for uniform iteration.

```rust
assert_eq!(
    [Some(1234).as_slice(), None.as_slice()],
    [&[1234][..], &[][..]],
);
```

--------------------------------

### Any Implementation for EguiStartupSet

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/enum.EguiStartupSet.html

Provides runtime type information for EguiStartupSet.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Get Option<&mut [T]> with as_mut_slice

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiFullOutput.html

Use `as_mut_slice()` to get a mutable slice of the contained value, or an empty slice if the Option is None. Allows in-place modification.

```rust
assert_eq!(
    [Some(1234).as_mut_slice(), None.as_mut_slice()],
    [&mut [1234][..], &mut [][..]],
);

let mut x = Some(1234);
x.as_mut_slice()[0] += 1;
assert_eq!(x, Some(1235));
```

--------------------------------

### Get Mutable References to Disjoint Keys

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiManagedTextures.html

Demonstrates how to get mutable references to multiple disjoint values in a HashMap using `get_disjoint_mut`. This is useful when you need to modify several independent entries simultaneously.

```rust
let mut map = HashMap::new();

map.insert("foo", 0);
map.insert("bar", 1);
map.insert("baz", 2);

let result = map.get_disjoint_mut(["foo", "bar"]);

assert_eq!(result, [Some(&mut 0), Some(&mut 1)]);
```

--------------------------------

### CloneToUninit Implementation for EguiStartupSet

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/enum.EguiStartupSet.html

Provides experimental functionality for cloning EguiStartupSet into uninitialized memory.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### get

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiManagedTextures.html

Returns a reference to the value corresponding to the key.

```APIDOC
## pub fn get<Q>(&self, k: &Q) -> Option<&V>

### Description
Returns a reference to the value corresponding to the key.

### Method
`get`

### Parameters
* `k` (&Q) - The key to look up.

### Returns
An `Option` containing a reference to the value if the key exists, otherwise `None`.

### Type Parameters
* `Q`: The type of the key, which must implement `Hash` and `Equivalent<K>`.

### Examples
```rust
let mut map = HashMap::new();

map.insert("foo", 0);

assert_eq!(map.get("foo"), Some(&0));
```
```

--------------------------------

### get

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/render/systems/struct.EguiTextureBindGroups.html

Returns a reference to the value corresponding to the key, if it exists.

```APIDOC
## pub fn get<Q>(&self, k: &Q) -> Option<&V>

Returns a reference to the value corresponding to the key.
The key may be any borrowed form of the map’s key type, but `Hash` and `Eq` on the borrowed form _must_ match those for the key type.
where Q: Hash + Equivalent<K> + ?Sized,
##### §Examples
```
use hashbrown::HashMap;

let mut map = HashMap::new();
map.insert(1, "a");
assert_eq!(map.get(&1), Some(&"a"));
assert_eq!(map.get(&2), None);
```
```

--------------------------------

### Updating UI Scale Factor Based on Camera

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiContextSettings.html

Example of how to dynamically update the Egui scale factor based on the camera's target scaling factor. This is useful for ensuring UI consistency across different display DPIs or scaling settings.

```rust
use bevy::{prelude::*,
 window::PrimaryWindow};
use bevy_egui::EguiContextSettings;

fn update_ui_scale_factor(mut egui_contexts: Query<(&mut EguiContextSettings, &Camera)>) {
    for (mut egui_settings, camera) in egui_contexts {
        egui_settings.scale_factor = 1.0 / camera.target_scaling_factor().unwrap_or(1.0);
    }
}
```

--------------------------------

### into_configs

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/enum.EguiStartupSet.html

Converts the system set into `ScheduleConfigs`.

```APIDOC
## fn into_configs(self) -> ScheduleConfigs<Interned<dyn SystemSet>>

Convert into a `ScheduleConfigs`.

### Method

`into_configs`
```

--------------------------------

### get_disjoint_mut

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiManagedTextures.html

Attempts to get mutable references to N values in the map at once.

```APIDOC
## pub fn get_disjoint_mut<Q, const N: usize>( &mut self, ks: [&Q; N], ) -> [Option<&mut V>; N]

### Description
Attempts to get mutable references to `N` values in the map at once.

### Method
`get_disjoint_mut`

### Parameters
* `ks` ([&Q; N]) - An array of references to keys for which to get mutable references to values.

### Returns
An array of `Option`s, where each `Option` contains a mutable reference to the value if the corresponding key exists, otherwise `None`.

### Type Parameters
* `Q`: The type of the keys, which must implement `Hash` and `Equivalent<K>`.
* `N`: The number of keys to look up.

### Details
Refer to `get_disjoint_mut` for further details.
```

--------------------------------

### PartialEq Implementation for EguiStartupSet

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/enum.EguiStartupSet.html

Enables equality comparison for EguiStartupSet values.

```rust
fn eq(&self, other: &EguiStartupSet) -> bool
```

```rust
fn ne(&self, other: &Rhs) -> bool
```

--------------------------------

### entry

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiManagedTextures.html

Gets the given key’s corresponding entry in the map for in-place manipulation.

```APIDOC
## pub fn entry(&mut self, key: K) -> Entry<'_, K, V, S>

### Description
Gets the given key’s corresponding entry in the map for in-place manipulation.

### Method
`entry`

### Parameters
* `key` (K) - The key to get the entry for.

### Returns
An `Entry` enum that allows for in-place manipulation.

### Examples
```rust
let mut map = HashMap::new();

let value = map.entry("foo").or_insert(0);
```
```

--------------------------------

### Getting Key-Value Pair from HashMap

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiManagedTextures.html

Demonstrates retrieving both the key and value as references from a HashMap.

```rust
let mut map = HashMap::new();

map.insert("foo", 0);

assert_eq!(map.get_key_value("foo"), Some((&"foo", &0)));
```

--------------------------------

### DynEq Implementation for EguiStartupSet

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/enum.EguiStartupSet.html

Enables dynamic equality comparison for EguiStartupSet.

```rust
fn dyn_eq(&self, other: &(dyn DynEq + 'static)) -> bool
```

--------------------------------

### Getting Value from HashMap

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiManagedTextures.html

Shows how to retrieve a reference to a value associated with a key in a HashMap.

```rust
let mut map = HashMap::new();

map.insert("foo", 0);

assert_eq!(map.get("foo"), Some(&0));
```

--------------------------------

### IntoScheduleConfigs

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/enum.EguiPostUpdateSet.html

Provides methods to configure how a collection of systems is scheduled, including ordering, run conditions, and set membership.

```APIDOC
## impl<S> IntoScheduleConfigs<Interned<dyn SystemSet>, ()> for S
where S: SystemSet

### Description
Methods for configuring system scheduling.

#### Methods
- `into_configs()`: Convert into a `ScheduleConfigs`.
- `in_set(set)`: Add these systems to the provided `set`.
- `before(set)`: Runs before all systems in `set`. If `self` has any systems that produce `Commands` or other `Deferred` operations, all systems in `set` will see their effect.
- `after(set)`: Run after all systems in `set`. If `set` has any systems that produce `Commands` or other `Deferred` operations, all systems in `self` will see their effect.
- `before_ignore_deferred(set)`: Run before all systems in `set`.
- `after_ignore_deferred(set)`: Run after all systems in `set`.
- `distributive_run_if(condition)`: Add a run condition to each contained system.
- `run_if(condition)`: Run the systems only if the `SystemCondition` is `true`.
- `ambiguous_with(set)`: Suppress warnings and errors that would result from these systems having ambiguities (conflicting access but indeterminate order) with systems in `set`.
- `ambiguous_with_all()`: Suppress warnings and errors that would result from these systems having ambiguities (conflicting access but indeterminate order) with any other system.
- `chain()`: Treat this collection as a sequence of systems.
- `chain_ignore_deferred()`: Treat this collection as a sequence of systems.
```

--------------------------------

### before

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/enum.EguiStartupSet.html

Runs these systems before all systems in the specified `set`. If `self` has any systems that produce `Commands` or other `Deferred` operations, all systems in `set` will see their effect.

```APIDOC
## fn before<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>

Runs before all systems in `set`. If `self` has any systems that produce `Commands` or other `Deferred` operations, all systems in `set` will see their effect.

### Method

`before`

### Parameters

* `set` (impl IntoSystemSet<M>): The system set to run before.
```

--------------------------------

### entry_ref

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiManagedTextures.html

Gets the given key’s corresponding entry by reference in the map for in-place manipulation.

```APIDOC
## pub fn entry_ref<'a, 'b, Q>( &'a mut self, key: &'b Q, ) -> EntryRef<'a, 'b, K, Q, V, S>

### Description
Gets the given key’s corresponding entry by reference in the map for in-place manipulation.

### Method
`entry_ref`

### Parameters
* `key` (&'b Q) - The key to get the entry for, as a reference.

### Returns
An `EntryRef` enum that allows for in-place manipulation.

### Type Parameters
* `'a`, `'b`: Lifetimes associated with the mutable reference to self and the key reference.
* `Q`: The type of the key, which must implement `Hash` and `Equivalent<K>`.

### Examples
```rust
let mut map = HashMap::new();

let value = map.entry_ref("foo").or_insert(0);
```
```

--------------------------------

### Get MultiPassEguiQueryState

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.MultiPassEguiQuery.html

Attempts to initialize a State for this WorldQuery type using read-only access to Components.

```rust
fn get_state(components: &Components) -> Option<MultiPassEguiQueryState>
```

--------------------------------

### Reflection Methods

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiInputSystemSettings.html

Provides methods for interacting with EguiInputSystemSettings through reflection, allowing dynamic access and manipulation of its properties.

```APIDOC
## Reflection Methods

### `try_as_reflect`
Attempts to cast this type to a fully-reflected value.

### `try_as_reflect_mut`
Attempts to cast this type to a mutable, fully-reflected value.

### `into_partial_reflect`
Casts this type to a boxed, reflected value.

### `as_partial_reflect`
Casts this type to a reflected value.

### `as_partial_reflect_mut`
Casts this type to a mutable, reflected value.

### `reflect_partial_eq`
Returns a “partial equality” comparison result.

### `reflect_clone`
Attempts to clone `Self` using reflection.

### `apply`
Applies a reflected value to this value.

### `to_dynamic`
Converts this reflected value into its dynamic representation based on its kind.

### `reflect_clone_and_take`
Combines `reflect_clone` and `take` for types implementing `PartialReflect`.

### `reflect_hash`
Returns a hash of the value (which includes the type).

### `debug`
Debug formatter for the value.

### `is_dynamic`
Indicates whether or not this type is a _dynamic_ type.
```

--------------------------------

### EguiMultipassSchedule TypeId Implementation

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiMultipassSchedule.html

Implementation of the Any trait for EguiMultipassSchedule, providing a way to get the TypeId of the component.

```rust
fn type_id(&self) -> TypeId

```

--------------------------------

### CloneToUninit Implementation

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/input/struct.HoveredNonWindowEguiContext.html

Details the `clone_to_uninit` method, an experimental nightly-only API for copying data to uninitialized memory.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8);

```

--------------------------------

### get_disjoint_key_value_mut

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/render/systems/struct.EguiTextureBindGroups.html

Attempts to get mutable references to multiple values along with immutable references to their corresponding keys.

```APIDOC
## pub fn get_disjoint_key_value_mut<Q, const N: usize>( &mut self, ks: [&Q; N], ) -> [Option<(&K, &mut V)>; N]

### Description
Attempts to get mutable references to `N` values in the map at once, with immutable references to the corresponding keys. Returns an array of length `N` with the results of each query. For soundness, at most one mutable reference will be returned to any value. `None` will be used if the key is missing.

### Method
`get_disjoint_key_value_mut`

### Parameters
#### Path Parameters
- **ks** (*[&Q; N]*) - Required - An array of keys to look up.

### Panics
Panics if any keys are overlapping.

### Response
#### Success Response ([Option<(&K, &mut V)>; N])
- An array of `N` elements, where each element is `Some((&K, &mut V))` if the corresponding key exists and a mutable reference could be obtained, or `None` if the key is missing.
```

--------------------------------

### Set Text on Clipboard

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiClipboard.html

Use this method to place text content onto the system clipboard. Ensure the 'manage_clipboard' feature is enabled.

```rust
pub fn set_text(&mut self, contents: &str)
```

--------------------------------

### StructuralPartialEq Implementation for EguiStartupSet

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/enum.EguiStartupSet.html

Enables structural equality comparison for EguiStartupSet.

```rust
impl StructuralPartialEq for EguiStartupSet
```

--------------------------------

### Get HashMap Hasher

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiManagedTextures.html

Retrieves the hasher used by a HashMap. Useful for understanding or replicating the hashing strategy.

```rust
use hashbrown::HashMap;
use hashbrown::DefaultHashBuilder;

let hasher = DefaultHashBuilder::default();
let map: HashMap<i32, i32> = HashMap::with_hasher(hasher);
let hasher: &DefaultHashBuilder = map.hasher();
```

--------------------------------

### Getting Mutable Value from HashMap

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiManagedTextures.html

Demonstrates retrieving a mutable reference to a value associated with a key in a HashMap.

```rust
let mut map = HashMap::new();

map.insert("foo", 0);

assert_eq!(map.get_mut("foo"), Some(&mut 0));
```

--------------------------------

### Update UI Size and Scale System

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/fn.update_ui_size_and_scale_system.html

This system updates the `egui::RawInput::screen_rect` and calls `egui::Context::set_pixels_per_point`. It requires a query for `UpdateUiSizeAndScaleQuery`.

```rust
pub fn update_ui_size_and_scale_system(
    contexts: Query<'_, '_, UpdateUiSizeAndScaleQuery>,
)
```

--------------------------------

### handle_move_system

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/picking/fn.handle_move_system.html

Ray-casts a mesh rendering a pickable Egui context and updates its EguiContextPointerPosition component.

```APIDOC
## Function handle_move_system

### Description
Ray-casts a mesh rendering a pickable Egui context and updates its `EguiContextPointerPosition` component.

### Source
```rust
pub fn handle_move_system(
    event: On<'_, '_, Pointer<Move>>,
    mesh_ray_cast: MeshRayCast<'_, '_>,
    egui_pointers: Query<'_, '_, &mut EguiContextPointerPosition>,
    egui_contexts: Query<'_, '_, (&Camera, &GlobalTransform, &RenderTarget), With<EguiContext>>,
    pickable_egui_context_query: Query<'_, '_, (&PickableEguiContext, AnyOf<(&Mesh2d, &Mesh3d)>)>,
    primary_window_query: Query<'_, '_, Entity, With<PrimaryWindow>>,
    meshes: Res<'_, Assets<Mesh>>,
) -> Result
```

### Parameters
* **event**: `On<'_, '_, Pointer<Move>>` - Represents a pointer move event.
* **mesh_ray_cast**: `MeshRayCast<'_, '_>` - Provides mesh ray casting capabilities.
* **egui_pointers**: `Query<'_, '_, &mut EguiContextPointerPosition>` - Queries for mutable `EguiContextPointerPosition` components.
* **egui_contexts**: `Query<'_, '_, (&Camera, &GlobalTransform, &RenderTarget), With<EguiContext>>` - Queries for Egui contexts with associated camera, transform, and render target.
* **pickable_egui_context_query**: `Query<'_, '_, (&PickableEguiContext, AnyOf<(&Mesh2d, &Mesh3d)>)>` - Queries for pickable Egui contexts with either a 2D or 3D mesh.
* **primary_window_query**: `Query<'_, '_, Entity, With<PrimaryWindow>>` - Queries for the primary window entity.
* **meshes**: `Res<'_, Assets<Mesh>>` - Resource containing mesh assets.
```

--------------------------------

### Getting Mutable Key-Value Pair from HashMap

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiManagedTextures.html

Shows how to retrieve a key and a mutable reference to its value from a HashMap.

```rust
let mut map = HashMap::new();

map.insert("foo", 0);

assert_eq!(map.get_key_value_mut("foo"), Some((&"foo", &mut 0)));
```

--------------------------------

### Get UpdateUiSizeAndScaleQuery State

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.UpdateUiSizeAndScaleQuery.html

Attempts to initialize a State for this WorldQuery type using read-only access to Components.

```rust
fn get_state(components: &Components) -> Option<UpdateUiSizeAndScaleQueryState>
```

--------------------------------

### impl<T> IntoScheduleConfigs<Interned<dyn SystemSet>, ()> for S

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/enum.EguiInputSet.html

Provides methods to configure how systems within a set are scheduled and executed, including ordering, conditions, and ambiguity resolution.

```APIDOC
## impl<S> IntoScheduleConfigs<Interned<dyn SystemSet>, ()> for S
where S: SystemSet,

### Description
Provides methods to configure how systems within a set are scheduled and executed, including ordering, conditions, and ambiguity resolution.

### Methods

#### fn into_configs(self) -> ScheduleConfigs<Interned<dyn SystemSet>>
Convert into a `ScheduleConfigs`.

#### fn in_set(self, set: impl SystemSet) -> ScheduleConfigs<T>
Add these systems to the provided `set`.

#### fn before<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>
Runs before all systems in `set`. If `self` has any systems that produce `Commands` or other `Deferred` operations, all systems in `set` will see their effect.

#### fn after<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>
Run after all systems in `set`. If `set` has any systems that produce `Commands` or other `Deferred` operations, all systems in `self` will see their effect.

#### fn before_ignore_deferred<M>( self, set: impl IntoSystemSet<M>, ) -> ScheduleConfigs<T>
Run before all systems in `set`.

#### fn after_ignore_deferred<M>( self, set: impl IntoSystemSet<M>, ) -> ScheduleConfigs<T>
Run after all systems in `set`.

#### fn distributive_run_if<M>( self, condition: impl SystemCondition<M> + Clone, ) -> ScheduleConfigs<T>
Add a run condition to each contained system.

#### fn run_if<M>(self, condition: impl SystemCondition<M>) -> ScheduleConfigs<T>
Run the systems only if the `SystemCondition` is `true`.

#### fn ambiguous_with<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>
Suppress warnings and errors that would result from these systems having ambiguities (conflicting access but indeterminate order) with systems in `set`.

#### fn ambiguous_with_all(self) -> ScheduleConfigs<T>
Suppress warnings and errors that would result from these systems having ambiguities (conflicting access but indeterminate order) with any other system.

#### fn chain(self) -> ScheduleConfigs<T>
Treat this collection as a sequence of systems.
```

--------------------------------

### queue_pipelines_system

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/render/systems/fn.queue_pipelines_system.html

Queues EguiPipeline instances. This system is responsible for setting up the necessary pipelines for rendering egui elements within the Bevy engine.

```APIDOC
## queue_pipelines_system

### Description
Queue `EguiPipeline` instances.

### Function Signature
```rust
pub fn queue_pipelines_system(
    commands: Commands<'_, '_>,
    pipeline_cache: Res<'_, PipelineCache>,
    specialized_pipelines: ResMut<'_, SpecializedRenderPipelines<EguiPipeline>>,
    egui_pipeline: Res<'_, EguiPipeline>,
    egui_views: Query<'_, '_, &EguiViewTarget, With<ExtractedView>>,
    camera_views: Query<'_, '_, (&MainEntity, &ExtractedCamera)>
)
```

### Parameters
- **commands**: Commands<'_, '_> - The Bevy commands system.
- **pipeline_cache**: Res<'_, PipelineCache> - The Bevy pipeline cache resource.
- **specialized_pipelines**: ResMut<'_, SpecializedRenderPipelines<EguiPipeline>> - Mutable resource for specialized render pipelines.
- **egui_pipeline**: Res<'_, EguiPipeline> - Resource for the Egui pipeline.
- **egui_views**: Query<'_, '_, &EguiViewTarget, With<ExtractedView>> - Query for EguiViewTarget with ExtractedView.
- **camera_views**: Query<'_, '_, (&MainEntity, &ExtractedCamera)> - Query for camera views.
```

--------------------------------

### Dynamic Bundle Operations

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/picking/struct.PickableEguiContext.html

Methods for handling dynamic bundles, including getting components and applying effects.

```APIDOC
## type Effect = ()

An operation on the entity that happens _after_ inserting this bundle.

## unsafe fn get_components( ptr: MovingPtr<'_, C>, func: &mut impl FnMut(StorageType, OwningPtr<'_>), ) -> <C as DynamicBundle>::Effect

Moves the components out of the bundle.

## unsafe fn apply_effect( _ptr: MovingPtr<'_, MaybeUninit<C>>, _entity: &mut EntityWorldMut<'_>, )

Applies the after-effects of spawning this bundle.
```

--------------------------------

### Borrow Implementation for EguiStartupSet

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/enum.EguiStartupSet.html

Enables borrowing EguiStartupSet values.

```rust
fn borrow(&self) -> &T
```

--------------------------------

### Get &dyn Any from &Trait

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/picking/struct.PickableEguiContext.html

Converts `&Trait` to `&Any`. This is necessary because Rust cannot generate `&Any`'s vtable from `&Trait`'s.

```rust
fn as_any(&self) -> &(dyn Any + 'static)
```

--------------------------------

### prepare_egui_transforms_system

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/render/systems/fn.prepare_egui_transforms_system.html

Prepares Egui transforms by processing various Bevy resources and queries related to rendering and camera views. This system is crucial for correctly applying transformations to Egui elements within the Bevy engine.

```APIDOC
## Function prepare_egui_transforms_system

### Description
Prepares Egui transforms.

### Signature
```rust
pub fn prepare_egui_transforms_system(
    egui_transforms: ResMut<'_, EguiTransforms>,
    views: Query<'_, '_, &RenderComputedScaleFactor>,
    render_targets: Query<'_, '_, (&ExtractedView, &ExtractedCamera, &EguiCameraView)>,
    render_device: Res<'_, RenderDevice>,
    render_queue: Res<'_, RenderQueue>,
    pipeline_cache: Res<'_, PipelineCache>,
    egui_pipeline: Res<'_, EguiPipeline>,
) -> Result
```

### Parameters

- **egui_transforms**: `ResMut<'_, EguiTransforms>` - Mutable resource for Egui transforms.
- **views**: `Query<'_, '_, &RenderComputedScaleFactor>` - Query for render views to get computed scale factors.
- **render_targets**: `Query<'_, '_, (&ExtractedView, &ExtractedCamera, &EguiCameraView)>` - Query for render targets including extracted view, camera, and Egui camera view.
- **render_device**: `Res<'_, RenderDevice>` - Resource for the render device.
- **render_queue**: `Res<'_, RenderQueue>` - Resource for the render queue.
- **pipeline_cache**: `Res<'_, PipelineCache>` - Resource for the pipeline cache.
- **egui_pipeline**: `Res<'_, EguiPipeline>` - Resource for the Egui rendering pipeline.

### Returns

- **Result**: Indicates success or failure of the operation.
```

--------------------------------

### positions

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/input/struct.EguiContextsMessageIterator.html

Return an iterator adaptor that yields the indices of all elements satisfying a predicate, counted from the start of the iterator.

```APIDOC
## fn positions<P>(self, predicate: P) -> Positions<Self, P>

### Description
Return an iterator adaptor that yields the indices of all elements satisfying a predicate, counted from the start of the iterator.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Method
N/A (Iterator method)

### Endpoint
N/A (Iterator method)

### Request Example
None

### Response
#### Success Response
`Positions<Self, P>`: An iterator adaptor that yields the indices of elements that satisfy the given predicate.
```

--------------------------------

### Get HashMap Length

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiManagedTextures.html

Returns the number of elements currently stored in the HashMap. Demonstrates checking length before and after insertion.

```rust
use hashbrown::HashMap;

let mut a = HashMap::new();
assert_eq!(a.len(), 0);
a.insert(1, "a");
assert_eq!(a.len(), 1);
```

--------------------------------

### Try to reserve capacity for HashMap

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiManagedTextures.html

Demonstrates how to attempt to reserve a specific amount of capacity for a HashMap. It shows successful reservation and handling of potential errors like capacity overflow.

```rust
use hashbrown::HashMap;

let mut map: HashMap<&str, isize> = HashMap::new();
// Map is empty and doesn't allocate memory
assert_eq!(map.capacity(), 0);

map.try_reserve(10).expect("why is the test harness OOMing on 10 bytes?");

// And now map can hold at least 10 elements
assert!(map.capacity() >= 10);
```

```rust
use hashbrown::HashMap;
use hashbrown::TryReserveError;
let mut map: HashMap<i32, i32> = HashMap::new();

match map.try_reserve(usize::MAX) {
    Err(error) => match error {
        TryReserveError::CapacityOverflow => {}
        _ => panic!("TryReserveError::AllocError ?"),
    },
    _ => panic!(),
}
```

--------------------------------

### Get Component IDs Iterator

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiRenderOutput.html

Retrieves an iterator over the component IDs of a bundle. Returns None if a component is not registered.

```rust
fn get_component_ids( components: &Components, ) -> impl Iterator<Item = Option<ComponentId>>
```

--------------------------------

### process_ime_system

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/input/fn.process_ime_system.html

This system processes Egui output to determine if the virtual keyboard should be shown. It checks the `ime` field in `EguiOutput` and calls `Window::set_ime_allowed` accordingly.

```APIDOC
## process_ime_system

### Description
Shows the virtual keyboard when a text input is focused. Works by reading `EguiOutput` and calling `Window::set_ime_allowed` if the `ime` field is set.

### Function Signature
```rust
pub fn process_ime_system(
    egui_context_query: Query<'_, '_, (Entity, &EguiOutput, &EguiContextSettings, &mut EguiContext, &mut EguiContextImeState)>,
    window_to_egui_context_map: Res<'_, WindowToEguiContextMap>,
    _non_send_marker: NonSendMarker,
)
```

### Parameters

*   **`egui_context_query`** (Query): Queries for entities with `EguiOutput`, `EguiContextSettings`, `EguiContext`, and `EguiContextImeState`.
*   **`window_to_egui_context_map`** (Res): A resource mapping windows to Egui contexts.
*   **`_non_send_marker`** (NonSendMarker): A marker to indicate this system does not use non-send resources.
```

--------------------------------

### after

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/enum.EguiStartupSet.html

Runs these systems after all systems in the specified `set`. If `set` has any systems that produce `Commands` or other `Deferred` operations, all systems in `self` will see their effect.

```APIDOC
## fn after<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>

Run after all systems in `set`. If `set` has any systems that produce `Commands` or other `Deferred` operations, all systems in `self` will see their effect.

### Method

`after`

### Parameters

* `set` (impl IntoSystemSet<M>): The system set to run after.
```

--------------------------------

### Get Components from Bundle

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/picking/struct.PickableEguiContext.html

Moves components out of a bundle. This is an unsafe operation that requires careful handling of pointers and closures.

```rust
unsafe fn get_components( ptr: MovingPtr<'_, C>, func: &mut impl FnMut(StorageType, OwningPtr<'_>), ) -> <C as DynamicBundle>::Effect
```

--------------------------------

### Debug Implementation for EguiStartupSet

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/enum.EguiStartupSet.html

Enables debugging EguiStartupSet values.

```rust
fn fmt(&self, f: &mut Formatter<'_>) -> Result
```

--------------------------------

### Get AssetId from EguiTextureHandle

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/enum.EguiTextureHandle.html

Retrieves the AssetId<Image> from an EguiTextureHandle, regardless of whether it's a Strong or Weak variant.

```rust
pub fn asset_id(&self) -> AssetId<Image>
```

--------------------------------

### impl Clone for EguiFullOutput

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiFullOutput.html

Provides the `clone` and `clone_from` methods for creating copies of EguiFullOutput.

```APIDOC
## impl Clone for EguiFullOutput

### Description
Provides the `clone` and `clone_from` methods for creating copies of EguiFullOutput.

### Methods
#### clone(&self) -> EguiFullOutput
Returns a duplicate of the value.

#### clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`.

### Method
N/A (Trait implementation methods).

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

--------------------------------

### Clone Implementation for PrimaryEguiContext

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.PrimaryEguiContext.html

Demonstrates the `clone` and `clone_from` methods for the PrimaryEguiContext. These methods allow for duplication of the marker component.

```rust
impl Clone for PrimaryEguiContext
Source
	fn clone(&self) -> PrimaryEguiContext
Returns a duplicate of the value. Read more
1.0.0 · Source
	fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`. Read more
Source
```

--------------------------------

### init_state

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.MultiPassEguiQueryReadOnly.html

Creates and initializes a `State` for this `WorldQuery` type. This is the primary method for setting up the query's state.

```APIDOC
## fn init_state(world: &mut World) -> MultiPassEguiQueryState

### Description
Creates and initializes a `State` for this `WorldQuery` type.

### Parameters
* `world`: A mutable reference to the `World` to initialize the state from.

### Returns
A `MultiPassEguiQueryState` instance.
```

--------------------------------

### Iterate over Option with iter

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiFullOutput.html

Use `iter()` to get an iterator over the value inside the Option. This iterator yields at most one item.

```rust
pub fn iter(&self) -> Iter<'_, T>
```

--------------------------------

### CloneToUninit

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiContext.html

An experimental, nightly-only API for performing copy-assignment from `self` to an uninitialized destination pointer.

```APIDOC
## unsafe fn clone_to_uninit(&self, dest: *mut u8)

### Description
Performs copy-assignment from `self` to `dest`.

### Method
`clone_to_uninit`
```

--------------------------------

### enumerate() Method

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/input/struct.EguiContextsMessageIterator.html

Creates a new iterator that yields pairs of (index, element), where index starts at 0 and increments for each element.

```rust
fn enumerate(self) -> Enumerate<Self>
where Self: Sized,
```

--------------------------------

### from_world

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/input/struct.EguiContextPointerTouchId.html

Creates Self using default().

```APIDOC
## fn from_world(_world: &mut World) -> T

### Description
Creates `Self` using `default()`.

### Method
`from_world`
```

--------------------------------

### EguiMultipassSchedule Bundle Get Component IDs

Source: https://docs.rs/bevy_egui/0.39.1/bevy_egui/struct.EguiMultipassSchedule.html

Returns an iterator over Option<ComponentId> for the EguiMultipassSchedule bundle. This is used to check if components have been registered.

```rust
fn get_component_ids( components: &Components, ) -> impl Iterator<Item = Option<ComponentId>>

```
Tokens:
Raw