Struct AssetPlugin 

pub struct AssetPlugin {
    pub file_path: String,
    pub processed_file_path: String,
    pub watch_for_changes_override: Option<bool>,
    pub mode: AssetMode,
    pub meta_check: AssetMetaCheck,
    pub unapproved_path_mode: UnapprovedPathMode,
}

Provides “asset” loading and processing functionality. An Asset is a “runtime value” that is loaded from an AssetSource, which can be something like a filesystem, a network, etc.

Supports flexible “modes”, such as AssetMode::Processed and AssetMode::Unprocessed that enable using the asset workflow that best suits your project.

Fields

file_path: String

The default file path to use (relative to the project root) for unprocessed assets.

processed_file_path: String

The default file path to use (relative to the project root) for processed assets.

watch_for_changes_override: Option<bool>

If set, will override the default “watch for changes” setting. By default “watch for changes” will be false unless the watch cargo feature is set. watch can be enabled manually, or it will be automatically enabled if a specific watcher like file_watcher is enabled.

Most use cases should leave this set to None and enable a specific watcher feature such as file_watcher to enable watching for dev-scenarios.

mode: AssetMode

The AssetMode to use for this server.

meta_check: AssetMetaCheck

How/If asset meta files should be checked.

unapproved_path_mode: UnapprovedPathMode

How to handle load requests of files that are outside the approved directories.

Approved folders are AssetPlugin::file_path and the folder of each AssetSource. Subfolders within these folders are also valid.

Trait Implementations

impl Default for AssetPlugin

fn default() -> Self

Returns the “default value” for a type.

impl Plugin for AssetPlugin

fn build(&self, app: &mut App)

Configures the App to which this plugin is added.

fn ready(&self, _app: &App) -> bool

Has the plugin finished its setup? This can be useful for plugins that need something asynchronous to happen before they can finish their setup, like the initialization of a renderer. Once the plugin is ready, finish should be called.

fn finish(&self, _app: &mut App)

Finish adding this plugin to the App, once all plugins registered are ready. This can be useful for plugins that depends on another plugin asynchronous setup, like the renderer.

fn cleanup(&self, _app: &mut App)

Runs after all plugins are built and finished, but before the app schedule is executed. This can be useful if you have some resource that other plugins need during their build step, but after build you want to remove it and send it to another thread.

fn name(&self) -> &str

Configures a name for the Plugin which is primarily used for checking plugin uniqueness and debugging.

fn is_unique(&self) -> bool

If the plugin can be meaningfully instantiated several times in an App, override this method to return false.