Struct AssetServer

Source

pub struct AssetServer { /* private fields */ }

Available on crate feature bevy_asset only.

Expand description

Loads and tracks the state of Asset values from a configured AssetReader. This can be used to kick off new asset loads and retrieve their current load states.

The general process to load an asset is:

Initialize a new Asset type with the AssetServer via AssetApp::init_asset, which will internally call AssetServer::register_asset and set up related ECS Assets storage and systems.
Register one or more AssetLoaders for that asset with AssetApp::init_asset_loader
Add the asset to your asset folder (defaults to assets).
Call AssetServer::load with a path to your asset.

AssetServer can be cloned. It is backed by an Arc so clones will share state. Clones can be freely used in parallel.

Implementations§

Source §

impl AssetServer

Source

pub const STARTED_LOAD_COUNT: DiagnosticPath

The number of loads that have been started by the server.

Source

pub fn new( sources: Arc<AssetSources>, mode: AssetServerMode, watching_for_changes: bool, unapproved_path_mode: UnapprovedPathMode, ) -> AssetServer

Create a new instance of AssetServer. If watch_for_changes is true, the AssetReader storage will watch for changes to asset sources and hot-reload them.

Source

pub fn new_with_meta_check( sources: Arc<AssetSources>, mode: AssetServerMode, meta_check: AssetMetaCheck, watching_for_changes: bool, unapproved_path_mode: UnapprovedPathMode, ) -> AssetServer

Create a new instance of AssetServer. If watch_for_changes is true, the AssetReader storage will watch for changes to asset sources and hot-reload them.

Source

pub fn get_source<'a>( &self, source: impl Into<AssetSourceId<'a>>, ) -> Result<&AssetSource, MissingAssetSourceError>

Retrieves the AssetSource for the given source.

Source

pub fn watching_for_changes(&self) -> bool

Returns true if the AssetServer watches for changes.

Source

pub fn register_loader<L>(&self, loader: L)
where L: AssetLoader,

Registers a new AssetLoader. AssetLoaders must be registered before they can be used.

Source

pub fn register_asset<A>(&self, assets: &Assets<A>)
where A: Asset,

Registers a new Asset type. Asset types must be registered before assets of that type can be loaded.

Source

pub async fn get_asset_loader_with_extension( &self, extension: &str, ) -> Result<Arc<dyn ErasedAssetLoader>, MissingAssetLoaderForExtensionError>

Returns the registered AssetLoader associated with the given extension, if it exists.

Source

pub async fn get_asset_loader_with_type_name( &self, type_name: &str, ) -> Result<Arc<dyn ErasedAssetLoader>, MissingAssetLoaderForTypeNameError>

Returns the registered AssetLoader associated with the given type name, if it exists.

Source

pub async fn get_path_asset_loader<'a>( &self, path: impl Into<AssetPath<'a>>, ) -> Result<Arc<dyn ErasedAssetLoader>, MissingAssetLoaderForExtensionError>

Retrieves the default AssetLoader for the given path, if one can be found.

Source

pub async fn get_asset_loader_with_asset_type_id( &self, type_id: TypeId, ) -> Result<Arc<dyn ErasedAssetLoader>, MissingAssetLoaderForTypeIdError>

Retrieves the default AssetLoader for the given Asset TypeId, if one can be found.

Source

pub async fn get_asset_loader_with_asset_type<A>( &self, ) -> Result<Arc<dyn ErasedAssetLoader>, MissingAssetLoaderForTypeIdError>
where A: Asset,

Retrieves the default AssetLoader for the given Asset type, if one can be found.

Source

pub fn load<'a, A>(&self, path: impl Into<AssetPath<'a>>) -> Handle<A>
where A: Asset,

Begins loading an Asset of type A stored at path. This will not block on the asset load. Instead, it returns a “strong” Handle. When the Asset is loaded (and enters LoadState::Loaded), it will be added to the associated Assets resource.

Note that if the asset at this path is already loaded, this function will return the existing handle, and will not waste work spawning a new load task.

In case the file path contains a hashtag (#), the path must be specified using Path or AssetPath because otherwise the hashtag would be interpreted as separator between the file path and the label. For example:

// `#path` is a label.
asset_server.load("some/file#path");

// `#path` is part of the file name.
asset_server.load(Path::new("some/file#path"));

Furthermore, if you need to load a file with a hashtag in its name and a label, you can manually construct an AssetPath.

asset_server.load(AssetPath::from_path(Path::new("some/file#path")).with_label("subasset"));

You can check the asset’s load state by reading AssetEvent events, calling AssetServer::load_state, or checking the Assets storage to see if the Asset exists yet.

The asset load will fail and an error will be printed to the logs if the asset stored at path is not of type A.

Examples found in repository ?

examples/asset/asset_saving_with_subassets.rs (line 91)

90fn start_load(mut commands: Commands, asset_server: Res<AssetServer>) {
91    commands.spawn(PendingLoad(asset_server.load(ASSET_PATH)));
92}

More examples

Hide additional examples

examples/state/states.rs (line 121)

120fn setup_game(mut commands: Commands, asset_server: Res<AssetServer>) {
121    commands.spawn(Sprite::from_image(asset_server.load("branding/icon.png")));
122}

examples/audio/audio.rs (line 15)

13fn setup(asset_server: Res<AssetServer>, mut commands: Commands) {
14    commands.spawn(AudioPlayer::new(
15        asset_server.load("sounds/Windless Slopes.ogg"),
16    ));
17}

examples/asset/custom_asset_reader.rs (line 64)

62fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
63    commands.spawn(Camera2d);
64    commands.spawn(Sprite::from_image(asset_server.load("branding/icon.png")));
65}

examples/window/transparent_window.rs (line 35)

33fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
34    commands.spawn(Camera2d);
35    commands.spawn(Sprite::from_image(asset_server.load("branding/icon.png")));
36}

examples/2d/sprite.rs (line 16)

12fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
13    commands.spawn(Camera2d);
14
15    commands.spawn(Sprite::from_image(
16        asset_server.load("branding/bevy_bird_dark.png"),
17    ));
18}

Additional examples can be found in:

Source

pub fn load_builder(&self) -> LoadBuilder<'_>

Returns a LoadBuilder that can be used to start more complex loads. See LoadBuilder for details.

Examples found in repository ?

examples/3d/clustered_decal_maps.rs (line 56)

50    fn from_world(world: &mut World) -> Self {
51        // Load all the decal textures.
52        let asset_server = world.resource::<AssetServer>();
53        AppTextures {
54            decal_base_color_texture: asset_server.load("branding/bevy_bird_dark.png"),
55            decal_normal_map_texture: asset_server
56                .load_builder()
57                .with_settings(|settings: &mut ImageLoaderSettings| settings.is_srgb = false)
58                .load(get_web_asset_url("BevyLogo-Normal.png")),
59            decal_metallic_roughness_map_texture: asset_server
60                .load_builder()
61                .with_settings(|settings: &mut ImageLoaderSettings| settings.is_srgb = false)
62                .load(get_web_asset_url("BevyLogo-MetallicRoughness.png")),
63            decal_emissive_texture: asset_server.load(get_web_asset_url("BevyLogo-Emissive.png")),
64        }
65    }
66}
67
68/// A component that we place on our decals to track them for animation
69/// purposes.
70#[derive(Component)]
71struct ExampleDecal {
72    /// The width and height of the square decal in meters.
73    size: f32,
74    /// What state the decal is in (animating in, idling, or animating out).
75    state: ExampleDecalState,
76}
77
78/// The animation state of a decal.
79///
80/// When each [`Timer`] goes off, the decal advances to the next state.
81enum ExampleDecalState {
82    /// The decal has just been spawned and is animating in.
83    AnimatingIn(Timer),
84    /// The decal has animated in and is waiting to animate out.
85    Idling(Timer),
86    /// The decal is animating out.
87    ///
88    /// When this timer expires, the decal is despawned.
89    AnimatingOut(Timer),
90}
91
92/// All settings that the user can change.
93///
94/// This app only has one: whether newly-spawned decals are emissive.
95#[derive(Clone, Copy, Component, PartialEq)]
96enum AppSetting {
97    /// True if newly-spawned decals have an emissive channel (i.e. they glow),
98    /// or false otherwise.
99    EmissiveDecals(bool),
100}
101
102impl Default for AppSetting {
103    fn default() -> Self {
104        Self::EmissiveDecals(false)
105    }
106}
107
108/// The current values of the settings that the user can change.
109///
110/// This app only has one: whether newly-spawned decals are emissive.
111#[derive(Default, Resource)]
112struct AppStatus {
113    /// True if newly-spawned decals have an emissive channel (i.e. they glow),
114    /// or false otherwise.
115    emissive_decals: bool,
116}
117
118/// Half of the width and height of the plane onto which the decals are
119/// projected.
120const PLANE_HALF_SIZE: f32 = 2.0;
121/// The minimum width and height that a decal may have.
122///
123/// The actual size is determined randomly, using this value as a lower bound.
124const DECAL_MIN_SIZE: f32 = 0.5;
125/// The maximum width and height that a decal may have.
126///
127/// The actual size is determined randomly, using this value as an upper bound.
128const DECAL_MAX_SIZE: f32 = 1.5;
129
130/// How long it takes the decal to grow to its full size when animating in.
131const DECAL_ANIMATE_IN_DURATION: Duration = Duration::from_millis(300);
132/// How long a decal stays in the idle state before starting to animate out.
133const DECAL_IDLE_DURATION: Duration = Duration::from_secs(10);
134/// How long it takes the decal to shrink down to nothing when animating out.
135const DECAL_ANIMATE_OUT_DURATION: Duration = Duration::from_millis(300);
136
137/// The demo entry point.
138fn main() {
139    App::new()
140        .add_plugins((
141            DefaultPlugins
142                .set(WebAssetPlugin {
143                    silence_startup_warning: true,
144                })
145                .set(WindowPlugin {
146                    primary_window: Some(Window {
147                        title: "Bevy Clustered Decal Maps Example".into(),
148                        ..default()
149                    }),
150                    ..default()
151                }),
152            FeathersPlugins,
153        ))
154        .init_resource::<AppStatus>()
155        .init_resource::<AppTextures>()
156        .insert_resource(UiTheme(create_dark_theme()))
157        .add_systems(Startup, setup)
158        .add_systems(Update, draw_gizmos)
159        .add_systems(Update, spawn_decal)
160        .add_systems(Update, animate_decals)
161        .add_observer(handle_emission_type_change)
162        .add_observer(radio_self_update)
163        .insert_resource(SeededRng(ChaCha8Rng::seed_from_u64(19878367467712)))
164        .run();
165}
166
167#[derive(Resource)]
168struct SeededRng(ChaCha8Rng);
169
170/// Spawns all the objects in the scene.
171fn setup(
172    mut commands: Commands,
173    asset_server: Res<AssetServer>,
174    mut meshes: ResMut<Assets<Mesh>>,
175    mut materials: ResMut<Assets<StandardMaterial>>,
176) {
177    spawn_plane_mesh(&mut commands, &asset_server, &mut meshes, &mut materials);
178    spawn_light(&mut commands);
179    spawn_camera(&mut commands);
180    spawn_buttons(&mut commands);
181}
182
183/// Spawns the plane onto which the decals are projected.
184fn spawn_plane_mesh(
185    commands: &mut Commands,
186    asset_server: &AssetServer,
187    meshes: &mut Assets<Mesh>,
188    materials: &mut Assets<StandardMaterial>,
189) {
190    // Create a plane onto which we project decals.
191    //
192    // As the plane has a normal map, we must generate tangents for the
193    // vertices.
194    let plane_mesh = meshes.add(
195        Plane3d {
196            normal: Dir3::NEG_Z,
197            half_size: Vec2::splat(PLANE_HALF_SIZE),
198        }
199        .mesh()
200        .build()
201        .with_duplicated_vertices()
202        .with_computed_flat_normals()
203        .with_generated_tangents()
204        .unwrap(),
205    );
206
207    // Give the plane some texture.
208    //
209    // Note that, as this is a normal map, we must disable sRGB when loading.
210    let normal_map_texture = asset_server
211        .load_builder()
212        .with_settings(|settings: &mut ImageLoaderSettings| settings.is_srgb = false)
213        .load("textures/ScratchedGold-Normal.png");
214
215    // Actually spawn the plane.
216    commands.spawn((
217        Mesh3d(plane_mesh),
218        MeshMaterial3d(materials.add(StandardMaterial {
219            base_color: Color::from(CRIMSON),
220            normal_map_texture: Some(normal_map_texture),
221            ..StandardMaterial::default()
222        })),
223        Transform::IDENTITY,
224    ));
225}

More examples

Hide additional examples

examples/3d/rotate_environment_map.rs (line 76)

62fn spawn_sphere(
63    commands: &mut Commands,
64    materials: &mut Assets<StandardMaterial>,
65    asset_server: &AssetServer,
66    sphere_mesh: &Handle<Mesh>,
67) {
68    commands.spawn((
69        Mesh3d(sphere_mesh.clone()),
70        MeshMaterial3d(
71            materials.add(StandardMaterial {
72                clearcoat: 1.0,
73                clearcoat_perceptual_roughness: 0.3,
74                clearcoat_normal_texture: Some(
75                    asset_server
76                        .load_builder()
77                        .with_settings(|settings: &mut ImageLoaderSettings| {
78                            settings.is_srgb = false;
79                        })
80                        .load("textures/ScratchedGold-Normal.png"),
81                ),
82                metallic: 0.9,
83                perceptual_roughness: 0.1,
84                base_color: GOLD.into(),
85                ..default()
86            }),
87        ),
88        Transform::from_xyz(0.0, 0.0, 0.0).with_scale(Vec3::splat(1.25)),
89    ));
90}

examples/3d/clearcoat.rs (line 122)

107fn spawn_car_paint_sphere(
108    commands: &mut Commands,
109    materials: &mut Assets<StandardMaterial>,
110    asset_server: &AssetServer,
111    sphere: &Handle<Mesh>,
112) {
113    commands
114        .spawn((
115            Mesh3d(sphere.clone()),
116            MeshMaterial3d(
117                materials.add(StandardMaterial {
118                    clearcoat: 1.0,
119                    clearcoat_perceptual_roughness: 0.1,
120                    normal_map_texture: Some(
121                        asset_server
122                            .load_builder()
123                            .with_settings(|settings: &mut ImageLoaderSettings| {
124                                settings.is_srgb = false;
125                            })
126                            .load("textures/BlueNoise-Normal.png"),
127                    ),
128                    metallic: 0.9,
129                    perceptual_roughness: 0.5,
130                    base_color: BLUE.into(),
131                    ..default()
132                }),
133            ),
134            Transform::from_xyz(-1.0, 1.0, 0.0).with_scale(Vec3::splat(SPHERE_SCALE)),
135        ))
136        .insert(ExampleSphere);
137}
138
139/// Spawn a semitransparent object with a clearcoat layer.
140fn spawn_coated_glass_bubble_sphere(
141    commands: &mut Commands,
142    materials: &mut Assets<StandardMaterial>,
143    sphere: &Handle<Mesh>,
144) {
145    commands
146        .spawn((
147            Mesh3d(sphere.clone()),
148            MeshMaterial3d(materials.add(StandardMaterial {
149                clearcoat: 1.0,
150                clearcoat_perceptual_roughness: 0.1,
151                metallic: 0.5,
152                perceptual_roughness: 0.1,
153                base_color: Color::srgba(0.9, 0.9, 0.9, 0.3),
154                alpha_mode: AlphaMode::Blend,
155                ..default()
156            })),
157            Transform::from_xyz(-1.0, -1.0, 0.0).with_scale(Vec3::splat(SPHERE_SCALE)),
158        ))
159        .insert(ExampleSphere);
160}
161
162/// Spawns an object with both a clearcoat normal map (a scratched varnish) and
163/// a main layer normal map (the golf ball pattern).
164///
165/// This object is in glTF format, using the `KHR_materials_clearcoat`
166/// extension.
167fn spawn_golf_ball(commands: &mut Commands, asset_server: &AssetServer) {
168    commands.spawn((
169        WorldAssetRoot(
170            asset_server.load(GltfAssetLabel::Scene(0).from_asset("models/GolfBall/GolfBall.glb")),
171        ),
172        Transform::from_xyz(1.0, 1.0, 0.0).with_scale(Vec3::splat(SPHERE_SCALE)),
173        ExampleSphere,
174    ));
175}
176
177/// Spawns an object with only a clearcoat normal map (a scratch pattern) and no
178/// main layer normal map.
179fn spawn_scratched_gold_ball(
180    commands: &mut Commands,
181    materials: &mut Assets<StandardMaterial>,
182    asset_server: &AssetServer,
183    sphere: &Handle<Mesh>,
184) {
185    commands
186        .spawn((
187            Mesh3d(sphere.clone()),
188            MeshMaterial3d(
189                materials.add(StandardMaterial {
190                    clearcoat: 1.0,
191                    clearcoat_perceptual_roughness: 0.3,
192                    clearcoat_normal_texture: Some(
193                        asset_server
194                            .load_builder()
195                            .with_settings(|settings: &mut ImageLoaderSettings| {
196                                settings.is_srgb = false;
197                            })
198                            .load("textures/ScratchedGold-Normal.png"),
199                    ),
200                    metallic: 0.9,
201                    perceptual_roughness: 0.1,
202                    base_color: GOLD.into(),
203                    ..default()
204                }),
205            ),
206            Transform::from_xyz(1.0, -1.0, 0.0).with_scale(Vec3::splat(SPHERE_SCALE)),
207        ))
208        .insert(ExampleSphere);
209}

examples/asset/multi_asset_sync.rs (line 147)

144fn setup_assets(mut commands: Commands, asset_server: Res<AssetServer>) {
145    let (barrier, guard) = AssetBarrier::new();
146    commands.insert_resource(OneHundredThings(std::array::from_fn(|i| {
147        let builder = asset_server.load_builder().with_guard(guard.clone());
148        match i % 5 {
149            0 => builder.load("models/GolfBall/GolfBall.glb"),
150            1 => builder.load("models/AlienCake/alien.glb"),
151            2 => builder.load("models/AlienCake/cakeBirthday.glb"),
152            3 => builder.load("models/FlightHelmet/FlightHelmet.gltf"),
153            4 => builder.load("models/torus/torus.gltf"),
154            _ => unreachable!(),
155        }
156    })));
157    let future = barrier.wait_async();
158    commands.insert_resource(barrier);
159
160    let loading_state = Arc::new(AtomicBool::new(false));
161    commands.insert_resource(AsyncLoadingState(loading_state.clone()));
162
163    // await the `AssetBarrierFuture`.
164    AsyncComputeTaskPool::get()
165        .spawn(async move {
166            future.await;
167            // Notify via `AsyncLoadingState`
168            loading_state.store(true, Ordering::Release);
169        })
170        .detach();
171}

examples/shader/array_texture.rs (line 40)

32fn setup(
33    mut commands: Commands,
34    mut meshes: ResMut<Assets<Mesh>>,
35    mut materials: ResMut<Assets<ArrayTextureMaterial>>,
36    asset_server: Res<AssetServer>,
37) {
38    // Load the texture.
39    let array_texture = asset_server
40        .load_builder()
41        .with_settings(|settings: &mut ImageLoaderSettings| {
42            settings.array_layout = Some(ImageArrayLayout::RowCount {
43                rows: TEXTURE_COUNT,
44            });
45        })
46        .load("textures/array_texture.png");
47
48    // light
49    commands.spawn((
50        DirectionalLight::default(),
51        Transform::from_xyz(3.0, 2.0, 1.0).looking_at(Vec3::ZERO, Vec3::Y),
52    ));
53
54    // camera
55    commands.spawn((
56        Camera3d::default(),
57        Transform::from_xyz(5.0, 5.0, 5.0).looking_at(Vec3::new(1.5, 0.0, 0.0), Vec3::Y),
58    ));
59
60    // Spawn some cubes using the array texture.
61    let mesh_handle = meshes.add(Cuboid::default());
62    let material_handle = materials.add(ArrayTextureMaterial { array_texture });
63    for x in -5..=5 {
64        commands.spawn((
65            Mesh3d(mesh_handle.clone()),
66            MeshMaterial3d(material_handle.clone()),
67            // Pass a different mesh tag to allow selecting different layers of
68            // the array texture in the shader.
69            MeshTag::new(x as u32 % TEXTURE_COUNT),
70            Transform::from_xyz(x as f32 + 0.5, 0.0, 0.0),
71        ));
72    }
73}

examples/2d/tilemap_chunk.rs (line 49)

26fn setup(mut commands: Commands, assets: Res<AssetServer>) {
27    // We're seeding the PRNG here to make this example deterministic for testing purposes.
28    // This isn't strictly required in practical use unless you need your app to be deterministic.
29    let mut rng = ChaCha8Rng::seed_from_u64(42);
30
31    let chunk_size = UVec2::splat(64);
32    let tile_display_size = UVec2::splat(8);
33    let tile_data: Vec<Option<TileData>> = (0..chunk_size.element_product())
34        .map(|_| rng.random_range(0..5))
35        .map(|i| {
36            if i == 0 {
37                None
38            } else {
39                Some(TileData::from_tileset_index(i - 1))
40            }
41        })
42        .collect();
43
44    commands.spawn((
45        TilemapChunk {
46            chunk_size,
47            tile_display_size,
48            tileset: assets
49                .load_builder()
50                .with_settings(|settings: &mut ImageLoaderSettings| {
51                    // The tileset texture is expected to be an array of tile textures, so we tell the
52                    // `ImageLoader` that our texture is composed of 4 stacked tile images.
53                    settings.array_layout = Some(ImageArrayLayout::RowCount { rows: 4 });
54                })
55                .load("textures/array_texture.png"),
56            ..default()
57        },
58        TilemapChunkTileData(tile_data),
59        UpdateTimer(Timer::from_seconds(0.1, TimerMode::Repeating)),
60    ));
61
62    commands.spawn(Camera2d);
63
64    commands.insert_resource(SeededRng(rng));
65}

Additional examples can be found in:

Source

pub fn reload<'a>(&self, path: impl Into<AssetPath<'a>>)

Kicks off a reload of the asset stored at the given path. This will only reload the asset if it currently loaded.

Source

pub fn add<A>(&self, asset: A) -> Handle<A>
where A: Asset,

Queues a new asset to be tracked by the AssetServer and returns a Handle to it. This can be used to track dependencies of assets created at runtime.

After the asset has been fully loaded by the AssetServer, it will show up in the relevant Assets storage.

Examples found in repository ?

examples/asset/asset_decompression.rs (line 131)

115fn decompress<T: Component + From<Handle<A>>, A: Asset>(
116    mut commands: Commands,
117    asset_server: Res<AssetServer>,
118    mut compressed_assets: ResMut<Assets<GzAsset>>,
119    query: Query<(Entity, &Compressed<A>)>,
120) {
121    for (entity, Compressed { compressed, .. }) in query.iter() {
122        let Some(GzAsset { uncompressed }) = compressed_assets.remove(compressed) else {
123            continue;
124        };
125
126        let uncompressed = uncompressed.take::<A>().unwrap();
127
128        commands
129            .entity(entity)
130            .remove::<Compressed<A>>()
131            .insert(T::from(asset_server.add(uncompressed)));
132    }
133}

More examples

Hide additional examples

examples/3d/anisotropy.rs (lines 120-124)

101fn setup(mut commands: Commands, asset_server: Res<AssetServer>, app_status: Res<AppStatus>) {
102    commands.spawn((
103        Camera3d::default(),
104        ScreenSpaceTransmission::default(),
105        Transform::from_translation(CAMERA_INITIAL_POSITION).looking_at(Vec3::ZERO, Vec3::Y),
106    ));
107
108    spawn_directional_light(&mut commands);
109
110    commands.spawn((
111        WorldAssetRoot(
112            asset_server.load("models/AnisotropyBarnLamp/AnisotropyBarnLamp.gltf#Scene0"),
113        ),
114        Transform::from_xyz(0.0, 0.07, -0.13),
115        Scene::BarnLamp,
116    ));
117
118    commands.spawn((
119        Mesh3d(
120            asset_server.add(
121                Mesh::from(Sphere::new(0.1))
122                    .with_generated_tangents()
123                    .unwrap(),
124            ),
125        ),
126        MeshMaterial3d(asset_server.add(StandardMaterial {
127            base_color: palettes::tailwind::GRAY_300.into(),
128            anisotropy_rotation: 0.5,
129            anisotropy_strength: 1.,
130            ..default()
131        })),
132        Scene::Sphere,
133        Visibility::Hidden,
134    ));
135
136    spawn_text(&mut commands, &app_status);
137}

examples/3d/contact_shadows.rs (line 242)

119fn setup(mut commands: Commands, asset_server: Res<AssetServer>, app_status: Res<AppStatus>) {
120    commands.spawn((
121        Camera3d::default(),
122        Transform::from_xyz(-0.8, 0.6, -0.8).looking_at(Vec3::new(0.0, 0.35, 0.0), Vec3::Y),
123        ContactShadows::default(),
124        TemporalAntiAliasing::default(), // Contact shadows and AO benefit from TAA
125        // Everything past this point is extra to look pretty.
126        Bloom::default(),
127        Hdr,
128        Skybox {
129            brightness: 1000.0,
130            image: Some(asset_server.load("environment_maps/pisa_diffuse_rgb9e5_zstd.ktx2")),
131            ..default()
132        },
133        EnvironmentMapLight {
134            diffuse_map: asset_server.load("environment_maps/pisa_diffuse_rgb9e5_zstd.ktx2"),
135            specular_map: asset_server.load("environment_maps/pisa_specular_rgb9e5_zstd.ktx2"),
136            intensity: 1000.0,
137            ..default()
138        },
139        ScreenSpaceAmbientOcclusion::default(),
140        Msaa::Off,
141        Tonemapping::AcesFitted,
142        MotionBlur {
143            shutter_angle: 2.0, // This is really just for fun when spinning the model
144            ..default()
145        },
146    ));
147
148    let directional_light = commands
149        .spawn((
150            DirectionalLight {
151                shadow_maps_enabled: true,
152                contact_shadows_enabled: true,
153                ..default()
154            },
155            Visibility::Hidden,
156        ))
157        .id();
158
159    let point_light = commands
160        .spawn((
161            PointLight {
162                intensity: light_consts::lumens::VERY_LARGE_CINEMA_LIGHT * 0.4,
163                shadow_maps_enabled: true,
164                contact_shadows_enabled: true,
165                ..default()
166            },
167            Visibility::Visible,
168        ))
169        .id();
170
171    let spot_light = commands
172        .spawn((
173            SpotLight {
174                intensity: light_consts::lumens::VERY_LARGE_CINEMA_LIGHT * 0.4,
175                shadow_maps_enabled: true,
176                contact_shadows_enabled: true,
177                ..default()
178            },
179            Visibility::Hidden,
180        ))
181        .id();
182
183    commands
184        .spawn((
185            Transform::from_xyz(-0.8, 1.5, 1.2).looking_at(Vec3::ZERO, Vec3::Y),
186            Visibility::default(),
187            LightContainer,
188        ))
189        .add_child(directional_light)
190        .add_child(point_light)
191        .add_child(spot_light);
192
193    commands
194        .spawn((
195            WorldAssetRoot(asset_server.load(
196                GltfAssetLabel::Scene(0).from_asset("models/FlightHelmet/FlightHelmet.gltf"),
197            )),
198            Transform::from_rotation(Quat::from_rotation_y(std::f32::consts::PI)),
199        ))
200        .observe(
201            |event: On<PointerDrag>,
202             mut query: Query<&mut Transform, With<WorldAssetRoot>>,
203             mut commands: Commands,
204             mut window: Query<Entity, With<PrimaryWindow>>| {
205                for mut transform in query.iter_mut() {
206                    transform.rotate_y(event.delta.x * 0.01);
207                }
208                commands
209                    .entity(window.single_mut().unwrap())
210                    .insert(CursorIcon::System(SystemCursorIcon::Grabbing));
211            },
212        )
213        .observe(
214            |_: On<PointerOver>,
215             mut commands: Commands,
216             mut window: Query<Entity, With<PrimaryWindow>>| {
217                commands
218                    .entity(window.single_mut().unwrap())
219                    .insert(CursorIcon::System(SystemCursorIcon::Grab));
220            },
221        )
222        .observe(
223            |_: On<PointerOut>,
224             mut commands: Commands,
225             mut window: Query<Entity, With<PrimaryWindow>>| {
226                commands
227                    .entity(window.single_mut().unwrap())
228                    .insert(CursorIcon::System(SystemCursorIcon::Default));
229            },
230        )
231        .observe(
232            |_: On<PointerDragEnd>,
233             mut commands: Commands,
234             mut window: Query<Entity, With<PrimaryWindow>>| {
235                commands
236                    .entity(window.single_mut().unwrap())
237                    .insert(CursorIcon::System(SystemCursorIcon::Default));
238            },
239        );
240
241    commands.spawn((
242        Mesh3d(asset_server.add(Circle::default().mesh().into())),
243        MeshMaterial3d(asset_server.add(StandardMaterial {
244            base_color: Color::srgb(0.06, 0.06, 0.06),
245            ..default()
246        })),
247        Transform::from_rotation(Quat::from_axis_angle(Vec3::X, -std::f32::consts::FRAC_PI_2)),
248        GroundPlane,
249    ));
250
251    spawn_buttons(&mut commands, &app_status);
252
253    commands.spawn((
254        Node {
255            position_type: PositionType::Absolute,
256            top: px(12.0),
257            left: px(0.0),
258            right: px(0.0),
259            justify_content: JustifyContent::Center,
260            ..default()
261        },
262        children![(
263            Text::new("Drag model to spin"),
264            TextFont {
265                font_size: FontSize::Px(18.0),
266                ..default()
267            },
268        )],
269    ));
270}

Source

pub fn add_async<A, E>( &self, future: impl Future<Output = Result<A, E>> + Send + 'static, ) -> Handle<A>
where A: Asset, E: Error + Send + Sync + 'static,

Queues a new asset to be tracked by the AssetServer and returns a Handle to it. This can be used to track dependencies of assets created at runtime.

After the asset has been fully loaded, it will show up in the relevant Assets storage.

Examples found in repository ?

examples/asset/generated_assets.rs (line 35)

13fn setup(
14    mut commands: Commands,
15    asset_server: Res<AssetServer>,
16    mut materials: ResMut<Assets<StandardMaterial>>,
17    meshes: Res<Assets<Mesh>>,
18) {
19    commands.spawn((Camera3d::default(), Transform::from_xyz(0.0, 0.0, 5.0)));
20
21    commands.spawn((
22        DirectionalLight::default(),
23        Transform::default().looking_to(Dir3::new(Vec3::new(-1.0, -1.0, -1.0)).unwrap(), Dir3::Y),
24    ));
25
26    // The simplest way to generate an asset is to add it directly to the `Assets`.
27    let material_handle = materials.add(StandardMaterial::default());
28
29    commands.spawn((
30        Transform::from_xyz(-2.0, 0.0, 0.0),
31        MeshMaterial3d(material_handle.clone()),
32        // Alternatively, `add_async` creates a task that runs your async function. Once it
33        // completes, the asset is added to the `Assets`. This is "deferred" meaning that the asset
34        // may take a frame to be added after the task completes.
35        Mesh3d(asset_server.add_async(generate_mesh_async())),
36    ));
37
38    // The last way to generate assets is to reserve a handle, and then use `Assets::insert` to
39    // populate the asset later. In this example, the `generate_mesh_system` system runs to populate
40    // the mesh.
41    let mesh_handle = meshes.reserve_handle();
42    commands.insert_resource(HandleToGenerate(mesh_handle.clone()));
43    commands.spawn((
44        Transform::from_xyz(2.0, 0.0, 0.0)
45            .with_rotation(Quat::from_rotation_x(50.0f32.to_radians())),
46        Mesh3d(mesh_handle),
47        MeshMaterial3d(material_handle),
48    ));
49}

Source

pub fn load_folder<'a>( &self, path: impl Into<AssetPath<'a>>, ) -> Handle<LoadedFolder>

Loads all assets from the specified folder recursively. The LoadedFolder asset (when it loads) will contain handles to all assets in the folder. You can wait for all assets to load by checking the LoadedFolder’s RecursiveDependencyLoadState.

Loading the same folder multiple times will return the same handle. If the file_watcher feature is enabled, LoadedFolder handles will reload when a file in the folder is removed, added or moved. This includes files in subdirectories and moving, adding, or removing complete subdirectories.

Examples found in repository ?

examples/2d/texture_atlas.rs (line 34)

32fn load_textures(mut commands: Commands, asset_server: Res<AssetServer>) {
33    // Load multiple, individual sprites from a folder
34    commands.insert_resource(RpgSpriteFolder(asset_server.load_folder("textures/rpg")));
35}

More examples

Hide additional examples

examples/asset/asset_loading.rs (line 55)

12fn setup(
13    mut commands: Commands,
14    asset_server: Res<AssetServer>,
15    meshes: Res<Assets<Mesh>>,
16    mut materials: ResMut<Assets<StandardMaterial>>,
17) {
18    // By default AssetServer will load assets from inside the "assets" folder.
19    // For example, the next line will load GltfAssetLabel::Primitive{mesh:0,primitive:0}.from_asset("ROOT/assets/models/cube/cube.gltf"),
20    // where "ROOT" is the directory of the Application.
21    //
22    // This can be overridden by setting [`AssetPlugin.file_path`].
23    let cube_handle = asset_server.load(
24        GltfAssetLabel::Primitive {
25            mesh: 0,
26            primitive: 0,
27        }
28        .from_asset("models/cube/cube.gltf"),
29    );
30    let sphere_handle = asset_server.load(
31        GltfAssetLabel::Primitive {
32            mesh: 0,
33            primitive: 0,
34        }
35        .from_asset("models/sphere/sphere.gltf"),
36    );
37
38    // All assets end up in their Assets<T> collection once they are done loading:
39    if let Some(sphere) = meshes.get(&sphere_handle) {
40        // You might notice that this doesn't run! This is because assets load in parallel without
41        // blocking. When an asset has loaded, it will appear in relevant Assets<T>
42        // collection.
43        info!("{:?}", sphere.primitive_topology());
44    } else {
45        info!("sphere hasn't loaded yet");
46    }
47
48    // You can load all assets in a folder like this. They will be loaded in parallel without
49    // blocking. The LoadedFolder asset holds handles to each asset in the folder. These are all
50    // dependencies of the LoadedFolder asset, meaning you can wait for the LoadedFolder asset to
51    // fire AssetEvent::LoadedWithDependencies if you want to wait for all assets in the folder
52    // to load.
53    // If you want to keep the assets in the folder alive, make sure you store the returned handle
54    // somewhere.
55    let _loaded_folder: Handle<LoadedFolder> = asset_server.load_folder("models/torus");
56
57    // If you want a handle to a specific asset in a loaded folder, the easiest way to get one is to call load.
58    // It will _not_ be loaded a second time.
59    // The LoadedFolder asset will ultimately also hold handles to the assets, but waiting for it to load
60    // and finding the right handle is more work!
61    let torus_handle = asset_server.load(
62        GltfAssetLabel::Primitive {
63            mesh: 0,
64            primitive: 0,
65        }
66        .from_asset("models/torus/torus.gltf"),
67    );
68
69    // You can also add assets directly to their Assets<T> storage:
70    let material_handle = materials.add(StandardMaterial {
71        base_color: Color::srgb(0.8, 0.7, 0.6),
72        ..default()
73    });
74
75    // torus
76    commands.spawn((
77        Mesh3d(torus_handle),
78        MeshMaterial3d(material_handle.clone()),
79        Transform::from_xyz(-3.0, 0.0, 0.0),
80    ));
81    // cube
82    commands.spawn((
83        Mesh3d(cube_handle),
84        MeshMaterial3d(material_handle.clone()),
85        Transform::from_xyz(0.0, 0.0, 0.0),
86    ));
87    // sphere
88    commands.spawn((
89        Mesh3d(sphere_handle),
90        MeshMaterial3d(material_handle),
91        Transform::from_xyz(3.0, 0.0, 0.0),
92    ));
93    // light
94    commands.spawn((PointLight::default(), Transform::from_xyz(4.0, 5.0, 4.0)));
95    // camera
96    commands.spawn((
97        Camera3d::default(),
98        Transform::from_xyz(0.0, 3.0, 10.0).looking_at(Vec3::ZERO, Vec3::Y),
99    ));
100}

Source

pub fn get_load_states( &self, id: impl Into<UntypedAssetId>, ) -> Option<(LoadState, DependencyLoadState, RecursiveDependencyLoadState)>

Retrieves all loads states for the given asset id.

Source

pub fn get_load_state(&self, id: impl Into<UntypedAssetId>) -> Option<LoadState>

Retrieves the main LoadState of a given asset id.

Note that this is “just” the root asset load state. To get the load state of its dependencies or recursive dependencies, see AssetServer::get_dependency_load_state and AssetServer::get_recursive_dependency_load_state respectively.

Examples found in repository ?

examples/scene/world_serialization.rs (line 239)

237fn panic_on_fail(world_roots: Query<&DynamicWorldRoot>, asset_server: Res<AssetServer>) {
238    for world_root in &world_roots {
239        if let Some(LoadState::Failed(err)) = asset_server.get_load_state(&world_root.0) {
240            panic!("Failed to load world. {err}");
241        }
242    }
243}

Source

pub fn get_dependency_load_state( &self, id: impl Into<UntypedAssetId>, ) -> Option<DependencyLoadState>

Retrieves the DependencyLoadState of a given asset id’s dependencies.

Note that this is only the load state of direct dependencies of the root asset. To get the load state of the root asset itself or its recursive dependencies, see AssetServer::get_load_state and AssetServer::get_recursive_dependency_load_state respectively.

Source

pub fn get_recursive_dependency_load_state( &self, id: impl Into<UntypedAssetId>, ) -> Option<RecursiveDependencyLoadState>

Retrieves the main RecursiveDependencyLoadState of a given asset id’s recursive dependencies.

Note that this is only the load state of recursive dependencies of the root asset. To get the load state of the root asset itself or its direct dependencies only, see AssetServer::get_load_state and AssetServer::get_dependency_load_state respectively.

Examples found in repository ?

examples/showcase/loading_screen.rs (line 210)

197fn update_loading_data(
198    mut loading_data: ResMut<LoadingData>,
199    mut loading_state: ResMut<LoadingState>,
200    asset_server: Res<AssetServer>,
201    pipelines_ready: Res<PipelinesReady>,
202) {
203    if !loading_data.loading_assets.is_empty() || !pipelines_ready.0 {
204        // If we are still loading assets / pipelines are not fully compiled,
205        // we reset the confirmation frame count.
206        loading_data.confirmation_frames_count = 0;
207
208        loading_data.loading_assets.retain(|asset| {
209            asset_server
210                .get_recursive_dependency_load_state(asset)
211                .is_none_or(|state| !state.is_loaded())
212        });
213
214        // If there are no more assets being monitored, and pipelines
215        // are compiled, then start counting confirmation frames.
216        // Once enough confirmations have passed, everything will be
217        // considered to be fully loaded.
218    } else {
219        loading_data.confirmation_frames_count += 1;
220        if loading_data.confirmation_frames_count == loading_data.confirmation_frames_target {
221            *loading_state = LoadingState::LevelReady;
222        }
223    }
224}

Source

pub fn load_state(&self, id: impl Into<UntypedAssetId>) -> LoadState

Retrieves the main LoadState of a given asset id.

This is the same as AssetServer::get_load_state except the result is unwrapped. If the result is None, LoadState::NotLoaded is returned.

Examples found in repository ?

examples/3d/pbr.rs (line 134)

127fn environment_map_load_finish(
128    mut commands: Commands,
129    asset_server: Res<AssetServer>,
130    environment_map: Single<&EnvironmentMapLight>,
131    label_entity: Option<Single<Entity, With<EnvironmentMapLabel>>>,
132) {
133    if asset_server
134        .load_state(&environment_map.diffuse_map)
135        .is_loaded()
136        && asset_server
137            .load_state(&environment_map.specular_map)
138            .is_loaded()
139    {
140        // Do not attempt to remove `label_entity` if it has already been removed.
141        if let Some(label_entity) = label_entity {
142            commands.entity(*label_entity).despawn();
143        }
144    }
145}

More examples

Hide additional examples

examples/3d/skybox.rs (line 154)

148fn asset_loaded(
149    asset_server: Res<AssetServer>,
150    mut images: ResMut<Assets<Image>>,
151    mut cubemap: ResMut<Cubemap>,
152    mut skyboxes: Query<&mut Skybox>,
153) {
154    if !cubemap.is_loaded && asset_server.load_state(&cubemap.image_handle).is_loaded() {
155        info!("Swapping to {}...", CUBEMAPS[cubemap.index].0);
156        let mut image = images.get_mut(&cubemap.image_handle).unwrap();
157        // NOTE: PNGs do not have any metadata that could indicate they contain a cubemap texture,
158        // so they appear as one texture. The following code reconfigures the texture as necessary.
159        if image.texture_descriptor.array_layer_count() == 1 {
160            let layers = image.height() / image.width();
161            image
162                .reinterpret_stacked_2d_as_array(layers)
163                .expect("asset should be 2d texture and height will always be evenly divisible with the given layers");
164            image.texture_view_descriptor = Some(TextureViewDescriptor {
165                dimension: Some(TextureViewDimension::Cube),
166                ..default()
167            });
168        }
169
170        for mut skybox in &mut skyboxes {
171            skybox.image = Some(cubemap.image_handle.clone());
172        }
173
174        cubemap.is_loaded = true;
175    }
176}

Source

pub fn dependency_load_state( &self, id: impl Into<UntypedAssetId>, ) -> DependencyLoadState

Retrieves the DependencyLoadState of a given asset id.

This is the same as AssetServer::get_dependency_load_state except the result is unwrapped. If the result is None, DependencyLoadState::NotLoaded is returned.

Source

pub fn recursive_dependency_load_state( &self, id: impl Into<UntypedAssetId>, ) -> RecursiveDependencyLoadState

Retrieves the RecursiveDependencyLoadState of a given asset id.

This is the same as AssetServer::get_recursive_dependency_load_state except the result is unwrapped. If the result is None, RecursiveDependencyLoadState::NotLoaded is returned.

Source

pub fn is_loaded(&self, id: impl Into<UntypedAssetId>) -> bool

Convenience method that returns true if the asset has been loaded.

Source

pub fn is_loaded_with_direct_dependencies( &self, id: impl Into<UntypedAssetId>, ) -> bool

Convenience method that returns true if the asset and all of its direct dependencies have been loaded.

Source

pub fn is_loaded_with_dependencies(&self, id: impl Into<UntypedAssetId>) -> bool

Convenience method that returns true if the asset, all of its dependencies, and all of its recursive dependencies have been loaded.

Examples found in repository ?

examples/animation/animated_mesh_control.rs (line 104)

97fn spawn_fox_asset_when_ready(
98    mut commands: Commands,
99    fox_handle: Res<Fox>,
100    asset_server: Res<AssetServer>,
101    gltfs: Res<Assets<Gltf>>,
102    mut graphs: ResMut<Assets<AnimationGraph>>,
103) {
104    if !asset_server.is_loaded_with_dependencies(&fox_handle.0) {
105        // fox is not loaded yet
106        return;
107    }
108
109    let fox = gltfs
110        .get(&fox_handle.0)
111        .expect("a loaded asset should exist in the glTF assets collection");
112
113    // Build the animation graph
114    let (graph, node_indices) = AnimationGraph::from_clips([
115        fox.named_animations["Run"].clone(),
116        fox.named_animations["Walk"].clone(),
117        fox.named_animations["Survey"].clone(),
118    ]);
119
120    // Keep our animation graph in a Resource so that it can be inserted onto
121    // the correct entity once the scene actually loads.
122    let graph_handle = graphs.add(graph);
123    commands.insert_resource(Animations {
124        animations: node_indices,
125        graph_handle,
126    });
127
128    // Fox
129    commands
130        .spawn(WorldAssetRoot(
131            fox.default_scene
132                .clone()
133                .expect("a default scene exists in this file"),
134        ))
135        .observe(setup_scene);
136}

Source

pub fn are_dependencies_loaded( &self, value: &impl VisitAssetDependencies, ) -> bool

Returns true if all of values dependencies (included recursive dependencies) are loaded.

This allows querying for whether all the handles in a resource or component are loaded.

Source

pub fn are_direct_dependencies_loaded( &self, value: &impl VisitAssetDependencies, ) -> bool

Returns true if all of values dependencies (excluding recursive dependencies) are loaded.

This allows querying for whether all the handles in a resource or component are loaded.

Source

pub fn get_handle<'a, A>( &self, path: impl Into<AssetPath<'a>>, ) -> Option<Handle<A>>
where A: Asset,

Returns an active handle for the given path, if the asset at the given path has already started loading, or is still “alive”.

Examples found in repository ?

examples/2d/texture_atlas.rs (line 144)

50fn setup(
51    mut commands: Commands,
52    rpg_sprite_handles: Res<RpgSpriteFolder>,
53    asset_server: Res<AssetServer>,
54    mut texture_atlases: ResMut<Assets<TextureAtlasLayout>>,
55    loaded_folders: Res<Assets<LoadedFolder>>,
56    mut textures: ResMut<Assets<Image>>,
57) {
58    let loaded_folder = loaded_folders.get(&rpg_sprite_handles.0).unwrap();
59
60    // Create texture atlases with different padding and sampling
61
62    let (texture_atlas_linear, linear_sources, linear_texture) = create_texture_atlas(
63        loaded_folder,
64        None,
65        Some(ImageSampler::linear()),
66        &mut textures,
67    );
68    let atlas_linear_handle = texture_atlases.add(texture_atlas_linear);
69
70    let (texture_atlas_nearest, nearest_sources, nearest_texture) = create_texture_atlas(
71        loaded_folder,
72        None,
73        Some(ImageSampler::nearest()),
74        &mut textures,
75    );
76    let atlas_nearest_handle = texture_atlases.add(texture_atlas_nearest);
77
78    let (texture_atlas_linear_padded, linear_padded_sources, linear_padded_texture) =
79        create_texture_atlas(
80            loaded_folder,
81            Some(UVec2::new(6, 6)),
82            Some(ImageSampler::linear()),
83            &mut textures,
84        );
85    let atlas_linear_padded_handle = texture_atlases.add(texture_atlas_linear_padded.clone());
86
87    let (texture_atlas_nearest_padded, nearest_padded_sources, nearest_padded_texture) =
88        create_texture_atlas(
89            loaded_folder,
90            Some(UVec2::new(6, 6)),
91            Some(ImageSampler::nearest()),
92            &mut textures,
93        );
94    let atlas_nearest_padded_handle = texture_atlases.add(texture_atlas_nearest_padded);
95
96    commands.spawn(Camera2d);
97
98    // Padded textures are to the right, unpadded to the left
99
100    // Draw unpadded texture atlas
101    commands.spawn((
102        Sprite::from_image(linear_texture.clone()),
103        Transform {
104            translation: Vec3::new(-250.0, -160.0, 0.0),
105            scale: Vec3::splat(0.5),
106            ..default()
107        },
108    ));
109
110    // Draw padded texture atlas
111    commands.spawn((
112        Sprite::from_image(linear_padded_texture.clone()),
113        Transform {
114            translation: Vec3::new(250.0, -160.0, 0.0),
115            scale: Vec3::splat(0.5),
116            ..default()
117        },
118    ));
119
120    let font = asset_server.load("fonts/FiraSans-Bold.ttf");
121
122    // Padding label text style
123    let text_style: TextFont = TextFont {
124        font: font.clone().into(),
125        font_size: FontSize::Px(42.0),
126        ..default()
127    };
128
129    // Labels to indicate padding
130
131    // No padding
132    create_label(
133        &mut commands,
134        (-250.0, 250.0, 0.0),
135        "No padding",
136        text_style.clone(),
137    );
138
139    // Padding
140    create_label(&mut commands, (250.0, 250.0, 0.0), "Padding", text_style);
141
142    // Get handle to a sprite to render
143    let vendor_handle: Handle<Image> = asset_server
144        .get_handle("textures/rpg/chars/vendor/generic-rpg-vendor.png")
145        .unwrap();
146
147    // Configuration array to render sprites through iteration
148    let configurations: [(
149        &str,
150        Handle<TextureAtlasLayout>,
151        TextureAtlasSources,
152        Handle<Image>,
153        f32,
154    ); 4] = [
155        (
156            "Linear",
157            atlas_linear_handle,
158            linear_sources,
159            linear_texture,
160            -350.0,
161        ),
162        (
163            "Nearest",
164            atlas_nearest_handle,
165            nearest_sources,
166            nearest_texture,
167            -150.0,
168        ),
169        (
170            "Linear",
171            atlas_linear_padded_handle,
172            linear_padded_sources,
173            linear_padded_texture,
174            150.0,
175        ),
176        (
177            "Nearest",
178            atlas_nearest_padded_handle,
179            nearest_padded_sources,
180            nearest_padded_texture,
181            350.0,
182        ),
183    ];
184
185    // Label text style
186    let sampling_label_style = TextFont {
187        font: font.into(),
188        font_size: FontSize::Px(25.0),
189        ..default()
190    };
191
192    let base_y = 80.0; // y position of the sprites
193
194    for (sampling, atlas_handle, atlas_sources, atlas_texture, x) in configurations {
195        // Render a sprite from the texture_atlas
196        create_sprite_from_atlas(
197            &mut commands,
198            (x, base_y, 0.0),
199            atlas_texture,
200            atlas_sources,
201            atlas_handle,
202            &vendor_handle,
203        );
204
205        // Render a label to indicate the sampling setting
206        create_label(
207            &mut commands,
208            (x, base_y + 110.0, 0.0), // Offset to y position of the sprite
209            sampling,
210            sampling_label_style.clone(),
211        );
212    }
213}

Source

pub fn get_id_handle<A>(&self, id: AssetId<A>) -> Option<Handle<A>>
where A: Asset,

Get a Handle from an AssetId.

This only returns Some if id is derived from a Handle that was loaded through an AssetServer, otherwise it returns None.

Consider using Assets::get_strong_handle in the case the Handle comes from Assets::add.

Source

pub fn get_id_handle_untyped(&self, id: UntypedAssetId) -> Option<UntypedHandle>

Get an UntypedHandle from an UntypedAssetId. See AssetServer::get_id_handle for details.

Source

pub fn is_managed(&self, id: impl Into<UntypedAssetId>) -> bool

Returns true if the given id corresponds to an asset that is managed by this AssetServer. Otherwise, returns false.

Source

pub fn get_path_id<'a>( &self, path: impl Into<AssetPath<'a>>, ) -> Option<UntypedAssetId>

Returns an active untyped asset id for the given path, if the asset at the given path has already started loading, or is still “alive”. Returns the first ID in the event of multiple assets being registered against a single path.

§See also

get_path_ids for all handles.

Source

pub fn get_path_ids<'a>( &self, path: impl Into<AssetPath<'a>>, ) -> Vec<UntypedAssetId>

Returns all active untyped asset IDs for the given path, if the assets at the given path have already started loading, or are still “alive”. Multiple IDs will be returned in the event that a single path is used by multiple AssetLoader’s.

Source

pub fn get_handle_untyped<'a>( &self, path: impl Into<AssetPath<'a>>, ) -> Option<UntypedHandle>

Returns an active untyped handle for the given path, if the asset at the given path has already started loading, or is still “alive”. Returns the first handle in the event of multiple assets being registered against a single path.

§See also

get_handles_untyped for all handles.

Source

pub fn get_handles_untyped<'a>( &self, path: impl Into<AssetPath<'a>>, ) -> Vec<UntypedHandle>

Returns all active untyped handles for the given path, if the assets at the given path have already started loading, or are still “alive”. Multiple handles will be returned in the event that a single path is used by multiple AssetLoader’s.

Source

pub fn get_path_and_type_id_handle( &self, path: &AssetPath<'_>, type_id: TypeId, ) -> Option<UntypedHandle>

Returns an active untyped handle for the given path and TypeId, if the asset at the given path has already started loading, or is still “alive”.

Source

pub fn get_path(&self, id: impl Into<UntypedAssetId>) -> Option<AssetPath<'_>>

Returns the path for the given id, if it has one.

Examples found in repository ?

examples/animation/morph_targets.rs (line 87)

80fn name_morphs(
81    asset_server: Res<AssetServer>,
82    mut events: MessageReader<AssetEvent<Mesh>>,
83    meshes: Res<Assets<Mesh>>,
84) {
85    for event in events.read() {
86        if let AssetEvent::<Mesh>::Added { id } = event
87            && let Some(path) = asset_server.get_path(*id)
88            && let Some(mesh) = meshes.get(*id)
89            && let Some(names) = mesh.morph_target_names()
90        {
91            info!("Morph target names for {path:?}:");
92
93            for name in names {
94                info!("  {name}");
95            }
96        }
97    }
98}

Source

pub fn mode(&self) -> AssetServerMode

Returns the AssetServerMode this server is currently in.

Source

pub fn preregister_loader<L>(&self, extensions: &[&str])
where L: AssetLoader,

Pre-register a loader that will later be added.

Assets loaded with matching extensions will be blocked until the real loader is added.

Source

pub async fn wait_for_asset<A>( &self, handle: &Handle<A>, ) -> Result<(), WaitForAssetError>
where A: Asset,

Returns a future that will suspend until the specified asset and its dependencies finish loading.

§Errors

This will return an error if the asset or any of its dependencies fail to load, or if the asset has not been queued up to be loaded.

Source

pub async fn wait_for_asset_untyped( &self, handle: &UntypedHandle, ) -> Result<(), WaitForAssetError>

Returns a future that will suspend until the specified asset and its dependencies finish loading.

§Errors

This will return an error if the asset or any of its dependencies fail to load, or if the asset has not been queued up to be loaded.

Source

pub async fn wait_for_asset_id( &self, id: impl Into<UntypedAssetId>, ) -> Result<(), WaitForAssetError>

Returns a future that will suspend until the specified asset and its dependencies finish loading.

Note that since an asset ID does not count as a reference to the asset, the future returned from this method will not keep the asset alive. This may lead to the asset unexpectedly being dropped while you are waiting for it to finish loading.

When calling this method, make sure a strong handle is stored elsewhere to prevent the asset from being dropped. If you have access to an asset’s strong Handle, you should prefer to call AssetServer::wait_for_asset or wait_for_asset_untyped to ensure the asset finishes loading.

§Errors

This will return an error if the asset or any of its dependencies fail to load, or if the asset has not been queued up to be loaded.

Source

pub async fn write_default_loader_meta_file_for_path( &self, path: impl Into<AssetPath<'_>>, ) -> Result<(), WriteDefaultMetaError>

Writes the default loader meta file for the provided path.

This function only generates meta files that simply load the path directly. To generate a meta file that will use the default asset processor for the path, see AssetProcessor::write_default_meta_file_for_path.

Note if there is already a meta file for path, this function returns Err(WriteDefaultMetaError::MetaAlreadyExists).

Trait Implementations§

Source §

impl Clone for AssetServer

Source §

fn clone(&self) -> AssetServer

Returns a duplicate of the value. Read more

1.0.0 (const: unstable) · Source§

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

Performs copy-assignment from source. Read more

Source §

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

Source §

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::SparseSet

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, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )

Registers required components. Read more

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 relationship_accessor() -> Option<ComponentRelationshipAccessor<AssetServer>>

Returns ComponentRelationshipAccessor required for working with relationships in dynamic contexts. Read more

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_discard() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_discard 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 §

const HAS_SUMMARY_TICK: bool = false

Set this constant to true if the component should track a summary tick. Read more

Source §

impl Debug for AssetServer

Source §

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

Formats the value using the given formatter. Read more

Source §

impl GetAssetServer for AssetServer

Source §

fn get_asset_server(&self) -> &AssetServer

Return a reference to the relevant AssetServer.

Source §

impl LoadFromPath for AssetServer

Source §

fn load_from_path_erased( &mut self, type_id: TypeId, path: AssetPath<'static>, ) -> UntypedHandle

Initiates the load for the given expected type ID, and the path. Read more

Source §

impl LoadFromPath for &AssetServer

Source §

fn load_from_path_erased( &mut self, type_id: TypeId, path: AssetPath<'static>, ) -> UntypedHandle

Initiates the load for the given expected type ID, and the path. Read more

Source §

impl Resource for AssetServer
where AssetServer: Send + Sync + 'static,

Auto Trait Implementations§

§

impl UnsafeUnpin for AssetServer

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 for T
where U: ShaderType, &'a T: for<'a> Into,

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<'_>, ) -> impl Iterator<Item = ComponentId> + use<C>

Source §

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

Returns an iterator over 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>, C: Sized,

Source §

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

Source §

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

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> ConditionalSend for T
where T: Send,

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 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 + Sync + Send> ⓘ

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<S, T> Duplex<S> for T
where T: FromSample<S> + ToSample<S>,

Source §

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

Source §

type Effect = ()

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

Source §

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

Moves the components out of the bundle. Read more

Source §

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

Applies the after-effects of spawning this bundle. Read more

Source §

impl<T> ErasedBundleTemplate for T
where T: Template + Send + Sync + 'static, <T as Template>::Output: Bundle,

Source §

unsafe fn apply( &self, context: &mut TemplateContext<'_, '_>, ) -> Result<(), BevyError>

Applies this template to the given entity. Read more

Source §

fn clone_template(&self) -> Box<dyn ErasedBundleTemplate>

Clones this template. See Clone.

Source §

impl<T> ErasedDestructor for T
where T: 'static,

Source §

impl<T> ErasedTemplate for T
where T: Template + Send + Sync + 'static, <T as Template>::Output: SceneEffect,

Source §

unsafe fn apply( &self, context: &mut TemplateContext<'_, '_>, bundle_writer: &mut BundleWriter<'_>, ) -> Result<(), BevyError>

Applies this template to the given entity. Read more

Source §

fn clone_template(&self) -> Box<dyn ErasedTemplate>

Clones this template. See Clone.

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, W> HasTypeWitness<W> for T
where W: MakeTypeWitness<Arg = T>, T: ?Sized,

Source §

const WITNESS: W = W::MAKE

A constant of the type witness

Source §

impl<T> HitDataExtra for T
where T: Send + Sync + Debug + Any + 'static,

Source §

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

Source §

const TYPE_EQ: TypeEq<T, <T as Identity>::Type> = TypeEq::NEW

Proof that Self is the same type as Self::Type, provides methods for casting between Self and Self::Type.

Source §

type Type = T

The same type as Self, used to emulate type equality bounds (T == U) with associated type equality constraints (T: Identity<Type = U>).

Source §

impl<T> InitializeFromFunction<T> for T

Source §

fn initialize_from_function(f: fn() -> T) -> T

Create an instance of this type from an initialization function

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 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<T> IntoResult<T> for T

Source §

fn into_result(self) -> Result<T, RunSystemError>

Converts this type into the system output type.

Source §

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

Source §

fn into_sample(self) -> T

Source §

impl<A> Is for A
where A: Any,

Source §

fn is<T>() -> bool
where T: Any,

Checks if the current type “is” another type, using a TypeId equality comparison. This is most useful in the context of generic logic. Read more

Source §

impl<T> PatchTemplate for T
where T: Template,

Source §

fn patch_template<F>(func: F) -> TemplatePatch<F, T>
where F: FnOnce(&mut T, &mut ResolveContext<'_>),

Takes a “patch function” func that patches this Template, and turns it into a TemplatePatch.

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: '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: '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: '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: '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> Read<Exclusive, BecauseExclusive> for T
where T: ?Sized,

Source §

impl<T> Same for T

Source §

type Output = T

Should always be Self

Source §

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

Source §

fn apply( self, context: &mut TemplateContext<'_, '_>, bundle_writer: &mut BundleWriter<'_>, )

Applies the scene effect to the current context.

Source §

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

Source §

impl<Ret> SpawnIfAsync<(), Ret> for Ret

Source §

fn spawn(self) -> Ret

Spawn the value into the dioxus runtime if it is an async block

Source §

impl<T, O> SuperFrom<T> for O
where O: From<T>,

Source §

fn super_from(input: T) -> O

Convert from a type to another type.

Source §

impl<T, O, M> SuperInto<O, M> for T
where O: SuperFrom<T, M>,

Source §

fn super_into(self) -> O

Convert from a type to another type.

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(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow, B: ?Sized,

Immutable access to the Borrow of a value. Read more

Source §

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

Mutable access to the BorrowMut 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(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow, B: ?Sized,

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

Source §

fn tap_borrow_mut_dbg(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut, 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> Template for T
where T: Clone + Unpin,

Source §

type Output = T

The type of value produced by this Template.

Source §

fn build_template( &self, _context: &mut TemplateContext<'_, '_>, ) -> Result<<T as Template>::Output, BevyError>

Uses this template and the given entity context to produce a Template::Output.

Source §

fn clone_template(&self) -> T

Clones this template. See Clone.

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 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 for T
where U: Into<T>,

Source §

type Error = !

The type returned in the event of a conversion error.

Source §

fn try_from(value: U) -> Result<T, !>

Performs the conversion.

Source §

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

Source §

type Error = >::Error

The type returned in the event of a conversion error.

Source §

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

Performs the conversion.

Source §

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

Source §

fn clone_type_data(&self) -> Box<dyn TypeData>

Creates a type-erased clone of self.

Source §

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

Source §

fn vzip(self) -> V

Source §

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

Source §

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

Source §

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

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

Struct AssetServer Copy item path

Implementations§

impl AssetServer

pub const STARTED_LOAD_COUNT: DiagnosticPath

pub fn new( sources: Arc<AssetSources>, mode: AssetServerMode, watching_for_changes: bool, unapproved_path_mode: UnapprovedPathMode, ) -> AssetServer

pub fn new_with_meta_check( sources: Arc<AssetSources>, mode: AssetServerMode, meta_check: AssetMetaCheck, watching_for_changes: bool, unapproved_path_mode: UnapprovedPathMode, ) -> AssetServer

pub fn get_source<'a>( &self, source: impl Into<AssetSourceId<'a>>, ) -> Result<&AssetSource, MissingAssetSourceError>

pub fn watching_for_changes(&self) -> bool

pub fn register_loader<L>(&self, loader: L)where L: AssetLoader,

pub fn register_asset<A>(&self, assets: &Assets<A>)where A: Asset,

pub async fn get_asset_loader_with_extension( &self, extension: &str, ) -> Result<Arc<dyn ErasedAssetLoader>, MissingAssetLoaderForExtensionError>

pub async fn get_asset_loader_with_type_name( &self, type_name: &str, ) -> Result<Arc<dyn ErasedAssetLoader>, MissingAssetLoaderForTypeNameError>

pub async fn get_path_asset_loader<'a>( &self, path: impl Into<AssetPath<'a>>, ) -> Result<Arc<dyn ErasedAssetLoader>, MissingAssetLoaderForExtensionError>

pub async fn get_asset_loader_with_asset_type_id( &self, type_id: TypeId, ) -> Result<Arc<dyn ErasedAssetLoader>, MissingAssetLoaderForTypeIdError>

pub async fn get_asset_loader_with_asset_type<A>( &self, ) -> Result<Arc<dyn ErasedAssetLoader>, MissingAssetLoaderForTypeIdError>where A: Asset,

pub fn load<'a, A>(&self, path: impl Into<AssetPath<'a>>) -> Handle<A>where A: Asset,

pub fn load_builder(&self) -> LoadBuilder<'_>

pub fn reload<'a>(&self, path: impl Into<AssetPath<'a>>)

pub fn add<A>(&self, asset: A) -> Handle<A>where A: Asset,

pub fn add_async<A, E>( &self, future: impl Future<Output = Result<A, E>> + Send + 'static, ) -> Handle<A>where A: Asset, E: Error + Send + Sync + 'static,

pub fn load_folder<'a>( &self, path: impl Into<AssetPath<'a>>, ) -> Handle<LoadedFolder>

pub fn get_load_states( &self, id: impl Into<UntypedAssetId>, ) -> Option<(LoadState, DependencyLoadState, RecursiveDependencyLoadState)>

pub fn get_load_state(&self, id: impl Into<UntypedAssetId>) -> Option<LoadState>

pub fn get_dependency_load_state( &self, id: impl Into<UntypedAssetId>, ) -> Option<DependencyLoadState>

pub fn get_recursive_dependency_load_state( &self, id: impl Into<UntypedAssetId>, ) -> Option<RecursiveDependencyLoadState>

pub fn load_state(&self, id: impl Into<UntypedAssetId>) -> LoadState

pub fn dependency_load_state( &self, id: impl Into<UntypedAssetId>, ) -> DependencyLoadState

pub fn recursive_dependency_load_state( &self, id: impl Into<UntypedAssetId>, ) -> RecursiveDependencyLoadState

pub fn is_loaded(&self, id: impl Into<UntypedAssetId>) -> bool

pub fn is_loaded_with_direct_dependencies( &self, id: impl Into<UntypedAssetId>, ) -> bool

pub fn is_loaded_with_dependencies(&self, id: impl Into<UntypedAssetId>) -> bool

pub fn are_dependencies_loaded( &self, value: &impl VisitAssetDependencies, ) -> bool

pub fn are_direct_dependencies_loaded( &self, value: &impl VisitAssetDependencies, ) -> bool

pub fn get_handle<'a, A>( &self, path: impl Into<AssetPath<'a>>, ) -> Option<Handle<A>>where A: Asset,

pub fn get_id_handle<A>(&self, id: AssetId<A>) -> Option<Handle<A>>where A: Asset,

pub fn get_id_handle_untyped(&self, id: UntypedAssetId) -> Option<UntypedHandle>

pub fn is_managed(&self, id: impl Into<UntypedAssetId>) -> bool

pub fn get_path_id<'a>( &self, path: impl Into<AssetPath<'a>>, ) -> Option<UntypedAssetId>

§See also

pub fn get_path_ids<'a>( &self, path: impl Into<AssetPath<'a>>, ) -> Vec<UntypedAssetId>

pub fn get_handle_untyped<'a>( &self, path: impl Into<AssetPath<'a>>, ) -> Option<UntypedHandle>

§See also

pub fn get_handles_untyped<'a>( &self, path: impl Into<AssetPath<'a>>, ) -> Vec<UntypedHandle>

pub fn get_path_and_type_id_handle( &self, path: &AssetPath<'_>, type_id: TypeId, ) -> Option<UntypedHandle>

pub fn get_path(&self, id: impl Into<UntypedAssetId>) -> Option<AssetPath<'_>>

pub fn mode(&self) -> AssetServerMode

pub fn preregister_loader<L>(&self, extensions: &[&str])where L: AssetLoader,

pub async fn wait_for_asset<A>( &self, handle: &Handle<A>, ) -> Result<(), WaitForAssetError>where A: Asset,

§Errors

pub async fn wait_for_asset_untyped( &self, handle: &UntypedHandle, ) -> Result<(), WaitForAssetError>

§Errors

pub async fn wait_for_asset_id( &self, id: impl Into<UntypedAssetId>, ) -> Result<(), WaitForAssetError>

§Errors

pub async fn write_default_loader_meta_file_for_path( &self, path: impl Into<AssetPath<'_>>, ) -> Result<(), WriteDefaultMetaError>

Trait Implementations§

impl Clone for AssetServer

fn clone(&self) -> AssetServer

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

impl Component for AssetServerwhere AssetServer: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::SparseSet

type Mutability = Mutable

fn register_required_components( _requiree: ComponentId, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )

fn clone_behavior() -> ComponentCloneBehavior

fn relationship_accessor() -> Option<ComponentRelationshipAccessor<AssetServer>>

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

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

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

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

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

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

const HAS_SUMMARY_TICK: bool = false

impl Debug for AssetServer

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

impl GetAssetServer for AssetServer

fn get_asset_server(&self) -> &AssetServer

impl LoadFromPath for AssetServer

fn load_from_path_erased( &mut self, type_id: TypeId, path: AssetPath<'static>, ) -> UntypedHandle

impl LoadFromPath for &AssetServer

fn load_from_path_erased( &mut self, type_id: TypeId, path: AssetPath<'static>, ) -> UntypedHandle

impl Resource for AssetServerwhere AssetServer: Send + Sync + 'static,

Struct AssetServer

pub fn register_loader<L>(&self, loader: L)
where L: AssetLoader,

pub fn register_asset<A>(&self, assets: &Assets<A>)
where A: Asset,

pub async fn get_asset_loader_with_asset_type<A>( &self, ) -> Result<Arc<dyn ErasedAssetLoader>, MissingAssetLoaderForTypeIdError>
where A: Asset,

pub fn load<'a, A>(&self, path: impl Into<AssetPath<'a>>) -> Handle<A>
where A: Asset,

pub fn add<A>(&self, asset: A) -> Handle<A>
where A: Asset,

pub fn add_async<A, E>( &self, future: impl Future<Output = Result<A, E>> + Send + 'static, ) -> Handle<A>
where A: Asset, E: Error + Send + Sync + 'static,

pub fn get_handle<'a, A>( &self, path: impl Into<AssetPath<'a>>, ) -> Option<Handle<A>>
where A: Asset,

pub fn get_id_handle<A>(&self, id: AssetId<A>) -> Option<Handle<A>>
where A: Asset,

pub fn preregister_loader<L>(&self, extensions: &[&str])
where L: AssetLoader,

pub async fn wait_for_asset<A>( &self, handle: &Handle<A>, ) -> Result<(), WaitForAssetError>
where A: Asset,

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

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

impl Resource for AssetServer
where AssetServer: Send + Sync + 'static,

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

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

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

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

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

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

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

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

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

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

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

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

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

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

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

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

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

impl<T> ErasedBundleTemplate for T
where T: Template + Send + Sync + 'static, <T as Template>::Output: Bundle,