Struct BuiltInResource 

pub struct BuiltInResource<T>
where
    T: TypedResourceData,
{
    pub id: PathBuf,
    pub data_source: Option<DataSource>,
    pub resource: Resource<T>,
}

Built-in resource is a resource embedded in the application executable file. It is a very useful mechanism when you need to bundle all game resources and put them in the executable file.

Registration

Every built-in resource must be registered in a resource manager to be accessible via standard crate::manager::ResourceManager::request method. It could be done pretty easily:

use fyrox_resource::{
    builtin::BuiltInResource,
    core::{reflect::prelude::*, type_traits::prelude::*, visitor::prelude::*, Uuid},
    manager::ResourceManager,
    Resource, ResourceData,
};
use std::{error::Error, path::Path};

#[derive(TypeUuidProvider, Default, Debug, Clone, Visit, Reflect)]
#[type_uuid(id = "00d036bb-fbed-47f7-94e3-b3fce93dee17")]
struct MyResource {
    some_data: String,
}

impl ResourceData for MyResource {
    fn type_uuid(&self) -> Uuid {
        <Self as TypeUuidProvider>::type_uuid()
    }

    fn save(&mut self, _path: &Path) -> Result<(), Box<dyn Error>> {
        Ok(())
    }

    fn can_be_saved(&self) -> bool {
        false
    }

    fn try_clone_box(&self) -> Option<Box<dyn ResourceData>> {
        Some(Box::new(self.clone()))
    }
}

fn register_built_in_resource(resource_manager: &ResourceManager) {
    let id = "MyResourceId";
    let some_data = "This string is a built-in resource with MyResourceId id.";

    let resource = Resource::new_embedded(MyResource {
        some_data: some_data.into(),
    });

    resource_manager.register_built_in_resource(BuiltInResource::new_no_source(id, resource));

    assert_eq!(
        resource_manager
            .request::<MyResource>(id)
            .data_ref()
            .some_data,
        some_data,
    )
}

Fields

id: PathBuf

Id of the built-in resource.

data_source: Option<DataSource>

Initial data, from which the resource is created from.

resource: Resource<T>

Ready-to-use (“loaded”) resource.

Implementations

impl<T: TypedResourceData> BuiltInResource<T>

pub fn new<F>(id: impl AsRef<Path>, data_source: DataSource, make: F) -> Self

where F: FnOnce(&[u8]) -> Resource<T>,

Creates a new built-in resource with an id, a data source and function that creates the resource from the given data source.

pub fn new_no_source(id: impl AsRef<Path>, resource: Resource<T>) -> Self

Creates a new built-in resource from an id and arbitrary resource.

pub fn resource(&self) -> Resource<T>

Returns the wrapped resource instance.

Trait Implementations

impl<T: TypedResourceData> Clone for BuiltInResource<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: TypedResourceData> From<BuiltInResource<T>> for UntypedBuiltInResource

fn from(value: BuiltInResource<T>) -> Self

Converts to this type from the input type.