Struct minecraft_assets::api::AssetPack

pub struct AssetPack { /* fields omitted */ }

Top-level API for accessing Minecraft assets.

Implementations

impl AssetPack

pub fn at_path(root_dir: impl AsRef<Path>) -> Self

Returns a new AssetPack that can read data from the given directory.

The provided root_dir should be the directory that contains the assets/ and/or data/ directories.

Example

use minecraft_assets::api::AssetPack;

let assets = AssetPack::at_path("~/.minecraft/");

// Load the block states for `oak_planks`
let states = assets.load_blockstates("oak_planks").unwrap();
let variants = states.variants().unwrap();

assert_eq!(variants.len(), 1);

let model_properties = &variants[""].models()[0];
assert_eq!(model_properties.model, "block/oak_planks");

pub fn new<P>(provider: P) -> Self where
    P: ResourceProvider + 'static, 

Returns a new AssetPack that uses the given ResourceProvider.

pub fn load_blockstates(&self, block_id: &str) -> Result<BlockStates>

Loads the BlockStates of the block with the provided id.

Example

let states = assets.load_blockstates("stone");
let states = assets.load_blockstates("minecraft:dirt");

pub fn load_block_model(&self, model: &str) -> Result<Model>

Loads the block Model identified by the given name or path.

Example

let model = assets.load_block_model("stone");
let model = assets.load_block_model("block/dirt");

pub fn load_block_model_recursive(&self, model: &str) -> Result<Vec<Model>>

Loads the block Model identified by the given name or path, as well as all of its parents and ancestors.

The models are returned as a list, with the first element being the model that was originally requested, the next element being its parent, and so on with the last element being the topmost parent.

Example

let models = assets.load_block_model_recursive("block/cube_all").unwrap();

let expected = vec![
    assets.load_block_model("block/cube_all").unwrap(),
    assets.load_block_model("block/cube").unwrap(),
    assets.load_block_model("block/block").unwrap(),
];
assert_eq!(models, expected);

pub fn load_item_model(&self, model: &str) -> Result<Model>

Loads the item Model identified by the given name or path.

Example

let model = assets.load_item_model("compass");
let model = assets.load_item_model("item/diamond_hoe");

pub fn load_item_model_recursive(&self, model: &str) -> Result<Vec<Model>>

Loads the item Model identified by the given name or path, as well as all of its parents and ancestors.

The models are returned as a list, with the first element being the model that was originally requested, the next element being its parent, and so on with the last element being the topmost parent.

Example

let models = assets.load_item_model_recursive("item/diamond_hoe").unwrap();

let expected = vec![
    assets.load_item_model("item/diamond_hoe").unwrap(),
    assets.load_item_model("item/handheld").unwrap(),
    assets.load_item_model("item/generated").unwrap(),
];
assert_eq!(models, expected);

Trait Implementations

impl Deref for AssetPack

type Target = dyn ResourceProvider

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.