Struct AssetServer 

pub struct AssetServer { /* private fields */ }

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:

1. 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.
2. Register one or more AssetLoaders for that asset with AssetApp::init_asset_loader
3. Add the asset to your asset folder (defaults to assets).
4. 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

impl AssetServer

pub fn new( sources: 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.

pub fn new_with_meta_check( sources: 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.

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

Retrieves the AssetSource for the given source.

pub fn watching_for_changes(&self) -> bool

Returns true if the AssetServer watches for changes.

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

where L: AssetLoader,

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

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.

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.

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 core::any::type_name, if it exists.

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.

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.

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.

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/state/states.rs (line 117)

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

examples/scene/scene.rs (line 125)

fn load_scene_system(mut commands: Commands, asset_server: Res<AssetServer>) {
    commands.spawn(DynamicSceneRoot(asset_server.load(SCENE_FILE_PATH)));
}

examples/state/sub_states.rs (line 195)

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

examples/audio/audio.rs (line 15)

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

examples/asset/custom_asset_reader.rs (line 64)

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

examples/state/custom_transitions.rs (line 226)

fn setup_game(mut commands: Commands, asset_server: Res<AssetServer>) {
    commands.spawn(Sprite::from_image(asset_server.load("branding/icon.png")));
    info!("Setup game");
}

Additional examples can be found in:

• examples/window/transparent_window.rs
• examples/2d/sprite.rs
• examples/3d/specular_tint.rs
• examples/3d/reflection_probes.rs
• examples/state/computed_states.rs
• examples/shader/shader_material_wesl.rs
• examples/asset/asset_decompression.rs
• examples/ecs/removal_detection.rs
• examples/2d/move_sprite.rs
• examples/shader_advanced/custom_shader_instancing.rs
• examples/shader_advanced/custom_render_phase.rs
• examples/testbed/ui.rs
• examples/3d/clearcoat.rs
• examples/asset/web_asset.rs
• examples/shader_advanced/specialized_mesh_pipeline.rs
• examples/2d/sprite_flipping.rs
• examples/animation/gltf_skinned_mesh.rs
• examples/asset/custom_asset.rs
• examples/asset/processing/asset_processing.rs
• examples/3d/query_gltf_primitives.rs
• examples/2d/sprite_tile.rs
• examples/3d/lightmaps.rs
• examples/shader/shader_material_2d.rs
• examples/ui/overflow_debug.rs
• examples/shader/array_texture.rs
• examples/ecs/fallible_params.rs
• examples/3d/color_grading.rs
• examples/window/window_settings.rs
• examples/3d/ssr.rs
• examples/3d/light_textures.rs
• examples/audio/soundtrack.rs
• examples/2d/custom_gltf_vertex_attribute.rs
• examples/3d/occlusion_culling.rs
• examples/2d/pixel_grid_snap.rs
• examples/3d/mixed_lighting.rs
• examples/shader/shader_material.rs
• examples/shader/shader_material_glsl.rs
• examples/3d/clustered_decals.rs
• examples/asset/extra_source.rs
• examples/shader_advanced/texture_binding_array.rs
• examples/ui/window_fallthrough.rs
• examples/2d/sprite_slice.rs
• examples/asset/hot_asset_reloading.rs
• examples/ecs/parallel_query.rs
• examples/audio/audio_control.rs
• examples/2d/transparency_2d.rs
• examples/ui/standard_widgets.rs
• examples/ui/standard_widgets_observers.rs
• examples/animation/morph_targets.rs
• examples/3d/post_processing.rs
• examples/3d/rotate_environment_map.rs
• examples/3d/load_gltf_extras.rs
• examples/shader/gpu_readback.rs
• examples/asset/embedded_asset.rs
• examples/2d/sprite_sheet.rs
• examples/games/loading_screen.rs
• examples/3d/tonemapping.rs
• examples/games/game_menu.rs
• examples/shader/shader_material_screenspace_texture.rs
• examples/3d/pcss.rs
• examples/3d/depth_of_field.rs
• examples/testbed/3d.rs
• examples/3d/edit_material_on_gltf.rs
• examples/shader/shader_material_bindless.rs
• examples/3d/anisotropy.rs
• examples/ui/font_atlas_debug.rs
• examples/animation/animation_masks.rs
• examples/2d/tilemap_chunk.rs
• examples/3d/animated_material.rs
• examples/3d/load_gltf.rs
• examples/input/text_input.rs
• examples/ui/button.rs
• examples/animation/animated_mesh.rs
• examples/shader/extended_material_bindless.rs
• examples/3d/skybox.rs
• examples/stress_tests/text_pipeline.rs
• examples/3d/update_gltf_scene.rs
• examples/3d/atmospheric_fog.rs
• examples/3d/fog_volumes.rs
• examples/shader/compute_shader_game_of_life.rs
• examples/window/custom_cursor_image.rs
• examples/2d/mesh2d_vertex_color_texture.rs
• examples/ecs/hierarchy.rs
• examples/3d/generate_custom_mesh.rs
• examples/stress_tests/many_sprites.rs
• examples/audio/spatial_audio_2d.rs
• examples/ui/relative_cursor_position.rs
• examples/ui/ui_material.rs
• examples/testbed/2d.rs
• examples/games/contributors.rs
• examples/ui/ui_scaling.rs
• examples/ui/ui_texture_atlas.rs
• examples/usage/cooldown.rs
• examples/window/multiple_windows.rs
• examples/stress_tests/many_animated_sprites.rs
• examples/2d/bloom_2d.rs
• examples/ui/ghost_nodes.rs
• examples/animation/animated_mesh_events.rs
• examples/animation/animated_ui.rs
• examples/asset/alter_sprite.rs
• examples/audio/spatial_audio_3d.rs
• examples/stress_tests/many_buttons.rs
• examples/shader/automatic_instancing.rs
• examples/camera/projection_zoom.rs
• examples/2d/rotation.rs
• examples/ui/ui_texture_slice.rs
• examples/camera/2d_on_ui.rs
• examples/3d/visibility_range.rs
• examples/2d/sprite_animation.rs
• examples/3d/volumetric_fog.rs
• examples/animation/animation_graph.rs
• examples/animation/animated_mesh_control.rs
• examples/3d/atmosphere.rs
• examples/3d/texture.rs
• examples/3d/motion_blur.rs
• examples/shader_advanced/custom_phase_item.rs
• examples/time/virtual_time.rs
• examples/shader_advanced/custom_post_processing.rs
• examples/ui/size_constraints.rs
• examples/3d/anti_aliasing.rs
• examples/ui/transparency_ui.rs
• examples/3d/manual_material.rs
• examples/transforms/align.rs
• examples/ui/ui_texture_atlas_slice.rs
• examples/picking/sprite_picking.rs
• examples/games/stepping.rs
• examples/3d/decal.rs
• examples/2d/mesh2d_alpha_mode.rs
• examples/2d/mesh2d_arcs.rs
• examples/asset/repeated_texture.rs
• examples/ui/text_wrap_debug.rs
• examples/games/alien_cake_addict.rs
• examples/asset/alter_mesh.rs
• examples/ui/text.rs
• examples/asset/asset_settings.rs
• examples/3d/meshlet.rs
• examples/2d/mesh2d_repeated_texture.rs
• examples/3d/pbr.rs
• examples/3d/auto_exposure.rs
• examples/asset/asset_loading.rs
• examples/ui/overflow.rs
• examples/ui/overflow_clip_margin.rs
• examples/ui/flex_layout.rs
• examples/shader/shader_prepass.rs
• examples/stress_tests/bevymark.rs
• examples/3d/solari.rs
• examples/ui/display_and_visibility.rs
• examples/3d/split_screen.rs
• examples/ui/scroll.rs
• examples/games/breakout.rs
• examples/stress_tests/many_foxes.rs
• examples/games/desk_toy.rs
• examples/3d/parallax_mapping.rs
• examples/2d/texture_atlas.rs
• examples/2d/sprite_scale.rs
• examples/3d/deferred_rendering.rs
• examples/ui/box_shadow.rs
• examples/2d/text2d.rs
• examples/animation/custom_skinned_mesh.rs
• examples/3d/blend_modes.rs
• examples/3d/lighting.rs
• examples/ui/text_debug.rs
• examples/ui/grid.rs
• examples/3d/transmission.rs
• examples/ui/ui_transform.rs
• examples/testbed/full_ui.rs

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

where A: Asset,

Same as load, but you can load assets from unapproved paths if AssetPlugin::unapproved_path_mode is Deny.

See UnapprovedPathMode and AssetPath::is_unapproved

pub fn load_acquire<'a, A, G>( &self, path: impl Into<AssetPath<'a>>, guard: G, ) -> Handle<A>

where A: Asset, G: Send + Sync + 'static,

Begins loading an Asset of type A stored at path while holding a guard item. The guard item is dropped when either the asset is loaded or loading has failed.

This function returns a “strong” Handle. When the Asset is loaded (and enters LoadState::Loaded), it will be added to the associated Assets resource.

The guard item should notify the caller in its Drop implementation. See example multi_asset_sync. Synchronously this can be a Arc<AtomicU32> that decrements its counter, asynchronously this can be a Barrier. This function only guarantees the asset referenced by the Handle is loaded. If your asset is separated into multiple files, sub-assets referenced by the main asset might still be loading, depend on the implementation of the AssetLoader.

Additionally, 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/multi_asset_sync.rs (line 147)

fn setup_assets(mut commands: Commands, asset_server: Res<AssetServer>) {
    let (barrier, guard) = AssetBarrier::new();
    commands.insert_resource(OneHundredThings(std::array::from_fn(|i| match i % 5 {
        0 => asset_server.load_acquire("models/GolfBall/GolfBall.glb", guard.clone()),
        1 => asset_server.load_acquire("models/AlienCake/alien.glb", guard.clone()),
        2 => asset_server.load_acquire("models/AlienCake/cakeBirthday.glb", guard.clone()),
        3 => asset_server.load_acquire("models/FlightHelmet/FlightHelmet.gltf", guard.clone()),
        4 => asset_server.load_acquire("models/torus/torus.gltf", guard.clone()),
        _ => unreachable!(),
    })));
    let future = barrier.wait_async();
    commands.insert_resource(barrier);

    let loading_state = Arc::new(AtomicBool::new(false));
    commands.insert_resource(AsyncLoadingState(loading_state.clone()));

    // await the `AssetBarrierFuture`.
    AsyncComputeTaskPool::get()
        .spawn(async move {
            future.await;
            // Notify via `AsyncLoadingState`
            loading_state.store(true, Ordering::Release);
        })
        .detach();
}

pub fn load_acquire_override<'a, A, G>( &self, path: impl Into<AssetPath<'a>>, guard: G, ) -> Handle<A>

where A: Asset, G: Send + Sync + 'static,

Same as load, but you can load assets from unapproved paths if AssetPlugin::unapproved_path_mode is Deny.

See UnapprovedPathMode and AssetPath::is_unapproved

pub fn load_with_settings<'a, A, S>( &self, path: impl Into<AssetPath<'a>>, settings: impl Fn(&mut S) + Send + Sync + 'static, ) -> Handle<A>

where A: Asset, S: Settings,

Begins loading an Asset of type A stored at path. The given settings function will override the asset’s AssetLoader settings. The type S must match the configured AssetLoader::Settings or settings changes will be ignored and an error will be printed to the log.

Examples found in repository

examples/3d/rotate_environment_map.rs (lines 72-75)

fn spawn_sphere(
    commands: &mut Commands,
    materials: &mut Assets<StandardMaterial>,
    asset_server: &AssetServer,
    sphere_mesh: &Handle<Mesh>,
) {
    commands.spawn((
        Mesh3d(sphere_mesh.clone()),
        MeshMaterial3d(materials.add(StandardMaterial {
            clearcoat: 1.0,
            clearcoat_perceptual_roughness: 0.3,
            clearcoat_normal_texture: Some(asset_server.load_with_settings(
                "textures/ScratchedGold-Normal.png",
                |settings: &mut ImageLoaderSettings| settings.is_srgb = false,
            )),
            metallic: 0.9,
            perceptual_roughness: 0.1,
            base_color: GOLD.into(),
            ..default()
        })),
        Transform::from_xyz(0.0, 0.0, 0.0).with_scale(Vec3::splat(1.25)),
    ));
}

examples/3d/clearcoat.rs (lines 105-108)

fn spawn_car_paint_sphere(
    commands: &mut Commands,
    materials: &mut Assets<StandardMaterial>,
    asset_server: &AssetServer,
    sphere: &Handle<Mesh>,
) {
    commands
        .spawn((
            Mesh3d(sphere.clone()),
            MeshMaterial3d(materials.add(StandardMaterial {
                clearcoat: 1.0,
                clearcoat_perceptual_roughness: 0.1,
                normal_map_texture: Some(asset_server.load_with_settings(
                    "textures/BlueNoise-Normal.png",
                    |settings: &mut ImageLoaderSettings| settings.is_srgb = false,
                )),
                metallic: 0.9,
                perceptual_roughness: 0.5,
                base_color: BLUE.into(),
                ..default()
            })),
            Transform::from_xyz(-1.0, 1.0, 0.0).with_scale(Vec3::splat(SPHERE_SCALE)),
        ))
        .insert(ExampleSphere);
}

/// Spawn a semitransparent object with a clearcoat layer.
fn spawn_coated_glass_bubble_sphere(
    commands: &mut Commands,
    materials: &mut Assets<StandardMaterial>,
    sphere: &Handle<Mesh>,
) {
    commands
        .spawn((
            Mesh3d(sphere.clone()),
            MeshMaterial3d(materials.add(StandardMaterial {
                clearcoat: 1.0,
                clearcoat_perceptual_roughness: 0.1,
                metallic: 0.5,
                perceptual_roughness: 0.1,
                base_color: Color::srgba(0.9, 0.9, 0.9, 0.3),
                alpha_mode: AlphaMode::Blend,
                ..default()
            })),
            Transform::from_xyz(-1.0, -1.0, 0.0).with_scale(Vec3::splat(SPHERE_SCALE)),
        ))
        .insert(ExampleSphere);
}

/// Spawns an object with both a clearcoat normal map (a scratched varnish) and
/// a main layer normal map (the golf ball pattern).
///
/// This object is in glTF format, using the `KHR_materials_clearcoat`
/// extension.
fn spawn_golf_ball(commands: &mut Commands, asset_server: &AssetServer) {
    commands.spawn((
        SceneRoot(
            asset_server.load(GltfAssetLabel::Scene(0).from_asset("models/GolfBall/GolfBall.glb")),
        ),
        Transform::from_xyz(1.0, 1.0, 0.0).with_scale(Vec3::splat(SPHERE_SCALE)),
        ExampleSphere,
    ));
}

/// Spawns an object with only a clearcoat normal map (a scratch pattern) and no
/// main layer normal map.
fn spawn_scratched_gold_ball(
    commands: &mut Commands,
    materials: &mut Assets<StandardMaterial>,
    asset_server: &AssetServer,
    sphere: &Handle<Mesh>,
) {
    commands
        .spawn((
            Mesh3d(sphere.clone()),
            MeshMaterial3d(materials.add(StandardMaterial {
                clearcoat: 1.0,
                clearcoat_perceptual_roughness: 0.3,
                clearcoat_normal_texture: Some(asset_server.load_with_settings(
                    "textures/ScratchedGold-Normal.png",
                    |settings: &mut ImageLoaderSettings| settings.is_srgb = false,
                )),
                metallic: 0.9,
                perceptual_roughness: 0.1,
                base_color: GOLD.into(),
                ..default()
            })),
            Transform::from_xyz(1.0, -1.0, 0.0).with_scale(Vec3::splat(SPHERE_SCALE)),
        ))
        .insert(ExampleSphere);
}

examples/testbed/3d.rs (lines 395-400)

    pub fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
        commands.spawn((
            Camera3d::default(),
            Transform::from_xyz(-4.0, 4.0, -5.0).looking_at(Vec3::ZERO, Vec3::Y),
            DespawnOnExit(CURRENT_SCENE),
        ));

        commands.spawn((
            DirectionalLight {
                color: BLUE.into(),
                ..default()
            },
            Transform::IDENTITY.looking_to(Dir3::Z, Dir3::Y),
            DespawnOnExit(CURRENT_SCENE),
        ));

        commands.spawn((
            DirectionalLight {
                color: RED.into(),
                ..default()
            },
            Transform::IDENTITY.looking_to(Dir3::X, Dir3::Y),
            DespawnOnExit(CURRENT_SCENE),
        ));

        commands.spawn((
            DirectionalLight {
                color: GREEN.into(),
                ..default()
            },
            Transform::IDENTITY.looking_to(Dir3::NEG_Y, Dir3::X),
            DespawnOnExit(CURRENT_SCENE),
        ));

        commands
            .spawn((
                SceneRoot(asset_server.load_with_settings(
                    GltfAssetLabel::Scene(0).from_asset("models/Faces/faces.glb"),
                    |s: &mut GltfLoaderSettings| {
                        s.use_model_forward_direction = Some(true);
                    },
                )),
                DespawnOnExit(CURRENT_SCENE),
            ))
            .observe(show_aabbs);
    }

examples/3d/deferred_rendering.rs (lines 220-225)

fn setup_parallax(
    mut commands: Commands,
    mut materials: ResMut<Assets<StandardMaterial>>,
    mut meshes: ResMut<Assets<Mesh>>,
    asset_server: Res<AssetServer>,
) {
    // The normal map. Note that to generate it in the GIMP image editor, you should
    // open the depth map, and do Filters → Generic → Normal Map
    // You should enable the "flip X" checkbox.
    let normal_handle = asset_server.load_with_settings(
        "textures/parallax_example/cube_normal.png",
        // The normal map texture is in linear color space. Lighting won't look correct
        // if `is_srgb` is `true`, which is the default.
        |settings: &mut ImageLoaderSettings| settings.is_srgb = false,
    );

    let mut cube = Mesh::from(Cuboid::new(0.15, 0.15, 0.15));

    // NOTE: for normal maps and depth maps to work, the mesh
    // needs tangents generated.
    cube.generate_tangents().unwrap();

    let parallax_material = materials.add(StandardMaterial {
        perceptual_roughness: 0.4,
        base_color_texture: Some(asset_server.load("textures/parallax_example/cube_color.png")),
        normal_map_texture: Some(normal_handle),
        // The depth map is a grayscale texture where black is the highest level and
        // white the lowest.
        depth_map: Some(asset_server.load("textures/parallax_example/cube_depth.png")),
        parallax_depth_scale: 0.09,
        parallax_mapping_method: ParallaxMappingMethod::Relief { max_steps: 4 },
        max_parallax_layer_count: ops::exp2(5.0f32),
        ..default()
    });
    commands.spawn((
        Mesh3d(meshes.add(cube)),
        MeshMaterial3d(parallax_material),
        Transform::from_xyz(0.4, 0.2, -0.8),
        Spin { speed: 0.3 },
    ));
}

examples/3d/ssr.rs (lines 195-207)

fn spawn_water(
    commands: &mut Commands,
    asset_server: &AssetServer,
    meshes: &mut Assets<Mesh>,
    water_materials: &mut Assets<ExtendedMaterial<StandardMaterial, Water>>,
) {
    commands.spawn((
        Mesh3d(meshes.add(Plane3d::new(Vec3::Y, Vec2::splat(1.0)))),
        MeshMaterial3d(water_materials.add(ExtendedMaterial {
            base: StandardMaterial {
                base_color: BLACK.into(),
                perceptual_roughness: 0.0,
                ..default()
            },
            extension: Water {
                normals: asset_server.load_with_settings::<Image, ImageLoaderSettings>(
                    "textures/water_normals.png",
                    |settings| {
                        settings.is_srgb = false;
                        settings.sampler = ImageSampler::Descriptor(ImageSamplerDescriptor {
                            address_mode_u: ImageAddressMode::Repeat,
                            address_mode_v: ImageAddressMode::Repeat,
                            mag_filter: ImageFilterMode::Linear,
                            min_filter: ImageFilterMode::Linear,
                            ..default()
                        });
                    },
                ),
                // These water settings are just random values to create some
                // variety.
                settings: WaterSettings {
                    octave_vectors: [
                        vec4(0.080, 0.059, 0.073, -0.062),
                        vec4(0.153, 0.138, -0.149, -0.195),
                    ],
                    octave_scales: vec4(1.0, 2.1, 7.9, 14.9) * 5.0,
                    octave_strengths: vec4(0.16, 0.18, 0.093, 0.044),
                },
            },
        })),
        Transform::from_scale(Vec3::splat(100.0)),
    ));
}

examples/asset/alter_sprite.rs (lines 53-70)

fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
    let bird_left = Bird::Normal;
    let bird_right = Bird::Normal;
    commands.spawn(Camera2d);

    let texture_left = asset_server.load_with_settings(
        bird_left.get_texture_path(),
        // `RenderAssetUsages::all()` is already the default, so the line below could be omitted.
        // It's helpful to know it exists, however.
        //
        // `RenderAssetUsages` tell Bevy whether to keep the data around:
        //   - for the GPU (`RenderAssetUsages::RENDER_WORLD`),
        //   - for the CPU (`RenderAssetUsages::MAIN_WORLD`),
        //   - or both.
        // `RENDER_WORLD` is necessary to render the image, `MAIN_WORLD` is necessary to inspect
        // and modify the image (via `ResMut<Assets<Image>>`).
        //
        // Since most games will not need to modify textures at runtime, many developers opt to pass
        // only `RENDER_WORLD`. This is more memory efficient, as we don't need to keep the image in
        // RAM. For this example however, this would not work, as we need to inspect and modify the
        // image at runtime.
        |settings: &mut ImageLoaderSettings| settings.asset_usage = RenderAssetUsages::all(),
    );

    commands.spawn((
        Name::new("Bird Left"),
        // This marker component ensures we can easily find either of the Birds by using With and
        // Without query filters.
        Left,
        Sprite::from_image(texture_left),
        Transform::from_xyz(-200.0, 0.0, 0.0),
        bird_left,
    ));

    commands.spawn((
        Name::new("Bird Right"),
        // In contrast to the above, here we rely on the default `RenderAssetUsages` loader setting
        Sprite::from_image(asset_server.load(bird_right.get_texture_path())),
        Transform::from_xyz(200.0, 0.0, 0.0),
        bird_right,
    ));
}

Additional examples can be found in:

• examples/ui/ui_texture_slice_flip_and_tile.rs
• examples/3d/scrolling_fog.rs
• examples/asset/repeated_texture.rs
• examples/asset/alter_mesh.rs
• examples/asset/asset_settings.rs
• examples/2d/mesh2d_repeated_texture.rs
• examples/3d/parallax_mapping.rs

pub fn load_with_settings_override<'a, A, S>( &self, path: impl Into<AssetPath<'a>>, settings: impl Fn(&mut S) + Send + Sync + 'static, ) -> Handle<A>

where A: Asset, S: Settings,

Same as load, but you can load assets from unapproved paths if AssetPlugin::unapproved_path_mode is Deny.

See UnapprovedPathMode and AssetPath::is_unapproved

pub fn load_acquire_with_settings<'a, A, S, G>( &self, path: impl Into<AssetPath<'a>>, settings: impl Fn(&mut S) + Send + Sync + 'static, guard: G, ) -> Handle<A>

where A: Asset, S: Settings, G: Send + Sync + 'static,

Begins loading an Asset of type A stored at path while holding a guard item. The guard item is dropped when either the asset is loaded or loading has failed.

This function only guarantees the asset referenced by the Handle is loaded. If your asset is separated into multiple files, sub-assets referenced by the main asset might still be loading, depend on the implementation of the AssetLoader.

The given settings function will override the asset’s AssetLoader settings. The type S must match the configured AssetLoader::Settings or settings changes will be ignored and an error will be printed to the log.

pub fn load_acquire_with_settings_override<'a, A, S, G>( &self, path: impl Into<AssetPath<'a>>, settings: impl Fn(&mut S) + Send + Sync + 'static, guard: G, ) -> Handle<A>

where A: Asset, S: Settings, G: Send + Sync + 'static,

Same as load, but you can load assets from unapproved paths if AssetPlugin::unapproved_path_mode is Deny.

See UnapprovedPathMode and AssetPath::is_unapproved

pub async fn load_untyped_async<'a>( &self, path: impl Into<AssetPath<'a>>, ) -> Result<UntypedHandle, AssetLoadError>

Asynchronously load an asset that you do not know the type of statically. If you do know the type of the asset, you should use AssetServer::load. If you don’t know the type of the asset, but you can’t use an async method, consider using AssetServer::load_untyped.

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

Load an asset without knowing its type. The method returns a handle to a LoadedUntypedAsset.

Once the LoadedUntypedAsset is loaded, an untyped handle for the requested path can be retrieved from it.

use bevy_asset::{Assets, Handle, LoadedUntypedAsset};
use bevy_ecs::system::Res;
use bevy_ecs::resource::Resource;

#[derive(Resource)]
struct LoadingUntypedHandle(Handle<LoadedUntypedAsset>);

fn resolve_loaded_untyped_handle(loading_handle: Res<LoadingUntypedHandle>, loaded_untyped_assets: Res<Assets<LoadedUntypedAsset>>) {
    if let Some(loaded_untyped_asset) = loaded_untyped_assets.get(&loading_handle.0) {
        let handle = loaded_untyped_asset.handle.clone();
        // continue working with `handle` which points to the asset at the originally requested path
    }
}

This indirection enables a non blocking load of an untyped asset, since I/O is required to figure out the asset type before a handle can be created.

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.

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)

fn decompress<T: Component + From<Handle<A>>, A: Asset>(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    mut compressed_assets: ResMut<Assets<GzAsset>>,
    query: Query<(Entity, &Compressed<A>)>,
) {
    for (entity, Compressed { compressed, .. }) in query.iter() {
        let Some(GzAsset { uncompressed }) = compressed_assets.remove(compressed) else {
            continue;
        };

        let uncompressed = uncompressed.take::<A>().unwrap();

        commands
            .entity(entity)
            .remove::<Compressed<A>>()
            .insert(T::from(asset_server.add(uncompressed)));
    }
}

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

fn setup(mut commands: Commands, asset_server: Res<AssetServer>, app_status: Res<AppStatus>) {
    commands.spawn((
        Camera3d::default(),
        Transform::from_translation(CAMERA_INITIAL_POSITION).looking_at(Vec3::ZERO, Vec3::Y),
    ));

    spawn_directional_light(&mut commands);

    commands.spawn((
        SceneRoot(asset_server.load("models/AnisotropyBarnLamp/AnisotropyBarnLamp.gltf#Scene0")),
        Transform::from_xyz(0.0, 0.07, -0.13),
        Scene::BarnLamp,
    ));

    commands.spawn((
        Mesh3d(
            asset_server.add(
                Mesh::from(Sphere::new(0.1))
                    .with_generated_tangents()
                    .unwrap(),
            ),
        ),
        MeshMaterial3d(asset_server.add(StandardMaterial {
            base_color: palettes::tailwind::GRAY_300.into(),
            anisotropy_rotation: 0.5,
            anisotropy_strength: 1.,
            ..default()
        })),
        Scene::Sphere,
        Visibility::Hidden,
    ));

    spawn_text(&mut commands, &app_status);
}

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.

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)

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

examples/asset/asset_loading.rs (line 55)

fn setup(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    meshes: Res<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    // By default AssetServer will load assets from inside the "assets" folder.
    // For example, the next line will load GltfAssetLabel::Primitive{mesh:0,primitive:0}.from_asset("ROOT/assets/models/cube/cube.gltf"),
    // where "ROOT" is the directory of the Application.
    //
    // This can be overridden by setting [`AssetPlugin.file_path`].
    let cube_handle = asset_server.load(
        GltfAssetLabel::Primitive {
            mesh: 0,
            primitive: 0,
        }
        .from_asset("models/cube/cube.gltf"),
    );
    let sphere_handle = asset_server.load(
        GltfAssetLabel::Primitive {
            mesh: 0,
            primitive: 0,
        }
        .from_asset("models/sphere/sphere.gltf"),
    );

    // All assets end up in their Assets<T> collection once they are done loading:
    if let Some(sphere) = meshes.get(&sphere_handle) {
        // You might notice that this doesn't run! This is because assets load in parallel without
        // blocking. When an asset has loaded, it will appear in relevant Assets<T>
        // collection.
        info!("{:?}", sphere.primitive_topology());
    } else {
        info!("sphere hasn't loaded yet");
    }

    // You can load all assets in a folder like this. They will be loaded in parallel without
    // blocking. The LoadedFolder asset holds handles to each asset in the folder. These are all
    // dependencies of the LoadedFolder asset, meaning you can wait for the LoadedFolder asset to
    // fire AssetEvent::LoadedWithDependencies if you want to wait for all assets in the folder
    // to load.
    // If you want to keep the assets in the folder alive, make sure you store the returned handle
    // somewhere.
    let _loaded_folder: Handle<LoadedFolder> = asset_server.load_folder("models/torus");

    // If you want a handle to a specific asset in a loaded folder, the easiest way to get one is to call load.
    // It will _not_ be loaded a second time.
    // The LoadedFolder asset will ultimately also hold handles to the assets, but waiting for it to load
    // and finding the right handle is more work!
    let torus_handle = asset_server.load(
        GltfAssetLabel::Primitive {
            mesh: 0,
            primitive: 0,
        }
        .from_asset("models/torus/torus.gltf"),
    );

    // You can also add assets directly to their Assets<T> storage:
    let material_handle = materials.add(StandardMaterial {
        base_color: Color::srgb(0.8, 0.7, 0.6),
        ..default()
    });

    // torus
    commands.spawn((
        Mesh3d(torus_handle),
        MeshMaterial3d(material_handle.clone()),
        Transform::from_xyz(-3.0, 0.0, 0.0),
    ));
    // cube
    commands.spawn((
        Mesh3d(cube_handle),
        MeshMaterial3d(material_handle.clone()),
        Transform::from_xyz(0.0, 0.0, 0.0),
    ));
    // sphere
    commands.spawn((
        Mesh3d(sphere_handle),
        MeshMaterial3d(material_handle),
        Transform::from_xyz(3.0, 0.0, 0.0),
    ));
    // light
    commands.spawn((PointLight::default(), Transform::from_xyz(4.0, 5.0, 4.0)));
    // camera
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(0.0, 3.0, 10.0).looking_at(Vec3::ZERO, Vec3::Y),
    ));
}

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

Retrieves all loads states for the given asset id.

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/scene.rs (line 231)

fn panic_on_fail(scenes: Query<&DynamicSceneRoot>, asset_server: Res<AssetServer>) {
    for scene in &scenes {
        if let Some(LoadState::Failed(err)) = asset_server.get_load_state(&scene.0) {
            panic!("Failed to load scene. {err}");
        }
    }
}

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.

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/games/loading_screen.rs (line 209)

fn update_loading_data(
    mut loading_data: ResMut<LoadingData>,
    mut loading_state: ResMut<LoadingState>,
    asset_server: Res<AssetServer>,
    pipelines_ready: Res<PipelinesReady>,
) {
    if !loading_data.loading_assets.is_empty() || !pipelines_ready.0 {
        // If we are still loading assets / pipelines are not fully compiled,
        // we reset the confirmation frame count.
        loading_data.confirmation_frames_count = 0;

        loading_data.loading_assets.retain(|asset| {
            asset_server
                .get_recursive_dependency_load_state(asset)
                .is_none_or(|state| !state.is_loaded())
        });

        // If there are no more assets being monitored, and pipelines
        // are compiled, then start counting confirmation frames.
        // Once enough confirmations have passed, everything will be
        // considered to be fully loaded.
    } else {
        loading_data.confirmation_frames_count += 1;
        if loading_data.confirmation_frames_count == loading_data.confirmation_frames_target {
            *loading_state = LoadingState::LevelReady;
        }
    }
}

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)

fn environment_map_load_finish(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    environment_map: Single<&EnvironmentMapLight>,
    label_entity: Option<Single<Entity, With<EnvironmentMapLabel>>>,
) {
    if asset_server
        .load_state(&environment_map.diffuse_map)
        .is_loaded()
        && asset_server
            .load_state(&environment_map.specular_map)
            .is_loaded()
    {
        // Do not attempt to remove `label_entity` if it has already been removed.
        if let Some(label_entity) = label_entity {
            commands.entity(*label_entity).despawn();
        }
    }
}

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

fn asset_loaded(
    asset_server: Res<AssetServer>,
    mut images: ResMut<Assets<Image>>,
    mut cubemap: ResMut<Cubemap>,
    mut skyboxes: Query<&mut Skybox>,
) {
    if !cubemap.is_loaded && asset_server.load_state(&cubemap.image_handle).is_loaded() {
        info!("Swapping to {}...", CUBEMAPS[cubemap.index].0);
        let image = images.get_mut(&cubemap.image_handle).unwrap();
        // NOTE: PNGs do not have any metadata that could indicate they contain a cubemap texture,
        // so they appear as one texture. The following code reconfigures the texture as necessary.
        if image.texture_descriptor.array_layer_count() == 1 {
            image.reinterpret_stacked_2d_as_array(image.height() / image.width());
            image.texture_view_descriptor = Some(TextureViewDescriptor {
                dimension: Some(TextureViewDimension::Cube),
                ..default()
            });
        }

        for mut skybox in &mut skyboxes {
            skybox.image = cubemap.image_handle.clone();
        }

        cubemap.is_loaded = true;
    }
}

examples/shader/array_texture.rs (line 58)

fn create_array_texture(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    mut loading_texture: ResMut<LoadingTexture>,
    mut images: ResMut<Assets<Image>>,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<ArrayTextureMaterial>>,
) {
    if loading_texture.is_loaded
        || !asset_server
            .load_state(loading_texture.handle.id())
            .is_loaded()
    {
        return;
    }
    loading_texture.is_loaded = true;
    let image = images.get_mut(&loading_texture.handle).unwrap();

    // Create a new array texture asset from the loaded texture.
    let array_layers = 4;
    image.reinterpret_stacked_2d_as_array(array_layers);

    // Spawn some cubes using the array texture
    let mesh_handle = meshes.add(Cuboid::default());
    let material_handle = materials.add(ArrayTextureMaterial {
        array_texture: loading_texture.handle.clone(),
    });
    for x in -5..=5 {
        commands.spawn((
            Mesh3d(mesh_handle.clone()),
            MeshMaterial3d(material_handle.clone()),
            Transform::from_xyz(x as f32 + 0.5, 0.0, 0.0),
        ));
    }
}

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.

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.

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

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

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.

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.

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)

fn setup(
    mut commands: Commands,
    rpg_sprite_handles: Res<RpgSpriteFolder>,
    asset_server: Res<AssetServer>,
    mut texture_atlases: ResMut<Assets<TextureAtlasLayout>>,
    loaded_folders: Res<Assets<LoadedFolder>>,
    mut textures: ResMut<Assets<Image>>,
) {
    let loaded_folder = loaded_folders.get(&rpg_sprite_handles.0).unwrap();

    // Create texture atlases with different padding and sampling

    let (texture_atlas_linear, linear_sources, linear_texture) = create_texture_atlas(
        loaded_folder,
        None,
        Some(ImageSampler::linear()),
        &mut textures,
    );
    let atlas_linear_handle = texture_atlases.add(texture_atlas_linear);

    let (texture_atlas_nearest, nearest_sources, nearest_texture) = create_texture_atlas(
        loaded_folder,
        None,
        Some(ImageSampler::nearest()),
        &mut textures,
    );
    let atlas_nearest_handle = texture_atlases.add(texture_atlas_nearest);

    let (texture_atlas_linear_padded, linear_padded_sources, linear_padded_texture) =
        create_texture_atlas(
            loaded_folder,
            Some(UVec2::new(6, 6)),
            Some(ImageSampler::linear()),
            &mut textures,
        );
    let atlas_linear_padded_handle = texture_atlases.add(texture_atlas_linear_padded.clone());

    let (texture_atlas_nearest_padded, nearest_padded_sources, nearest_padded_texture) =
        create_texture_atlas(
            loaded_folder,
            Some(UVec2::new(6, 6)),
            Some(ImageSampler::nearest()),
            &mut textures,
        );
    let atlas_nearest_padded_handle = texture_atlases.add(texture_atlas_nearest_padded);

    commands.spawn(Camera2d);

    // Padded textures are to the right, unpadded to the left

    // Draw unpadded texture atlas
    commands.spawn((
        Sprite::from_image(linear_texture.clone()),
        Transform {
            translation: Vec3::new(-250.0, -160.0, 0.0),
            scale: Vec3::splat(0.5),
            ..default()
        },
    ));

    // Draw padded texture atlas
    commands.spawn((
        Sprite::from_image(linear_padded_texture.clone()),
        Transform {
            translation: Vec3::new(250.0, -160.0, 0.0),
            scale: Vec3::splat(0.5),
            ..default()
        },
    ));

    let font = asset_server.load("fonts/FiraSans-Bold.ttf");

    // Padding label text style
    let text_style: TextFont = TextFont {
        font: font.clone(),
        font_size: 42.0,
        ..default()
    };

    // Labels to indicate padding

    // No padding
    create_label(
        &mut commands,
        (-250.0, 250.0, 0.0),
        "No padding",
        text_style.clone(),
    );

    // Padding
    create_label(&mut commands, (250.0, 250.0, 0.0), "Padding", text_style);

    // Get handle to a sprite to render
    let vendor_handle: Handle<Image> = asset_server
        .get_handle("textures/rpg/chars/vendor/generic-rpg-vendor.png")
        .unwrap();

    // Configuration array to render sprites through iteration
    let configurations: [(
        &str,
        Handle<TextureAtlasLayout>,
        TextureAtlasSources,
        Handle<Image>,
        f32,
    ); 4] = [
        (
            "Linear",
            atlas_linear_handle,
            linear_sources,
            linear_texture,
            -350.0,
        ),
        (
            "Nearest",
            atlas_nearest_handle,
            nearest_sources,
            nearest_texture,
            -150.0,
        ),
        (
            "Linear",
            atlas_linear_padded_handle,
            linear_padded_sources,
            linear_padded_texture,
            150.0,
        ),
        (
            "Nearest",
            atlas_nearest_padded_handle,
            nearest_padded_sources,
            nearest_padded_texture,
            350.0,
        ),
    ];

    // Label text style
    let sampling_label_style = TextFont {
        font,
        font_size: 25.0,
        ..default()
    };

    let base_y = 80.0; // y position of the sprites

    for (sampling, atlas_handle, atlas_sources, atlas_texture, x) in configurations {
        // Render a sprite from the texture_atlas
        create_sprite_from_atlas(
            &mut commands,
            (x, base_y, 0.0),
            atlas_texture,
            atlas_sources,
            atlas_handle,
            &vendor_handle,
        );

        // Render a label to indicate the sampling setting
        create_label(
            &mut commands,
            (x, base_y + 110.0, 0.0), // Offset to y position of the sprite
            sampling,
            sampling_label_style.clone(),
        );
    }
}

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.

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

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

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.

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.

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.

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.

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.

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”.

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)

fn name_morphs(
    asset_server: Res<AssetServer>,
    mut events: MessageReader<AssetEvent<Mesh>>,
    meshes: Res<Assets<Mesh>>,
) {
    for event in events.read() {
        if let AssetEvent::<Mesh>::Added { id } = event
            && let Some(path) = asset_server.get_path(*id)
            && let Some(mesh) = meshes.get(*id)
            && let Some(names) = mesh.morph_target_names()
        {
            info!("Morph target names for {path:?}:");

            for name in names {
                info!("  {name}");
            }
        }
    }
}

pub fn mode(&self) -> AssetServerMode

Returns the AssetServerMode this server is currently in.

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.

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.

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.

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.

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

impl Clone for AssetServer

fn clone(&self) -> AssetServer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AssetServer

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

Formats the value using the given formatter.

impl GetAssetServer for AssetServer

fn get_asset_server(&self) -> &AssetServer

impl Resource for AssetServer

where AssetServer: Send + Sync + 'static,