Struct DynamicSceneRoot

Source
pub struct DynamicSceneRoot(pub Handle<DynamicScene>);
Expand description

Adding this component will spawn the scene as a child of that entity. Once it’s spawned, the entity will have a SceneInstance component.

Tuple Fields§

§0: Handle<DynamicScene>

Methods from Deref<Target = Handle<DynamicScene>>§

Source

pub fn id(&self) -> AssetId<A>

Returns the AssetId of this Asset.

Examples found in repository?
examples/stress_tests/many_text2d.rs (line 180)
167fn print_counts(
168    time: Res<Time>,
169    mut timer: Local<PrintingTimer>,
170    texts: Query<&ViewVisibility, With<Text2d>>,
171    atlases: Res<FontAtlasSets>,
172    font: Res<FontHandle>,
173) {
174    timer.tick(time.delta());
175    if !timer.just_finished() {
176        return;
177    }
178
179    let num_atlases = atlases
180        .get(font.0.id())
181        .map(|set| set.iter().map(|atlas| atlas.1.len()).sum())
182        .unwrap_or(0);
183
184    let visible_texts = texts.iter().filter(|visibility| visibility.get()).count();
185
186    info!(
187        "Texts: {} Visible: {} Atlases: {}",
188        texts.iter().count(),
189        visible_texts,
190        num_atlases
191    );
192}
More examples
Hide additional examples
examples/3d/tonemapping.rs (line 243)
222fn resize_image(
223    image_mesh: Query<(&MeshMaterial3d<StandardMaterial>, &Mesh3d), With<HDRViewer>>,
224    materials: Res<Assets<StandardMaterial>>,
225    mut meshes: ResMut<Assets<Mesh>>,
226    images: Res<Assets<Image>>,
227    mut image_events: EventReader<AssetEvent<Image>>,
228) {
229    for event in image_events.read() {
230        let (AssetEvent::Added { id } | AssetEvent::Modified { id }) = event else {
231            continue;
232        };
233
234        for (mat_h, mesh_h) in &image_mesh {
235            let Some(mat) = materials.get(mat_h) else {
236                continue;
237            };
238
239            let Some(ref base_color_texture) = mat.base_color_texture else {
240                continue;
241            };
242
243            if *id != base_color_texture.id() {
244                continue;
245            };
246
247            let Some(image_changed) = images.get(*id) else {
248                continue;
249            };
250
251            let size = image_changed.size_f32().normalize_or_zero() * 1.4;
252            // Resize Mesh
253            let quad = Mesh::from(Rectangle::from_size(size));
254            meshes.insert(mesh_h, quad);
255        }
256    }
257}
examples/shader/array_texture.rs (line 60)
50fn create_array_texture(
51    mut commands: Commands,
52    asset_server: Res<AssetServer>,
53    mut loading_texture: ResMut<LoadingTexture>,
54    mut images: ResMut<Assets<Image>>,
55    mut meshes: ResMut<Assets<Mesh>>,
56    mut materials: ResMut<Assets<ArrayTextureMaterial>>,
57) {
58    if loading_texture.is_loaded
59        || !asset_server
60            .load_state(loading_texture.handle.id())
61            .is_loaded()
62    {
63        return;
64    }
65    loading_texture.is_loaded = true;
66    let image = images.get_mut(&loading_texture.handle).unwrap();
67
68    // Create a new array texture asset from the loaded texture.
69    let array_layers = 4;
70    image.reinterpret_stacked_2d_as_array(array_layers);
71
72    // Spawn some cubes using the array texture
73    let mesh_handle = meshes.add(Cuboid::default());
74    let material_handle = materials.add(ArrayTextureMaterial {
75        array_texture: loading_texture.handle.clone(),
76    });
77    for x in -5..=5 {
78        commands.spawn((
79            Mesh3d(mesh_handle.clone()),
80            MeshMaterial3d(material_handle.clone()),
81            Transform::from_xyz(x as f32 + 0.5, 0.0, 0.0),
82        ));
83    }
84}
examples/2d/mesh2d_manual.rs (line 362)
328pub fn extract_colored_mesh2d(
329    mut commands: Commands,
330    mut previous_len: Local<usize>,
331    // When extracting, you must use `Extract` to mark the `SystemParam`s
332    // which should be taken from the main world.
333    query: Extract<
334        Query<
335            (
336                Entity,
337                RenderEntity,
338                &ViewVisibility,
339                &GlobalTransform,
340                &Mesh2d,
341            ),
342            With<ColoredMesh2d>,
343        >,
344    >,
345    mut render_mesh_instances: ResMut<RenderColoredMesh2dInstances>,
346) {
347    let mut values = Vec::with_capacity(*previous_len);
348    for (entity, render_entity, view_visibility, transform, handle) in &query {
349        if !view_visibility.get() {
350            continue;
351        }
352
353        let transforms = Mesh2dTransforms {
354            world_from_local: (&transform.affine()).into(),
355            flags: MeshFlags::empty().bits(),
356        };
357
358        values.push((render_entity, ColoredMesh2d));
359        render_mesh_instances.insert(
360            entity.into(),
361            RenderMesh2dInstance {
362                mesh_asset_id: handle.0.id(),
363                transforms,
364                material_bind_group_id: Material2dBindGroupId::default(),
365                automatic_batching: false,
366                tag: 0,
367            },
368        );
369    }
370    *previous_len = values.len();
371    commands.try_insert_batch(values);
372}
examples/3d/edit_material_on_gltf.rs (line 78)
59fn change_material(
60    trigger: Trigger<SceneInstanceReady>,
61    mut commands: Commands,
62    children: Query<&Children>,
63    color_override: Query<&ColorOverride>,
64    mesh_materials: Query<&MeshMaterial3d<StandardMaterial>>,
65    mut asset_materials: ResMut<Assets<StandardMaterial>>,
66) {
67    // Get the `ColorOverride` of the entity, if it does not have a color override, skip
68    let Ok(color_override) = color_override.get(trigger.target()) else {
69        return;
70    };
71
72    // Iterate over all children recursively
73    for descendants in children.iter_descendants(trigger.target()) {
74        // Get the material of the descendant
75        if let Some(material) = mesh_materials
76            .get(descendants)
77            .ok()
78            .and_then(|id| asset_materials.get_mut(id.id()))
79        {
80            // Create a copy of the material and override base color
81            // If you intend on creating multiple models with the same tint, it
82            // is best to cache the handle somewhere, as having multiple materials
83            // that are identical is expensive
84            let mut new_material = material.clone();
85            new_material.base_color = color_override.0;
86
87            // Override `MeshMaterial3d` with new material
88            commands
89                .entity(descendants)
90                .insert(MeshMaterial3d(asset_materials.add(new_material)));
91        }
92    }
93}
examples/app/headless_renderer.rs (line 493)
472fn update(
473    images_to_save: Query<&ImageToSave>,
474    receiver: Res<MainWorldReceiver>,
475    mut images: ResMut<Assets<Image>>,
476    mut scene_controller: ResMut<SceneController>,
477    mut app_exit_writer: EventWriter<AppExit>,
478    mut file_number: Local<u32>,
479) {
480    if let SceneState::Render(n) = scene_controller.state {
481        if n < 1 {
482            // We don't want to block the main world on this,
483            // so we use try_recv which attempts to receive without blocking
484            let mut image_data = Vec::new();
485            while let Ok(data) = receiver.try_recv() {
486                // image generation could be faster than saving to fs,
487                // that's why use only last of them
488                image_data = data;
489            }
490            if !image_data.is_empty() {
491                for image in images_to_save.iter() {
492                    // Fill correct data from channel to image
493                    let img_bytes = images.get_mut(image.id()).unwrap();
494
495                    // We need to ensure that this works regardless of the image dimensions
496                    // If the image became wider when copying from the texture to the buffer,
497                    // then the data is reduced to its original size when copying from the buffer to the image.
498                    let row_bytes = img_bytes.width() as usize
499                        * img_bytes.texture_descriptor.format.pixel_size();
500                    let aligned_row_bytes = RenderDevice::align_copy_bytes_per_row(row_bytes);
501                    if row_bytes == aligned_row_bytes {
502                        img_bytes.data.as_mut().unwrap().clone_from(&image_data);
503                    } else {
504                        // shrink data to original image size
505                        img_bytes.data = Some(
506                            image_data
507                                .chunks(aligned_row_bytes)
508                                .take(img_bytes.height() as usize)
509                                .flat_map(|row| &row[..row_bytes.min(row.len())])
510                                .cloned()
511                                .collect(),
512                        );
513                    }
514
515                    // Create RGBA Image Buffer
516                    let img = match img_bytes.clone().try_into_dynamic() {
517                        Ok(img) => img.to_rgba8(),
518                        Err(e) => panic!("Failed to create image buffer {e:?}"),
519                    };
520
521                    // Prepare directory for images, test_images in bevy folder is used here for example
522                    // You should choose the path depending on your needs
523                    let images_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("test_images");
524                    info!("Saving image to: {images_dir:?}");
525                    std::fs::create_dir_all(&images_dir).unwrap();
526
527                    // Choose filename starting from 000.png
528                    let image_path = images_dir.join(format!("{:03}.png", file_number.deref()));
529                    *file_number.deref_mut() += 1;
530
531                    // Finally saving image to file, this heavy blocking operation is kept here
532                    // for example simplicity, but in real app you should move it to a separate task
533                    if let Err(e) = img.save(image_path) {
534                        panic!("Failed to save image: {e}");
535                    };
536                }
537                if scene_controller.single_image {
538                    app_exit_writer.write(AppExit::Success);
539                }
540            }
541        } else {
542            // clears channel for skipped frames
543            while receiver.try_recv().is_ok() {}
544            scene_controller.state = SceneState::Render(n - 1);
545        }
546    }
547}
Source

pub fn path(&self) -> Option<&AssetPath<'static>>

Returns the path if this is (1) a strong handle and (2) the asset has a path

Source

pub fn is_weak(&self) -> bool

Returns true if this is a weak handle.

Source

pub fn is_strong(&self) -> bool

Returns true if this is a strong handle.

Source

pub fn clone_weak(&self) -> Handle<A>

Creates a Handle::Weak clone of this Handle, which will not keep the referenced Asset alive.

Examples found in repository?
examples/shader/compute_shader_game_of_life.rs (line 89)
87fn switch_textures(images: Res<GameOfLifeImages>, mut sprite: Single<&mut Sprite>) {
88    if sprite.image == images.texture_a {
89        sprite.image = images.texture_b.clone_weak();
90    } else {
91        sprite.image = images.texture_a.clone_weak();
92    }
93}

Trait Implementations§

Source§

impl Clone for DynamicSceneRoot

Source§

fn clone(&self) -> DynamicSceneRoot

Returns a copy of the value. Read more
1.0.0 · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

impl Component for DynamicSceneRoot
where DynamicSceneRoot: Send + Sync + 'static,

Required Components: Transform, Visibility.

A component’s Required Components are inserted whenever it is inserted. Note that this will also insert the required components of the required components, recursively, in depth-first order.

Source§

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::Table

A constant indicating the storage type used for this component.
Source§

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have [Component<Mutability = Mutable>], while immutable components will instead have [Component<Mutability = Immutable>]. Read more
Source§

fn register_required_components( requiree: ComponentId, components: &mut ComponentsRegistrator<'_>, required_components: &mut RequiredComponents, inheritance_depth: u16, recursion_check_stack: &mut Vec<ComponentId>, )

Registers required components.
Source§

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component. Read more
Source§

fn register_component_hooks(hooks: &mut ComponentHooks)

👎Deprecated since 0.16.0: Use the individual hook methods instead (e.g., Component::on_add, etc.)
Called when registering this component, allowing mutable access to its ComponentHooks.
Source§

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add ComponentHook for this Component if one is defined.
Source§

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert ComponentHook for this Component if one is defined.
Source§

fn on_replace() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_replace ComponentHook for this Component if one is defined.
Source§

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove ComponentHook for this Component if one is defined.
Source§

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn ComponentHook for this Component if one is defined.
Source§

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)
where E: EntityMapper,

Maps the entities on this component using the given EntityMapper. This is used to remap entities in contexts like scenes and entity cloning. When deriving Component, this is populated by annotating fields containing entities with #[entities] Read more
Source§

impl Debug for DynamicSceneRoot

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Default for DynamicSceneRoot

Source§

fn default() -> DynamicSceneRoot

Returns the “default value” for a type. Read more
Source§

impl Deref for DynamicSceneRoot

Source§

type Target = Handle<DynamicScene>

The resulting type after dereferencing.
Source§

fn deref(&self) -> &<DynamicSceneRoot as Deref>::Target

Dereferences the value.
Source§

impl DerefMut for DynamicSceneRoot

Source§

fn deref_mut(&mut self) -> &mut <DynamicSceneRoot as Deref>::Target

Mutably dereferences the value.
Source§

impl From<Handle<DynamicScene>> for DynamicSceneRoot

Source§

fn from(value: Handle<DynamicScene>) -> DynamicSceneRoot

Converts to this type from the input type.
Source§

impl FromArg for &'static DynamicSceneRoot
where DynamicSceneRoot: Any + Send + Sync, Handle<DynamicScene>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

type This<'from_arg> = &'from_arg DynamicSceneRoot

The type to convert into. Read more
Source§

fn from_arg( arg: Arg<'_>, ) -> Result<<&'static DynamicSceneRoot as FromArg>::This<'_>, ArgError>

Creates an item from an argument. Read more
Source§

impl FromArg for &'static mut DynamicSceneRoot
where DynamicSceneRoot: Any + Send + Sync, Handle<DynamicScene>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

type This<'from_arg> = &'from_arg mut DynamicSceneRoot

The type to convert into. Read more
Source§

fn from_arg( arg: Arg<'_>, ) -> Result<<&'static mut DynamicSceneRoot as FromArg>::This<'_>, ArgError>

Creates an item from an argument. Read more
Source§

impl FromArg for DynamicSceneRoot
where DynamicSceneRoot: Any + Send + Sync, Handle<DynamicScene>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

type This<'from_arg> = DynamicSceneRoot

The type to convert into. Read more
Source§

fn from_arg( arg: Arg<'_>, ) -> Result<<DynamicSceneRoot as FromArg>::This<'_>, ArgError>

Creates an item from an argument. Read more
Source§

impl FromReflect for DynamicSceneRoot
where DynamicSceneRoot: Any + Send + Sync, Handle<DynamicScene>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn from_reflect( reflect: &(dyn PartialReflect + 'static), ) -> Option<DynamicSceneRoot>

Constructs a concrete instance of Self from a reflected value.
Source§

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails. Read more
Source§

impl GetOwnership for &DynamicSceneRoot
where DynamicSceneRoot: Any + Send + Sync, Handle<DynamicScene>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn ownership() -> Ownership

Returns the ownership of Self.
Source§

impl GetOwnership for &mut DynamicSceneRoot
where DynamicSceneRoot: Any + Send + Sync, Handle<DynamicScene>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn ownership() -> Ownership

Returns the ownership of Self.
Source§

impl GetOwnership for DynamicSceneRoot
where DynamicSceneRoot: Any + Send + Sync, Handle<DynamicScene>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn ownership() -> Ownership

Returns the ownership of Self.
Source§

impl GetTypeRegistration for DynamicSceneRoot
where DynamicSceneRoot: Any + Send + Sync, Handle<DynamicScene>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.
Source§

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type. Read more
Source§

impl IntoReturn for &DynamicSceneRoot
where DynamicSceneRoot: Any + Send + Sync, Handle<DynamicScene>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn into_return<'into_return>(self) -> Return<'into_return>
where &DynamicSceneRoot: 'into_return,

Converts Self into a Return value.
Source§

impl IntoReturn for &mut DynamicSceneRoot
where DynamicSceneRoot: Any + Send + Sync, Handle<DynamicScene>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn into_return<'into_return>(self) -> Return<'into_return>
where &mut DynamicSceneRoot: 'into_return,

Converts Self into a Return value.
Source§

impl IntoReturn for DynamicSceneRoot
where DynamicSceneRoot: Any + Send + Sync, Handle<DynamicScene>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn into_return<'into_return>(self) -> Return<'into_return>
where DynamicSceneRoot: 'into_return,

Converts Self into a Return value.
Source§

impl PartialEq for DynamicSceneRoot

Source§

fn eq(&self, other: &DynamicSceneRoot) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

impl PartialReflect for DynamicSceneRoot
where DynamicSceneRoot: Any + Send + Sync, Handle<DynamicScene>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value. Read more
Source§

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value. Read more
Source§

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type. Read more
Source§

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type. Read more
Source§

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type. Read more
Source§

fn reflect_owned(self: Box<DynamicSceneRoot>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type. Read more
Source§

fn try_into_reflect( self: Box<DynamicSceneRoot>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.
Source§

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

Attempts to cast this type to a fully-reflected value.
Source§

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

Attempts to cast this type to a mutable, fully-reflected value.
Source§

fn into_partial_reflect(self: Box<DynamicSceneRoot>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value. Read more
Source§

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value. Read more
Source§

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value. Read more
Source§

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

Returns a “partial equality” comparison result. Read more
Source§

fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Debug formatter for the value. Read more
Source§

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection. Read more
Source§

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value. Read more
Source§

fn clone_value(&self) -> Box<dyn PartialReflect>

👎Deprecated since 0.16.0: to clone reflected values, prefer using reflect_clone. To convert reflected values to dynamic ones, use to_dynamic.
Clones Self into its dynamic representation. Read more
Source§

fn to_dynamic(&self) -> Box<dyn PartialReflect>

Converts this reflected value into its dynamic representation based on its kind. Read more
Source§

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type). Read more
Source§

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type. Read more
Source§

impl Reflect for DynamicSceneRoot
where DynamicSceneRoot: Any + Send + Sync, Handle<DynamicScene>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn into_any(self: Box<DynamicSceneRoot>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>. Read more
Source§

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

Returns the value as a &dyn Any. Read more
Source§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any. Read more
Source§

fn into_reflect(self: Box<DynamicSceneRoot>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.
Source§

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a fully-reflected value.
Source§

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable, fully-reflected value.
Source§

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value. Read more
Source§

impl TupleStruct for DynamicSceneRoot
where DynamicSceneRoot: Any + Send + Sync, Handle<DynamicScene>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn field(&self, index: usize) -> Option<&(dyn PartialReflect + 'static)>

Returns a reference to the value of the field with index index as a &dyn Reflect.
Source§

fn field_mut( &mut self, index: usize, ) -> Option<&mut (dyn PartialReflect + 'static)>

Returns a mutable reference to the value of the field with index index as a &mut dyn Reflect.
Source§

fn field_len(&self) -> usize

Returns the number of fields in the tuple struct.
Source§

fn iter_fields(&self) -> TupleStructFieldIter<'_>

Returns an iterator over the values of the tuple struct’s fields.
Source§

fn to_dynamic_tuple_struct(&self) -> DynamicTupleStruct

Creates a new DynamicTupleStruct from this tuple struct.
Source§

fn clone_dynamic(&self) -> DynamicTupleStruct

👎Deprecated since 0.16.0: use to_dynamic_tuple_struct instead
Clones the struct into a DynamicTupleStruct.
Source§

fn get_represented_tuple_struct_info(&self) -> Option<&'static TupleStructInfo>

Will return None if TypeInfo is not available.
Source§

impl TypePath for DynamicSceneRoot

Source§

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type. Read more
Source§

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type. Read more
Source§

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous. Read more
Source§

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous. Read more
Source§

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous. Read more
Source§

impl Typed for DynamicSceneRoot
where DynamicSceneRoot: Any + Send + Sync, Handle<DynamicScene>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.
Source§

impl Eq for DynamicSceneRoot

Source§

impl StructuralPartialEq for DynamicSceneRoot

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T, U> AsBindGroupShaderType<U> for T
where U: ShaderType, &'a T: for<'a> Into<U>,

Source§

fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U

Return the T ShaderType for self. When used in AsBindGroup derives, it is safe to assume that all images in self exist.
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<C> Bundle for C
where C: Component,

Source§

fn component_ids( components: &mut ComponentsRegistrator<'_>, ids: &mut impl FnMut(ComponentId), )

Source§

fn register_required_components( components: &mut ComponentsRegistrator<'_>, required_components: &mut RequiredComponents, )

Registers components that are required by the components in this Bundle.
Source§

fn get_component_ids( components: &Components, ids: &mut impl FnMut(Option<ComponentId>), )

Gets this Bundle’s component ids. This will be None if the component has not been registered.
Source§

impl<C> BundleFromComponents for C
where C: Component,

Source§

unsafe fn from_components<T, F>(ctx: &mut T, func: &mut F) -> C
where F: for<'a> FnMut(&'a mut T) -> OwningPtr<'a>,

Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

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

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> Conv for T

Source§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
Source§

impl<T> Downcast<T> for T

Source§

fn downcast(&self) -> &T

Source§

impl<T> Downcast for T
where T: Any,

Source§

fn into_any(self: Box<T>) -> Box<dyn Any>

Converts Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>, which can then be downcast into Box<dyn ConcreteType> where ConcreteType implements Trait.
Source§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Converts Rc<Trait> (where Trait: Downcast) to Rc<Any>, which can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
Source§

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

Converts &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
Source§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Converts &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
Source§

impl<T> Downcast for T
where T: Any,

Source§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
Source§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
Source§

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

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
Source§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
Source§

impl<T> DowncastSend for T
where T: Any + Send,

Source§

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

Converts Box<Trait> (where Trait: DowncastSend) to Box<dyn Any + Send>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.
Source§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

Source§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
Source§

impl<T> DynEq for T
where T: Any + Eq,

Source§

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

Casts the type to dyn Any.
Source§

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

This method tests for self and other values to be equal. Read more
Source§

impl<C> DynamicBundle for C
where C: Component,

Source§

type Effect = ()

An operation on the entity that happens after inserting this bundle.
Source§

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

Source§

impl<T> DynamicTypePath for T
where T: TypePath,

Source§

impl<T> DynamicTyped for T
where T: Typed,

Source§

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

Source§

fn equivalent(&self, key: &K) -> bool

Compare self to key and return true if they are equal.
Source§

impl<T> FmtForward for T

Source§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
Source§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
Source§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
Source§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
Source§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
Source§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
Source§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
Source§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
Source§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<S> FromSample<S> for S

Source§

fn from_sample_(s: S) -> S

Source§

impl<T> FromWorld for T
where T: Default,

Source§

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

Creates Self using default().

Source§

impl<T> GetPath for T
where T: Reflect + ?Sized,

Source§

fn reflect_path<'p>( &self, path: impl ReflectPath<'p>, ) -> Result<&(dyn PartialReflect + 'static), ReflectPathError<'p>>

Returns a reference to the value specified by path. Read more
Source§

fn reflect_path_mut<'p>( &mut self, path: impl ReflectPath<'p>, ) -> Result<&mut (dyn PartialReflect + 'static), ReflectPathError<'p>>

Returns a mutable reference to the value specified by path. Read more
Source§

fn path<'p, T>( &self, path: impl ReflectPath<'p>, ) -> Result<&T, ReflectPathError<'p>>
where T: Reflect,

Returns a statically typed reference to the value specified by path. Read more
Source§

fn path_mut<'p, T>( &mut self, path: impl ReflectPath<'p>, ) -> Result<&mut T, ReflectPathError<'p>>
where T: Reflect,

Returns a statically typed mutable reference to the value specified by path. Read more
Source§

impl<S> GetTupleStructField for S
where S: TupleStruct,

Source§

fn get_field<T>(&self, index: usize) -> Option<&T>
where T: Reflect,

Returns a reference to the value of the field with index index, downcast to T.
Source§

fn get_field_mut<T>(&mut self, index: usize) -> Option<&mut T>
where T: Reflect,

Returns a mutable reference to the value of the field with index index, downcast to T.
Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<F, T> IntoSample<T> for F
where T: FromSample<F>,

Source§

fn into_sample(self) -> T

Source§

impl<T> NoneValue for T
where T: Default,

Source§

type NoneType = T

Source§

fn null_value() -> T

The none-equivalent value.
Source§

impl<T> Pipe for T
where T: ?Sized,

Source§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
Source§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
Source§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
Source§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
Source§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
Source§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
Source§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
Source§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
Source§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

type Init = T

The type for initializers.
Source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<R, P> ReadPrimitive<R> for P
where R: Read + ReadEndian<P>, P: Default,

Source§

fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_little_endian().
Source§

fn read_from_big_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_big_endian().
Source§

fn read_from_native_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_native_endian().
Source§

impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

Source§

type Target = T

🔬This is a nightly-only experimental API. (arbitrary_self_types)
The target type on which the method may be called.
Source§

impl<T> Tap for T

Source§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
Source§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
Source§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
Source§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
Source§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
Source§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
Source§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
Source§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
Source§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
Source§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
Source§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
Source§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
Source§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> ToSample<U> for T
where U: FromSample<T>,

Source§

fn to_sample_(self) -> U

Source§

impl<T> TryConv for T

Source§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> TypeData for T
where T: 'static + Send + Sync + Clone,

Source§

impl<T> Upcast<T> for T

Source§

fn upcast(&self) -> Option<&T>

Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

impl<T> ConditionalSend for T
where T: Send,

Source§

impl<S, T> Duplex<S> for T
where T: FromSample<S> + ToSample<S>,

Source§

impl<T> Reflectable for T

Source§

impl<T> Settings for T
where T: 'static + Send + Sync,

Source§

impl<T> WasmNotSend for T
where T: Send,

Source§

impl<T> WasmNotSendSync for T

Source§

impl<T> WasmNotSync for T
where T: Sync,