Struct Assets 

pub struct Assets {

    pub map_sources: FxHashMap<String, String>,
    pub maps: FxHashMap<String, Map>,
    pub entities: FxHashMap<String, (String, String)>,
    pub items: FxHashMap<String, (String, String)>,
    pub tiles: IndexMap<Uuid, Tile>,
    pub materials: FxHashMap<Uuid, Tile>,
    pub textures: FxHashMap<String, Texture>,
    pub tile_list: Vec<Tile>,
    pub tile_indices: FxHashMap<Uuid, u16>,
    pub screens: FxHashMap<String, Map>,
    pub character_maps: FxHashMap<String, Map>,
    pub entity_tiles: FxHashMap<u32, IndexMap<String, Tile>>,
    pub item_maps: FxHashMap<String, Map>,
    pub item_tiles: FxHashMap<u32, IndexMap<String, Tile>>,
    pub config: String,
    pub atlas: Texture,
    pub fonts: FxHashMap<String, Font>,
    pub audio: FxHashMap<String, Vec<u8>>,
    pub palette: ThePalette,
    pub global: ShapeFXGraph,
    pub locales: FxHashMap<String, FxHashMap<String, String>>,
    pub avatars: FxHashMap<String, Avatar>,
}

Fields

map_sources: FxHashMap<String, String>

maps: FxHashMap<String, Map>

entities: FxHashMap<String, (String, String)>

items: FxHashMap<String, (String, String)>

tiles: IndexMap<Uuid, Tile>

materials: FxHashMap<Uuid, Tile>

textures: FxHashMap<String, Texture>

tile_list: Vec<Tile>

tile_indices: FxHashMap<Uuid, u16>

screens: FxHashMap<String, Map>

character_maps: FxHashMap<String, Map>

Maps which build character tiles.

entity_tiles: FxHashMap<u32, IndexMap<String, Tile>>

The rendered tiles for a given entity.

item_maps: FxHashMap<String, Map>

Maps which build item tiles.

item_tiles: FxHashMap<u32, IndexMap<String, Tile>>

The rendered tiles for a given item.

config: String

atlas: Texture

fonts: FxHashMap<String, Font>

audio: FxHashMap<String, Vec<u8>>

palette: ThePalette

global: ShapeFXGraph

locales: FxHashMap<String, FxHashMap<String, String>>

A map of locale names to their translations.

avatars: FxHashMap<String, Avatar>

The avatars

Implementations

impl Assets

pub fn new() -> Self

pub fn read_locales(&mut self)

Reads all locale tables (locale_*) from the config file.

pub fn clean_tile_list(&mut self)

Clears the tile list.

pub fn tile_index(&self, id: &Uuid) -> Option<u16>

Returns the index into the tile_list for the given Tile Id

pub fn set_tiles(&mut self, tiles: IndexMap<Uuid, Tile>)

Set the tiles and atlas from a list of RGBA tiles.

pub fn set_materials(&mut self, materials: FxHashMap<Uuid, Map>)

Compile the materials.

pub fn blocking_tiles(&self) -> FxHashSet<Uuid>

Returns an FxHashSet of Uuid representing the blocking tiles and materials.

pub fn collect_from_directory(&mut self, dir_path: String)

Collects the assets from a directory.

Examples found in repository

examples/minigame.rs (line 24)

    fn new() -> Self
    where
        Self: Sized,
    {
        let mut assets = Assets::default();
        assets.collect_from_directory("minigame".to_string());
        // assets.compile_source_maps();

        let mut rusterix = Rusterix::default();
        rusterix.set_assets(assets);
        rusterix.create_regions();

        let camera = Box::new(D3FirstPCamera::new());
        rusterix.client.set_camera_d3(camera);

        // if let Some(map) = rusterix.assets.get_map("world") {
        //     // Build the 3D scene from the map meta data
        //     rusterix
        //         .client
        //         .build_scene_d3(map, &rusterix.assets, &ValueContainer::default());
        // }

        // Add logo on top of the scene
        rusterix.client.scene_d3.d2_static = vec![
            Batch2D::from_rectangle(0.0, 0.0, 200.0, 200.0)
                .receives_light(false)
                .source(PixelSource::StaticTileIndex(0)),
        ];
        // rusterix
        //     .client
        //     .scene_d3
        //     .textures
        //     .push(Tile::from_texture(Texture::from_image(Path::new(
        //         "images/logo.png",
        //     ))));

        Self { rusterix }
    }

pub fn get_map(&self, name: &str) -> Option<&Map>

Get a map by name.

Examples found in repository

examples/minigame.rs (line 65)

    fn draw(&mut self, pixels: &mut [u8], ctx: &mut TheContext) {
        let _start = get_time();

        // Update the entities on the server.
        self.rusterix.server.update(&mut self.rusterix.assets);

        if let Some(mut map) = self.rusterix.assets.get_map("world").cloned() {
            self.rusterix.server.apply_entities_items(&mut map);
            self.rusterix.build_entities_items_d3(&map);

            self.rusterix
                .draw_scene(&map, pixels, ctx.width, ctx.height);
        }

        let _stop = get_time();
        println!("Execution time: {:?} ms.", _stop - _start);
    }

pub fn add_entity(&mut self, name: String, code: String, data: String)

Add an entity.

pub fn textures(self, textures: Vec<Tile>) -> Self

Sets textures using the builder pattern.

Examples found in repository

examples/obj.rs (lines 46-48)

    fn new() -> Self
    where
        Self: Sized,
    {
        let scene = Scene::from_static(
            vec![Batch2D::from_rectangle(0.0, 0.0, 200.0, 200.0)],
            vec![
                Batch3D::from_obj(Path::new("examples/teapot.obj"))
                    .source(PixelSource::StaticTileIndex(0))
                    .repeat_mode(RepeatMode::RepeatXY)
                    .transform(Mat4::scaling_3d(Vec3::new(0.35, -0.35, 0.35)))
                    .with_computed_normals(),
            ],
        )
        .lights(vec![
            Light::new(LightType::Point)
                .with_intensity(1.0)
                .with_color([1.0, 1.0, 0.95])
                .compile(),
        ])
        .background(Box::new(VGrayGradientShader::new()));

        let assets = Assets::default().textures(vec![Tile::from_texture(Texture::from_image(
            Path::new("images/logo.png"),
        ))]);

        let mut camera = D3OrbitCamera::new();
        camera.set_parameter_f32("distance", 1.5);

        Self {
            camera,
            scene,
            start_time: Instant::now(),
            assets,
        }
    }

examples/cube.rs (lines 52-54)

    fn new() -> Self
    where
        Self: Sized,
    {
        let scene = Scene::from_static(
            vec![Batch2D::from_rectangle(0.0, 0.0, 200.0, 200.0)],
            vec![
                Batch3D::from_box(-0.5, -0.5, -0.5, 1.0, 1.0, 1.0)
                    .source(PixelSource::StaticTileIndex(0))
                    .cull_mode(CullMode::Off)
                    // Metallic material which is based on half of the
                    // saturation of the pixel color
                    .material(Material::new(
                        MaterialRole::Metallic,
                        MaterialModifier::Saturation,
                        0.6,
                        0.0,
                    ))
                    .with_computed_normals(),
            ],
        )
        .lights(vec![
            Light::new(LightType::Point)
                .with_intensity(1.0)
                .with_color([1.0, 1.0, 0.95])
                .compile(),
        ])
        .background(Box::new(VGrayGradientShader::new()));

        let assets = Assets::default().textures(vec![Tile::from_texture(Texture::from_image(
            Path::new("images/logo.png"),
        ))]);

        let mut camera = D3OrbitCamera::new();
        camera.set_parameter_f32("distance", 1.5);

        Self {
            camera,
            scene,
            start_time: Instant::now(),
            assets,
        }
    }

examples/cube_shaded.rs (lines 104-106)

    fn new() -> Self
    where
        Self: Sized,
    {
        let mut scene = Scene::from_static(
            vec![Batch2D::from_rectangle(0.0, 0.0, 200.0, 200.0)],
            vec![
                Batch3D::from_box(-0.5, -0.5, -0.5, 1.0, 1.0, 1.0)
                    .source(PixelSource::StaticTileIndex(0))
                    .cull_mode(CullMode::Off)
                    .ambient_color(Vec3::broadcast(0.3))
                    .shader(0)
                    .with_computed_normals(),
            ],
        )
        .lights(vec![
            Light::new(LightType::Point)
                .with_intensity(1.0)
                .with_color([1.0, 1.0, 0.95])
                .compile(),
        ])
        .background(Box::new(VGrayGradientShader::new()));

        scene.add_shader(
            r#"
            fn shade() {
                // Procedural wood: concentric growth rings warped by turbulence + fine grain.
                // Only the .x channel of textures is used (value channel).
                let t = time * 0.0;

                // Move and scale domain; center the rings roughly in the middle of each face.
                let uv2 = uv / 3.0 - vec2(1.5);

                // fBm turbulence (zero-mean) to warp the rings
                let n1 = sample(uv2 + vec2(t, 0.0), "fbm_perlin");   // [0,1]
                let n2 = sample(uv2 * 2.0 + vec2(0.0, t*0.7), "fbm_perlin");
                let turb = 0.65 * n1 + 0.35 * n2;                       // [0,1]
                let turb_zm = (turb - 0.5) * 2.0;                       // [-1,1]

                // Radial distance from center (log cross-section look)
                let r = length(uv2);

                // Warp rings by turbulence (phase modulation)
                let ring_freq = 10.0;            // number of rings
                let ring_warp = 0.22;            // strength of warp
                let rings = r + ring_warp * turb_zm;
                let waves = sin(rings * ring_freq);

                // Map sine to ring mask; sharpen valleys to make rings thinner
                let rings_mask = pow(1.0 - abs(waves), 3.0);

                // Fine longitudinal grain: high-frequency value noise stretched along X
                let grain_uv = vec2(uv2.x * 8.0, uv2.y * 40.0);
                let g = sample(grain_uv + vec2(0.0, t*0.5), "value");
                let grain = (g - 0.5) * 2.0;     // zero-mean

                // Base wood hues
                let base_light = vec3(0.72, 0.52, 0.32);
                let base_dark  = vec3(0.45, 0.30, 0.16);

                // Mix light/dark by ring mask
                color = mix(base_light, base_dark, rings_mask);

                // Apply subtle anisotropic grain as a multiplicative zero-mean factor
                color *= (1.0 + 0.06 * grain);

                // Optional pore streaks (cathedrals): directional bands along Y with slight turbulence
                let band = uv2.y + 0.15 * turb_zm;
                let cathedral = pow(1.0 - abs(sin(band * 6.0)), 4.0);
                color = mix(color, color * 0.9, cathedral * 0.2);

                // Roughness varies: pores are rougher, rings smoother
                roughness = 0.6 + cathedral * 0.3;

                // 16 Colors
                //let color_steps = 16.0;
                //color = floor(color * color_steps) / color_steps;
            }
        "#,
        );

        let assets = Assets::default().textures(vec![Tile::from_texture(Texture::from_image(
            Path::new("images/logo.png"),
        ))]);

        let mut camera = D3OrbitCamera::new();
        camera.set_parameter_f32("distance", 1.5);

        Self {
            camera,
            scene,
            start_time: Instant::now(),
            assets,
        }
    }

Trait Implementations

impl Clone for Assets

fn clone(&self) -> Assets

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for Assets

fn default() -> Self

Returns the “default value” for a type.